Changing ${INSTALL_ROOT} to ${INST_ROOT}

diff --git a/config_files/BLSURFPLUGIN.sh b/config_files/BLSURFPLUGIN.sh
index ecd793d593231a991d8c6f3486d624a636fbc553..8fd50503e7cced72adb37326638cd73bf2806112 100755 (executable)
--- a/config_files/BLSURFPLUGIN.sh
+++ b/config_files/BLSURFPLUGIN.sh
@@ -40,7 +40,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export BLSURFPLUGIN_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export BLSURFPLUGIN_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${BLSURFPLUGIN_ROOT_DIR}/bin/salome:\${PATH}
@@ -51,32 +51,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export BLSURFPLUGIN_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export BLSURFPLUGIN_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/BLSURFPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/BLSURFPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -91,15 +91,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT BLSURFPLUGIN
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT BLSURFPLUGIN
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT BLSURFPLUGIN
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT BLSURFPLUGIN
 fi
 
 cd $CUR_DIR
@@ -107,7 +107,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"BLSURFPLUGIN_BUILD" && rm -fr ${INSTALL_ROOT}/"BLSURFPLUGIN_BUILD"
+    test -d ${INST_ROOT}/"BLSURFPLUGIN_BUILD" && rm -fr ${INST_ROOT}/"BLSURFPLUGIN_BUILD"
 fi
 
 # to generate environment scripts
@@ -116,7 +116,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -127,7 +127,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/BLSURFPLUGINbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/BLSURFPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/BLSURFPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export BLSURFPLUGIN_ROOT_DIR=${PRODUCT_DIR}
@@ -142,7 +142,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -156,6 +156,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="BLSURFPLUGIN_${SALOME_VERSION}"
 export PRODUCT_SRC="BLSURFPLUGIN_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/BOOST-1.34.1.sh b/config_files/BOOST-1.34.1.sh
index 96c957ef12939d5dec85f6ca0006e5dbf8946de2..c586a0efca8123b0d01a197c8b398210514b6dfa 100755 (executable)
--- a/config_files/BOOST-1.34.1.sh
+++ b/config_files/BOOST-1.34.1.sh
@@ -26,13 +26,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export BOOSTDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export BOOSTDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export LD_LIBRARY_PATH=\${BOOSTDIR}/lib:\${LD_LIBRARY_PATH}
 export PATH=\${BOOSTDIR}/include:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -43,22 +43,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xzf ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xzf ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -72,6 +72,12 @@ install_source
 # build sources
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
+cd ${PRODUCT_SRC_DIR}/tools/jam/src
+
+chmod +w ./Jambase
+mv Jambase Jambase.orig
+sed -e 's/\/usr\/share\/boost-build/\$\(PRODUCT_SRC_DIR\)/g' Jambase.orig > Jambase
+
 GCC=`which gcc`
 cat >> ${PRODUCT_DIR}/BUILD.LOG <<EOF
 used gcc=$GCC
@@ -140,7 +146,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -155,7 +161,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -163,8 +169,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="boost-1.34.1"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/CALCULATOR.sh b/config_files/CALCULATOR.sh
index 3004ecac47ca03efdb7d4d2a43eea298bbe3c4c0..24abaa5a165c2d23584143b1dfa35317ef0eef23 100755 (executable)
--- a/config_files/CALCULATOR.sh
+++ b/config_files/CALCULATOR.sh
@@ -41,7 +41,7 @@ fi
 
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export CALCULATOR_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export CALCULATOR_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${CALCULATOR_ROOT_DIR}/bin/salome:\${PATH}
@@ -52,32 +52,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export CALCULATOR_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export CALCULATOR_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/CALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/CALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -92,19 +92,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT CALCULATOR
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT CALCULATOR
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"CALCULATOR_BUILD" && rm -fr ${INSTALL_ROOT}/"CALCULATOR_BUILD"
+    test -d ${INST_ROOT}/"CALCULATOR_BUILD" && rm -fr ${INST_ROOT}/"CALCULATOR_BUILD"
 fi
 
 # to generate environment scripts
@@ -113,14 +113,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/CALCULATORbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/CALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/CALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export CALCULATOR_ROOT_DIR=${PRODUCT_DIR}
@@ -141,7 +141,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -153,6 +153,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="CALCULATOR_${SALOME_VERSION}"
 export PRODUCT_SRC="CALCULATOR_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/CAS-6.3.sh b/config_files/CAS-6.3.sh
index 614812de5c991422a722d2744296b501793d11e9..9b65d5160158def94f1d2bbfdbd99e31c8e04be7 100755 (executable)
--- a/config_files/CAS-6.3.sh
+++ b/config_files/CAS-6.3.sh
@@ -35,7 +35,7 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export CASROOT=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export CASROOT=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${CASROOT}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${CASROOT}/lib:\${CASROOT}/lin/lib:\${LD_LIBRARY_PATH}
 # Variable for Foundation Classes : 
@@ -52,7 +52,7 @@ export MMGT_REENTRANT=1
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -63,23 +63,23 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled()
 {
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -195,7 +195,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -276,7 +276,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -284,8 +284,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="CAS-6.3"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/COMPONENT.sh b/config_files/COMPONENT.sh
index b3ddb685b4080f21b4def656d0a416897f1775f2..12f48117fd017e26b246aaab4e2b356cfc0bbd4e 100755 (executable)
--- a/config_files/COMPONENT.sh
+++ b/config_files/COMPONENT.sh
@@ -41,7 +41,7 @@ fi
 
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export COMPONENT_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export COMPONENT_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${COMPONENT_ROOT_DIR}/bin/salome:\${PATH}
@@ -52,32 +52,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export COMPONENT_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export COMPONENT_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/COMPONENTsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/COMPONENTsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -92,19 +92,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT COMPONENT
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT COMPONENT
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"COMPONENT_BUILD" && rm -fr ${INSTALL_ROOT}/"COMPONENT_BUILD"
+    test -d ${INST_ROOT}/"COMPONENT_BUILD" && rm -fr ${INST_ROOT}/"COMPONENT_BUILD"
 fi
 
 # to generate environment scripts
@@ -113,14 +113,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/COMPONENTbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/COMPONENTsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/COMPONENTsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export COMPONENT_ROOT_DIR=${PRODUCT_DIR}
@@ -135,7 +135,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -147,6 +147,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="COMPONENT_${SALOME_VERSION}"
 export PRODUCT_SRC="COMPONENT_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/DEBIANFORSALOME-3.1.sh b/config_files/DEBIANFORSALOME-3.1.sh
index 3f5b10fd88244b160caaa46440783c4ec9e73490..d5d2ecf2658c9cd10bef26d65b35da8fc3015e27 100755 (executable)
--- a/config_files/DEBIANFORSALOME-3.1.sh
+++ b/config_files/DEBIANFORSALOME-3.1.sh
@@ -21,24 +21,24 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export DEBIANFORSALOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export DEBIANFORSALOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${DEBIANFORSALOME}/bin:\${DEBIANFORSALOME}/bin/X11:\${PATH}
 export LD_LIBRARY_PATH=\${DEBIANFORSALOME}/extralibs:\${DEBIANFORSALOME}/lib:\${DEBIANFORSALOME}/bin/X11:\${LD_LIBRARY_PATH}
 export CPLUS_INCLUDE_PATH=\${DEBIANFORSALOME}/include/c++/3.3:\${DEBIANFORSALOME}/include/c++/3.3/i486-linux:\${DEBIANFORSALOME}/include/c++/3.3/backward
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 return $?
 }
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -55,7 +55,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -64,5 +64,5 @@ shift
 SINGLE_DIR=$9
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="DEBIANLIBS-3.1"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 $PROCEDURE

diff --git a/config_files/DOCUMENTATION.sh b/config_files/DOCUMENTATION.sh
index d16024e2f4d8af536bd4ff0d8cd1cb797ff530d8..7c5ae2e1973debdac16c7d0eb3d553e6010d6d46 100755 (executable)
--- a/config_files/DOCUMENTATION.sh
+++ b/config_files/DOCUMENTATION.sh
@@ -28,20 +28,20 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/DOCUMENTATIONsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/DOCUMENTATIONsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -62,7 +62,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -72,5 +72,5 @@ shift
 SINGLE_DIR=$9;
 export PRODUCT="DOCUMENTATION_${SALOME_VERSION}"
 export PRODUCT_SRC="DOCUMENTATION_SRC_${SALOME_VERSION}"
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/FILTER.sh b/config_files/FILTER.sh
index 2a17ec98a1566ca34eff573a92bfcad41c28dcf9..1debe3be66805f4fc59565577fc4df536b272724 100755 (executable)
--- a/config_files/FILTER.sh
+++ b/config_files/FILTER.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export FILTER_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export FILTER_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${FILTER_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export FILTER_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export FILTER_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/FILTERsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/FILTERsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,19 +89,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT FILTER
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT FILTER
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"FILTER_BUILD" && rm -fr ${INSTALL_ROOT}/"FILTER_BUILD"
+    test -d ${INST_ROOT}/"FILTER_BUILD" && rm -fr ${INST_ROOT}/"FILTER_BUILD"
 fi
 
 # to generate environment scripts
@@ -110,14 +110,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/FILTERbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/FILTERsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/FILTERsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export FILTER_ROOT_DIR=${PRODUCT_DIR}
@@ -132,7 +132,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -144,6 +144,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="FILTER_${SALOME_VERSION}"
 export PRODUCT_SRC="FILTER_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/GEOM.sh b/config_files/GEOM.sh
index c7d0660b44864ed8b78166ad4f112cd65a9dade3..75d4eb720360b309d1993be06ee16b71ea3b22fa 100755 (executable)
--- a/config_files/GEOM.sh
+++ b/config_files/GEOM.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export GEOM_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export GEOM_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${GEOM_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export GEOM_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export GEOM_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/GEOMsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/GEOMsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,15 +90,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT GEOM
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT GEOM
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT GEOM
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT GEOM
 fi
 
 cd $CUR_DIR
@@ -106,7 +106,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"GEOM_BUILD" && rm -fr ${INSTALL_ROOT}/"GEOM_BUILD"
+    test -d ${INST_ROOT}/"GEOM_BUILD" && rm -fr ${INST_ROOT}/"GEOM_BUILD"
 fi
 
 # to generate environment scripts
@@ -115,7 +115,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -126,7 +126,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/GEOMbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/GEOMsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/GEOMsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export GEOM_ROOT_DIR=${PRODUCT_DIR}
@@ -141,7 +141,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -155,6 +155,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="GEOM_${SALOME_VERSION}"
 export PRODUCT_SRC="GEOM_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/GHS3DPLUGIN.sh b/config_files/GHS3DPLUGIN.sh
index 24d611c2b48191f7b75c454cc5dd3a85c17c24a5..3fdb71a338902916c14599b2e7cb31d08a246f4f 100755 (executable)
--- a/config_files/GHS3DPLUGIN.sh
+++ b/config_files/GHS3DPLUGIN.sh
@@ -42,7 +42,7 @@ fi
 
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export GHS3DPLUGIN_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export GHS3DPLUGIN_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export LD_LIBRARY_PATH=\${GHS3DPLUGIN_ROOT_DIR}/lib${LIB_PREFIX}/salome:\${LD_LIBRARY_PATH}
@@ -52,32 +52,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export GHS3DPLUGIN_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export GHS3DPLUGIN_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/GHS3DPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/GHS3DPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -92,15 +92,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT GHS3DPLUGIN
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT GHS3DPLUGIN
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT GHS3DPLUGIN
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT GHS3DPLUGIN
 fi
 
 cd $CUR_DIR
@@ -108,7 +108,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"GHS3DPLUGIN_BUILD" && rm -fr ${INSTALL_ROOT}/"GHS3DPLUGIN_BUILD"
+    test -d ${INST_ROOT}/"GHS3DPLUGIN_BUILD" && rm -fr ${INST_ROOT}/"GHS3DPLUGIN_BUILD"
 fi
 
 # to generate environment scripts
@@ -117,7 +117,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -128,7 +128,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/GHS3DPLUGINbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/GHS3DPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/GHS3DPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export GHS3DPLUGIN_ROOT_DIR=${PRODUCT_DIR}
@@ -143,7 +143,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -157,6 +157,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="GHS3DPLUGIN_${SALOME_VERSION}"
 export PRODUCT_SRC="GHS3DPLUGIN_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/GHS3DPRLPLUGIN.sh b/config_files/GHS3DPRLPLUGIN.sh
index 005e47ef7aa3c8376be0fba8cdc13ca538fb1ede..f64ab186d3c7b4bb8afe0433e30c0011d3ed1797 100755 (executable)
--- a/config_files/GHS3DPRLPLUGIN.sh
+++ b/config_files/GHS3DPRLPLUGIN.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export GHS3DPRLPLUGIN_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export GHS3DPRLPLUGIN_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${GHS3DPRLPLUGIN_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export GHS3DPRLPLUGIN_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export GHS3DPRLPLUGIN_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/GHS3DPRLPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/GHS3DPRLPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,15 +89,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT GHS3DPRLPLUGIN
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT GHS3DPRLPLUGIN
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT GHS3DPRLPLUGIN
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT GHS3DPRLPLUGIN
 fi
 
 cd $CUR_DIR
@@ -105,7 +105,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"GHS3DPRLPLUGIN_BUILD" && rm -fr ${INSTALL_ROOT}/"GHS3DPRLPLUGIN_BUILD"
+    test -d ${INST_ROOT}/"GHS3DPRLPLUGIN_BUILD" && rm -fr ${INST_ROOT}/"GHS3DPRLPLUGIN_BUILD"
 fi
 
 # to generate environment scripts
@@ -114,7 +114,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -125,7 +125,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/GHS3DPRLPLUGINbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/GHS3DPRLPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/GHS3DPRLPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export GHS3DPRLPLUGIN_ROOT_DIR=${PRODUCT_DIR}
@@ -140,7 +140,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -154,6 +154,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="GHS3DPRLPLUGIN_${SALOME_VERSION}"
 export PRODUCT_SRC="GHS3DPRLPLUGIN_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/GUI.sh b/config_files/GUI.sh
index a510f4f887e2da14d259c46532185295550c1a56..d4bef9a85178db5ed967908decbe8573d53b88ea 100755 (executable)
--- a/config_files/GUI.sh
+++ b/config_files/GUI.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export GUI_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export GUI_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${GUI_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export GUI_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export GUI_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/GUIsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/GUIsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,19 +90,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT GUI
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT GUI
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"GUI_BUILD" && rm -fr ${INSTALL_ROOT}/"GUI_BUILD"
+    test -d ${INST_ROOT}/"GUI_BUILD" && rm -fr ${INST_ROOT}/"GUI_BUILD"
 fi
 
 # to generate environment scripts
@@ -111,14 +111,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/GUIbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/GUIsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/GUIsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export GUI_ROOT_DIR=${PRODUCT_DIR}
@@ -133,7 +133,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -145,6 +145,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="GUI_${SALOME_VERSION}"
 export PRODUCT_SRC="GUI_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/HELLO.sh b/config_files/HELLO.sh
index 31d2404c1902984dfceb1789c5af59b2af86bb99..25fa4bbd69330278da0a89105502d0777585b248 100755 (executable)
--- a/config_files/HELLO.sh
+++ b/config_files/HELLO.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export HELLO_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export HELLO_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${HELLO_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export HELLO_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export HELLO_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/HELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/HELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,19 +89,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT HELLO
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT HELLO
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"HELLO_BUILD" && rm -fr ${INSTALL_ROOT}/"HELLO_BUILD"
+    test -d ${INST_ROOT}/"HELLO_BUILD" && rm -fr ${INST_ROOT}/"HELLO_BUILD"
 fi
 
 # to generate environment scripts
@@ -110,14 +110,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/HELLObinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/HELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/HELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export HELLO_ROOT_DIR=${PRODUCT_DIR}
@@ -138,7 +138,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -150,6 +150,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="HELLO_${SALOME_VERSION}"
 export PRODUCT_SRC="HELLO_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/HXX2SALOME.sh b/config_files/HXX2SALOME.sh
index bb2f6d41c0bf4f52da9f427f9670905698d63eac..ce2228e941319b3ab0270657f66c6e6880cd6f26 100755 (executable)
--- a/config_files/HXX2SALOME.sh
+++ b/config_files/HXX2SALOME.sh
@@ -20,12 +20,12 @@ return 0
 print_env_bin(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export HXX2SALOME_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin
+export HXX2SALOME_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin
 export PATH=\${HXX2SALOME_ROOT_DIR}:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -36,21 +36,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/HXX2SALOMEsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/HXX2SALOMEsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -99,7 +99,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -116,7 +116,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -127,6 +127,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="HXX2SALOME_${SALOME_VERSION}"
 export PRODUCT_SRC="HXX2SALOME_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/HXX2SALOMEDOC.sh b/config_files/HXX2SALOMEDOC.sh
index 8ea80b34bf31450ea85b15c79d2a28d3dd840fa7..9bdacf9bb522aad5fdc776ef5af523500ff63a54 100755 (executable)
--- a/config_files/HXX2SALOMEDOC.sh
+++ b/config_files/HXX2SALOMEDOC.sh
@@ -24,7 +24,7 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -35,20 +35,20 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source(){
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/HXX2SALOMEDOCsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/HXX2SALOMEDOCsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -82,7 +82,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -93,6 +93,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="HXX2SALOMEDOC_${SALOME_VERSION}"
 export PRODUCT_SRC="HXX2SALOMEDOC_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/HexoticPLUGIN.sh b/config_files/HexoticPLUGIN.sh
index 2fbf2367e6c9fc71bce07222cb4870edf30c46f7..4fc5cea2139b0ea9d676e5415f1e8adf777ebac8 100755 (executable)
--- a/config_files/HexoticPLUGIN.sh
+++ b/config_files/HexoticPLUGIN.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export HexoticPLUGIN_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export HexoticPLUGIN_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${HexoticPLUGIN_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export HexoticPLUGIN_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export HexoticPLUGIN_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/HexoticPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/HexoticPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,15 +89,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT HexoticPLUGIN
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT HexoticPLUGIN
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT HexoticPLUGIN
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT HexoticPLUGIN
 fi
 
 cd $CUR_DIR
@@ -105,7 +105,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"HexoticPLUGIN_BUILD" && rm -fr ${INSTALL_ROOT}/"HexoticPLUGIN_BUILD"
+    test -d ${INST_ROOT}/"HexoticPLUGIN_BUILD" && rm -fr ${INST_ROOT}/"HexoticPLUGIN_BUILD"
 fi
 
 # to generate environment scripts
@@ -114,7 +114,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -125,7 +125,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/HexoticPLUGINbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/HexoticPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/HexoticPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export HexoticPLUGIN_ROOT_DIR=${PRODUCT_DIR}
@@ -140,7 +140,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -154,6 +154,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="HexoticPLUGIN_${SALOME_VERSION}"
 export PRODUCT_SRC="HexoticPLUGIN_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/KERNEL.sh b/config_files/KERNEL.sh
index 6f4427285b9040a3a870d85c23778899867115d6..819918a0603f5c2845b8687f891df4f79af63c3f 100755 (executable)
--- a/config_files/KERNEL.sh
+++ b/config_files/KERNEL.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export KERNEL_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export KERNEL_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${KERNEL_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export KERNEL_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export KERNEL_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/KERNELsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/KERNELsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,12 +90,12 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -c -d -v 0 -p $INSTALL_ROOT KERNEL
+cd ${INST_ROOT}
+check_jb ./build.sh -o -c -d -v 0 -p $INST_ROOT KERNEL
 
 # create environment for the built binaries
 cd $CUR_DIR
@@ -103,7 +103,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"KERNEL_BUILD" && rm -fr ${INSTALL_ROOT}/"KERNEL_BUILD"
+    test -d ${INST_ROOT}/"KERNEL_BUILD" && rm -fr ${INST_ROOT}/"KERNEL_BUILD"
 fi
 
 # to generate environment scripts
@@ -112,14 +112,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/KERNELbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/KERNELsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/KERNELsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # The next two symbolic links are created only for Red Hat 9 and Scientific Linux 3.0.5
 if [ -f /lib/libcrypto.so.0.9.7a ]; then
@@ -139,7 +139,7 @@ try_preinstalled
 
 pickup_env()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE} ${PRODUCT_DIR}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE} ${PRODUCT_DIR}
 if [ -d ${PRODUCT_DIR} ] ; then
     pushd ${PRODUCT_DIR} > /dev/null
     version=`cat bin/salome/VERSION | awk -F: '{print $2}' | tr -d '[:space:]'`
@@ -149,8 +149,8 @@ if [ -d ${PRODUCT_DIR} ] ; then
     cp -f ${PRODUCT_DIR}/salome.sh $dir/env.d
     popd > /dev/null
 fi
-create_config.sh ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_DIR}
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src ${PRODUCT_SRC_DIR}
+create_config.sh ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_DIR}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src ${PRODUCT_SRC_DIR}
 }
 
 source ./common.sh
@@ -158,7 +158,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -171,6 +171,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="KERNEL_${SALOME_VERSION}"
 export PRODUCT_SRC="KERNEL_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/LIGHT.sh b/config_files/LIGHT.sh
index 4aebadd05697a31be40409982acb3d7d01a41971..f3edf87f01d74c476014840a19ad26e8e9bccd1e 100755 (executable)
--- a/config_files/LIGHT.sh
+++ b/config_files/LIGHT.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export LIGHT_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export LIGHT_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export LD_LIBRARY_PATH=\${LIGHT_ROOT_DIR}/lib${LIB_PREFIX}/salome:\${LD_LIBRARY_PATH}
@@ -47,32 +47,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export LIGHT_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export LIGHT_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/LIGHTsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/LIGHTsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -87,19 +87,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT LIGHT
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT LIGHT
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"LIGHT_BUILD" && rm -fr ${INSTALL_ROOT}/"LIGHT_BUILD"
+    test -d ${INST_ROOT}/"LIGHT_BUILD" && rm -fr ${INST_ROOT}/"LIGHT_BUILD"
 fi
 
 # to generate environment scripts
@@ -108,14 +108,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/LIGHTbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/LIGHTsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/LIGHTsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export LIGHT_ROOT_DIR=${PRODUCT_DIR}
@@ -130,7 +130,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -142,6 +142,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="LIGHT_${SALOME_VERSION}"
 export PRODUCT_SRC="LIGHT_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/MED.sh b/config_files/MED.sh
index d0b6c0642e1c34b31c2138714788b56f4b6ba6ed..466ee070e63494e169b75cf50794f779f62d40e6 100755 (executable)
--- a/config_files/MED.sh
+++ b/config_files/MED.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export MED_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export MED_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${MED_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export MED_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export MED_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/MEDsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/MEDsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,15 +90,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT MED
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT MED
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT MED
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT MED
 fi
 
 cd $CUR_DIR
@@ -106,7 +106,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"MED_BUILD" && rm -fr ${INSTALL_ROOT}/"MED_BUILD"
+    test -d ${INST_ROOT}/"MED_BUILD" && rm -fr ${INST_ROOT}/"MED_BUILD"
 fi
 
 # to generate environment scripts
@@ -115,7 +115,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -126,7 +126,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/MEDbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/MEDsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/MEDsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export MED_ROOT_DIR=${PRODUCT_DIR}
@@ -141,7 +141,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -155,6 +155,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="MED_${SALOME_VERSION}"
 export PRODUCT_SRC="MED_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/MULTIPR.sh b/config_files/MULTIPR.sh
index 83be2095a206420fa21a891fd4134dd8c22693cc..f1373804eddc45ef0b709519a8220f3443c1a03b 100755 (executable)
--- a/config_files/MULTIPR.sh
+++ b/config_files/MULTIPR.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export MULTIPR_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export MULTIPR_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${MULTIPR_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export MULTIPR_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export MULTIPR_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/MULTIPRsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/MULTIPRsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,19 +89,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT MULTIPR
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT MULTIPR
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"MULTIPR_BUILD" && rm -fr ${INSTALL_ROOT}/"MULTIPR_BUILD"
+    test -d ${INST_ROOT}/"MULTIPR_BUILD" && rm -fr ${INST_ROOT}/"MULTIPR_BUILD"
 fi
 
 # to generate environment scripts
@@ -110,14 +110,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/MULTIPRbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/MULTIPRsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/MULTIPRsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export MULTIPR_ROOT_DIR=${PRODUCT_DIR}
@@ -132,7 +132,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -144,6 +144,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="MULTIPR_${SALOME_VERSION}"
 export PRODUCT_SRC="MULTIPR_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/NETGENPLUGIN.sh b/config_files/NETGENPLUGIN.sh
index 568dc57ca8714b0b856174315fda4f72e372542d..2d559db57f2c5e1eb9a1fefe664779fd17548f58 100755 (executable)
--- a/config_files/NETGENPLUGIN.sh
+++ b/config_files/NETGENPLUGIN.sh
@@ -40,7 +40,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export NETGENPLUGIN_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export NETGENPLUGIN_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export LD_LIBRARY_PATH=\${NETGENPLUGIN_ROOT_DIR}/lib${LIB_PREFIX}/salome:\${LD_LIBRARY_PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export NETGENPLUGIN_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export NETGENPLUGIN_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/NETGENPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/NETGENPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,15 +90,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT NETGENPLUGIN
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT NETGENPLUGIN
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT NETGENPLUGIN
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT NETGENPLUGIN
 fi
 
 cd $CUR_DIR
@@ -106,7 +106,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"NETGENPLUGIN_BUILD" && rm -fr ${INSTALL_ROOT}/"NETGENPLUGIN_BUILD"
+    test -d ${INST_ROOT}/"NETGENPLUGIN_BUILD" && rm -fr ${INST_ROOT}/"NETGENPLUGIN_BUILD"
 fi
 
 # to generate environment scripts
@@ -115,7 +115,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -126,7 +126,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/NETGENPLUGINbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/NETGENPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/NETGENPLUGINsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export NETGENPLUGIN_ROOT_DIR=${PRODUCT_DIR}
@@ -141,7 +141,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -155,6 +155,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="NETGENPLUGIN_${SALOME_VERSION}"
 export PRODUCT_SRC="NETGENPLUGIN_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/Numeric-24.2.sh b/config_files/Numeric-24.2.sh
index 9d731268a2bdcfcb4edf91416ff60396bd27d2d0..610bbd293a1576d90cc2be309a4af9393a68caa3 100755 (executable)
--- a/config_files/Numeric-24.2.sh
+++ b/config_files/Numeric-24.2.sh
@@ -25,11 +25,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PYTHONPATH=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/lib/python\${PYTHON_VERSION}/site-packages/Numeric:\${PYTHONPATH}
+export PYTHONPATH=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/lib/python\${PYTHON_VERSION}/site-packages/Numeric:\${PYTHONPATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -40,22 +40,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled()
 {
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -136,7 +136,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -151,7 +151,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -159,8 +159,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="Numeric-24.2"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/PYCALCULATOR.sh b/config_files/PYCALCULATOR.sh
index 067b7f289b0b5c0c4f4ffbe9693ef483f0b642e7..69099f00c5972fcfbf11f5d33e5ae960967a20b7 100755 (executable)
--- a/config_files/PYCALCULATOR.sh
+++ b/config_files/PYCALCULATOR.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PYCALCULATOR_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PYCALCULATOR_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${PYCALCULATOR_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export PYCALCULATOR_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export PYCALCULATOR_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/PYCALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/PYCALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,19 +90,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT PYCALCULATOR
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT PYCALCULATOR
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"PYCALCULATOR_BUILD" && rm -fr ${INSTALL_ROOT}/"PYCALCULATOR_BUILD"
+    test -d ${INST_ROOT}/"PYCALCULATOR_BUILD" && rm -fr ${INST_ROOT}/"PYCALCULATOR_BUILD"
 fi
 
 # to generate environment scripts
@@ -111,14 +111,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/PYCALCULATORbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/PYCALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/PYCALCULATORsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export PYCALCULATOR_ROOT_DIR=${PRODUCT_DIR}
@@ -133,7 +133,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -145,6 +145,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="PYCALCULATOR_${SALOME_VERSION}"
 export PRODUCT_SRC="PYCALCULATOR_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/PYHELLO.sh b/config_files/PYHELLO.sh
index f70c33b4a5730f7976009008862d8b0f8ff8df71..25204e70ce698b765c98d6cbad110246fcdad2b4 100755 (executable)
--- a/config_files/PYHELLO.sh
+++ b/config_files/PYHELLO.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PYHELLO_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PYHELLO_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${PYHELLO_ROOT_DIR}/bin/salome:\${PATH}
@@ -48,32 +48,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export PYHELLO_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export PYHELLO_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/PYHELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/PYHELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -88,19 +88,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT PYHELLO
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT PYHELLO
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"PYHELLO_BUILD" && rm -fr ${INSTALL_ROOT}/"PYHELLO_BUILD"
+    test -d ${INST_ROOT}/"PYHELLO_BUILD" && rm -fr ${INST_ROOT}/"PYHELLO_BUILD"
 fi
 
 # to generate environment scripts
@@ -109,14 +109,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/PYHELLObinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/PYHELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/PYHELLOsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export PYHELLO_ROOT_DIR=${PRODUCT_DIR}
@@ -136,7 +136,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -148,6 +148,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="PYHELLO_${SALOME_VERSION}"
 export PRODUCT_SRC="PYHELLO_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/PyQt-3.17.4.sh b/config_files/PyQt-3.17.4.sh
index 6928f71c194a99a016283b41f6bb08a23872098b..85464f4d8efc7c5cb44247231026962247c0bb63 100755 (executable)
--- a/config_files/PyQt-3.17.4.sh
+++ b/config_files/PyQt-3.17.4.sh
@@ -33,7 +33,7 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PYQTDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PYQTDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PYQT_SIPS=\${PYQTDIR}/sip
 export PATH=\${PYQTDIR}:\$PATH 
 export PYTHONPATH=\${PYQTDIR}:\${PYTHONPATH}
@@ -41,7 +41,7 @@ export LD_LIBRARY_PATH=\${PYQTDIR}:\$LD_LIBRARY_PATH
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -52,21 +52,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -110,7 +110,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -132,7 +132,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -140,8 +140,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="PyQt-3.17.4"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/Python-2.4.4.sh b/config_files/Python-2.4.4.sh
index 1e8b949607f6c548520d3aedf680826c0705bc37..a1547e5995300bff5d43b1d30cd647021083c6a7 100755 (executable)
--- a/config_files/Python-2.4.4.sh
+++ b/config_files/Python-2.4.4.sh
@@ -38,7 +38,7 @@ if [ -n "\${PYTHONPATH}" ] ; then
  export PYNATIVE=\${PYTHONPATH}
  export PYTHONPATH=""
 fi
-export PYTHONHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PYTHONHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${PYTHONHOME}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${PYTHONHOME}/lib:\${LD_LIBRARY_PATH}
 export PYTHON_VERSION=\`python -c "import sys; print sys.version[:3]"\`
@@ -47,7 +47,7 @@ export PYTHONPATH=\${PYTHONHOME}/lib/python\${PYTHON_VERSION}:\${PYNATIVE}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -58,18 +58,18 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 if test `uname -m` = "x86_64" ; then
@@ -83,7 +83,7 @@ else
     PYTHON_CONFIGURE_OPTIONS="--with-threads --with-cxx=`which g++` --enable-shared"
 fi
 
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # apply patch for 64-bit platforms
 #if test `uname -m` = "x86_64" ; then
@@ -148,7 +148,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -174,7 +174,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -182,8 +182,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="Python-2.4.4"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 ${PROCEDURE}

diff --git a/config_files/RANDOMIZER.sh b/config_files/RANDOMIZER.sh
index 79e5babfb47e049d5d61a7dd54e4f57e8df55f03..70a460c152a65abedb1f8a7166ab5b3bf12b371e 100755 (executable)
--- a/config_files/RANDOMIZER.sh
+++ b/config_files/RANDOMIZER.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export RANDOMIZER_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export RANDOMIZER_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${RANDOMIZER_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export RANDOMIZER_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export RANDOMIZER_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/RANDOMIZERsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/RANDOMIZERsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,19 +89,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT RANDOMIZER
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT RANDOMIZER
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"RANDOMIZER_BUILD" && rm -fr ${INSTALL_ROOT}/"RANDOMIZER_BUILD"
+    test -d ${INST_ROOT}/"RANDOMIZER_BUILD" && rm -fr ${INST_ROOT}/"RANDOMIZER_BUILD"
 fi
 
 # to generate environment scripts
@@ -110,14 +110,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/RANDOMIZERbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/RANDOMIZERsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/RANDOMIZERsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export RANDOMIZER_ROOT_DIR=${PRODUCT_DIR}
@@ -132,7 +132,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -144,6 +144,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="RANDOMIZER_${SALOME_VERSION}"
 export PRODUCT_SRC="RANDOMIZER_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/SAMPLES.sh b/config_files/SAMPLES.sh
index 0f42bc4a9e958b5097f6663c5326e3a3b8771634..fc238bd0ca1ac3a3b35a7c52f841cd505e6f2ff9 100755 (executable)
--- a/config_files/SAMPLES.sh
+++ b/config_files/SAMPLES.sh
@@ -24,24 +24,24 @@ return 1
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export DATA_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export DATA_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/SAMPLESsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/SAMPLESsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -62,7 +62,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -72,5 +72,5 @@ shift
 SINGLE_DIR=$9;
 export PRODUCT="SAMPLES_${SALOME_VERSION}"
 export PRODUCT_SRC="SAMPLES_SRC_${SALOME_VERSION}"
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/SIERPINSKY.sh b/config_files/SIERPINSKY.sh
index 94d7e118f8e889510e058a2aba459f239bd1e8a2..342cf0617cfadf98ad9666c6b19fe09faa2cac23 100755 (executable)
--- a/config_files/SIERPINSKY.sh
+++ b/config_files/SIERPINSKY.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export SIERPINSKY_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SIERPINSKY_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${SIERPINSKY_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export SIERPINSKY_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export SIERPINSKY_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/SIERPINSKYsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/SIERPINSKYsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,19 +89,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT SIERPINSKY
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT SIERPINSKY
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"SIERPINSKY_BUILD" && rm -fr ${INSTALL_ROOT}/"SIERPINSKY_BUILD"
+    test -d ${INST_ROOT}/"SIERPINSKY_BUILD" && rm -fr ${INST_ROOT}/"SIERPINSKY_BUILD"
 fi
 
 # to generate environment scripts
@@ -110,14 +110,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/SIERPINSKYbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/SIERPINSKYsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/SIERPINSKYsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export SIERPINSKY_ROOT_DIR=${PRODUCT_DIR}
@@ -132,7 +132,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -144,6 +144,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="SIERPINSKY_${SALOME_VERSION}"
 export PRODUCT_SRC="SIERPINSKY_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/SMESH.sh b/config_files/SMESH.sh
index 1832138711db6e407079e03b92023c6dcc69e25d..c4d0e298b11993ac4bf123133e758743d9e0e885 100755 (executable)
--- a/config_files/SMESH.sh
+++ b/config_files/SMESH.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export SMESH_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SMESH_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${SMESH_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export SMESH_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export SMESH_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/SMESHsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/SMESHsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,15 +90,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT SMESH
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT SMESH
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT SMESH
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT SMESH
 fi
 
 cd $CUR_DIR
@@ -106,7 +106,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"SMESH_BUILD" && rm -fr ${INSTALL_ROOT}/"SMESH_BUILD"
+    test -d ${INST_ROOT}/"SMESH_BUILD" && rm -fr ${INST_ROOT}/"SMESH_BUILD"
 fi
 
 # to generate environment scripts
@@ -115,7 +115,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -126,7 +126,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/SMESHbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/SMESHsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/SMESHsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export SMESH_ROOT_DIR=${PRODUCT_DIR}
@@ -141,7 +141,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -155,6 +155,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="SMESH_${SALOME_VERSION}"
 export PRODUCT_SRC="SMESH_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/SUPERV.sh b/config_files/SUPERV.sh
index 41d8db86067c436ab13a7f3b9dec8b452406db70..0bd7dc714691b78d8cc2f291fa75e4f70a9ada90 100755 (executable)
--- a/config_files/SUPERV.sh
+++ b/config_files/SUPERV.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export SUPERV_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SUPERV_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${SUPERV_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export SUPERV_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export SUPERV_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/SUPERVsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/SUPERVsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,19 +90,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT SUPERV
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT SUPERV
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"SUPERV_BUILD" && rm -fr ${INSTALL_ROOT}/"SUPERV_BUILD"
+    test -d ${INST_ROOT}/"SUPERV_BUILD" && rm -fr ${INST_ROOT}/"SUPERV_BUILD"
 fi
 
 # to generate environment scripts
@@ -111,14 +111,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/SUPERVbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/SUPERVsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/SUPERVsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export SUPERV_ROOT_DIR=${PRODUCT_DIR}
@@ -133,7 +133,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -145,6 +145,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="SUPERV_${SALOME_VERSION}"
 export PRODUCT_SRC="SUPERV_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/SWIG-1.3.31.sh b/config_files/SWIG-1.3.31.sh
index 21d5d3ab9d8339f445e24f44836b1302ce3067c5..0aabff8ca48948b3d975901bbaef464664eaefc5 100755 (executable)
--- a/config_files/SWIG-1.3.31.sh
+++ b/config_files/SWIG-1.3.31.sh
@@ -26,12 +26,12 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export SWIG_ROOT=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SWIG_ROOT=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${SWIG_ROOT}/bin:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -42,21 +42,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -105,7 +105,7 @@ install_source_and_build
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -114,8 +114,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="SWIG-1.3.31"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/VISU.sh b/config_files/VISU.sh
index 8c07a8819207136839ba08001f6b936ddde20089..75c59114d430a9bc58b25c6c85f04e98cdefc646 100755 (executable)
--- a/config_files/VISU.sh
+++ b/config_files/VISU.sh
@@ -39,7 +39,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export VISU_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export VISU_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${VISU_ROOT_DIR}/bin/salome:\${PATH}
@@ -50,32 +50,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export VISU_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export VISU_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/VISUsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/VISUsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,19 +90,19 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
-check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT VISU
+cd ${INST_ROOT}
+check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT VISU
 
 cd $CUR_DIR
 
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"VISU_BUILD" && rm -fr ${INSTALL_ROOT}/"VISU_BUILD"
+    test -d ${INST_ROOT}/"VISU_BUILD" && rm -fr ${INST_ROOT}/"VISU_BUILD"
 fi
 
 # to generate environment scripts
@@ -111,14 +111,14 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/VISUbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
-check_jb tar xfz ${SRC_DIR}/VISUsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/VISUsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export VISU_ROOT_DIR=${PRODUCT_DIR}
@@ -133,7 +133,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -145,6 +145,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="VISU_${SALOME_VERSION}"
 export PRODUCT_SRC="VISU_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/VTK-5.0.0.sh b/config_files/VTK-5.0.0.sh
index e168674a49d81ae966a0a743c829b9dfb6548375..437599151bcfd55edab3854fddbb6dd55792c481 100755 (executable)
--- a/config_files/VTK-5.0.0.sh
+++ b/config_files/VTK-5.0.0.sh
@@ -28,7 +28,7 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export VTKHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export VTKHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${VTKHOME}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${VTKHOME}/lib:\${LD_LIBRARY_PATH}
 export PYTHONPATH=\${VTKHOME}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
@@ -36,7 +36,7 @@ export TCLLIBPATH="\${VTKHOME}/lib/vtk-5.0/tcl \${TCLLIBPATH}"
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -47,18 +47,18 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 makedir ${PRODUCT_SRC_DIR}
@@ -227,7 +227,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -246,7 +246,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -254,8 +254,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="VTK-5.0.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/YACS.sh b/config_files/YACS.sh
index 8f5b86b53149b4ec4827580e51d811b3f3765f43..b1400998cab57aaf37699385ff75ca7f4de732db 100755 (executable)
--- a/config_files/YACS.sh
+++ b/config_files/YACS.sh
@@ -38,7 +38,7 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export YACS_ROOT_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export YACS_ROOT_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 if [ -n "\${ENV_FOR_LAUNCH}" ] ; then
   if [ "\${ENV_FOR_LAUNCH}" == "1" ] ; then
     export PATH=\${YACS_ROOT_DIR}/bin/salome:\${PATH}
@@ -49,32 +49,32 @@ fi
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE}_src $DELIM
-export YACS_SRC_DIR=\${INSTALL_ROOT}/${PRODUCT_SRC}
+export YACS_SRC_DIR=\${INST_ROOT}/${PRODUCT_SRC}
 ##
 EOF
 
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/YACSsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/YACSsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,15 +89,15 @@ install_source
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 if [ -e ./build.sh ] ; then
-    cp -f ./build.sh ${INSTALL_ROOT}
+    cp -f ./build.sh ${INST_ROOT}
 fi
 
 CUR_DIR=`pwd`
-cd ${INSTALL_ROOT}
+cd ${INST_ROOT}
 if [ $INST_WITH_GUI == "FALSE" ] ; then
-    check_jb ./build.sh -o -b -w -d -v 0 -p $INSTALL_ROOT YACS
+    check_jb ./build.sh -o -b -w -d -v 0 -p $INST_ROOT YACS
 else
-    check_jb ./build.sh -o -b -d -v 0 -p $INSTALL_ROOT YACS
+    check_jb ./build.sh -o -b -d -v 0 -p $INST_ROOT YACS
 fi
 
 cd $CUR_DIR
@@ -105,7 +105,7 @@ cd $CUR_DIR
 # remove sources and temporary files after building
 if [ ${REMOVE_SRC_TMP} == "TRUE" ] ; then
     test -d ${PRODUCT_SRC_DIR} && rm -fr ${PRODUCT_SRC_DIR}
-    test -d ${INSTALL_ROOT}/"YACS_BUILD" && rm -fr ${INSTALL_ROOT}/"YACS_BUILD"
+    test -d ${INST_ROOT}/"YACS_BUILD" && rm -fr ${INST_ROOT}/"YACS_BUILD"
 fi
 
 # to generate environment scripts
@@ -114,7 +114,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -125,7 +125,7 @@ if [ $INST_WITH_GUI == "FALSE" ] ; then
 else
     check_jb tar xfz ${SOURCE_DIR}/YACSbinariesV${SALOME_VERSION}.tar.gz -C ${PRODUCT_DIR}
 fi
-check_jb tar xfz ${SRC_DIR}/YACSsourcesV${SALOME_VERSION}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/YACSsourcesV${SALOME_VERSION}.tar.gz -C ${INST_ROOT}
 
 # modify all *.la files
 export YACS_ROOT_DIR=${PRODUCT_DIR}
@@ -140,7 +140,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -154,6 +154,6 @@ SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="YACS_${SALOME_VERSION}"
 export PRODUCT_SRC="YACS_SRC_${SALOME_VERSION}"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT_SRC}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT_SRC}
 $PROCEDURE 

diff --git a/config_files/blsurf-2.7.12.sh b/config_files/blsurf-2.7.12.sh
index a8f7901e4942dead25d91f512a76e9d93181e466..fbc80635e9b3bfd0ef4bb7c58fcfab8fc41b0497 100755 (executable)
--- a/config_files/blsurf-2.7.12.sh
+++ b/config_files/blsurf-2.7.12.sh
@@ -28,12 +28,12 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export BLSURFHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export BLSURFHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export LD_LIBRARY_PATH=\${BLSURFHOME}/lib${LIB_PREFIX}:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -44,12 +44,12 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
@@ -65,7 +65,7 @@ install_binary
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -80,7 +80,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -90,8 +90,8 @@ shift
 BIN_DIR=$9;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="blsurf-2.7.12"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/cElementTree-1.0.5.sh b/config_files/cElementTree-1.0.5.sh
index 621a656932c034cf5529752f8c1baac47960d405..11d2d707d04a9b7f3638d363d3966e8c90d9f23d 100755 (executable)
--- a/config_files/cElementTree-1.0.5.sh
+++ b/config_files/cElementTree-1.0.5.sh
@@ -21,12 +21,12 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export cElementTree_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export cElementTree_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PYTHONPATH=\${cElementTree_DIR}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -37,21 +37,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -83,7 +83,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -98,7 +98,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -107,8 +107,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="cElementTree-1.0.5"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/common.sh b/config_files/common.sh
index 8763e9c85c9b1ebe9af613a700d8dfce4dbf47e1..2c7a1a5f0491d48ec64572b81439826d766d0193 100755 (executable)
--- a/config_files/common.sh
+++ b/config_files/common.sh
@@ -116,10 +116,10 @@ if [ $# -eq 4 ] ; then
     product_env=${install_work}/env_${product_name}.sh
     (test -e ${product_env} && rm ${product_env} )
 fi
-### !!! writing salome.sh file !!!  -> define INSTALL_ROOT
+### !!! writing salome.sh file !!!  -> define INST_ROOT
 cat >> ${install_work}/$SHRC <<EOF
 #${DELIM} Setting products installation directory ${DELIM}
-export INSTALL_ROOT=${install_root}
+export INST_ROOT=${install_root}
 
 #${DELIM} Environment switch: 0 for SALOME building, 1 for SALOME launching ${DELIM}
 export ENV_FOR_LAUNCH=1

diff --git a/config_files/create_config.sh b/config_files/create_config.sh
index 667a0eb1e41501f0ba3f63c91a089757651b439d..71d2cc5d0fab802e0f00b061bd0298c6d7885a22 100755 (executable)
--- a/config_files/create_config.sh
+++ b/config_files/create_config.sh
@@ -14,7 +14,7 @@
 
 source ./common.sh
 
-export INSTALL_ROOT=$1
+export INST_ROOT=$1
 export INSTALL_WORK=$2
 export PRODUCT_SEQUENCE=$3
 export INSTALL_PRODUCTS=$4
@@ -24,7 +24,7 @@ export PRODUCT_DIR=$5
 CONFIG_FILE=${INSTALL_WORK}/config_appli.xml
 
 # create and source environment file
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 source ${INSTALL_WORK}/$SHRC
 
 # remove config file
@@ -38,7 +38,7 @@ touch ${CONFIG_FILE}
 echo "<application>" >> ${CONFIG_FILE}
 
 # <prerequisites> tag : path to the environment script
-echo "  <prerequisites path=\"${INSTALL_ROOT}/env_products.sh\"/>" >> ${CONFIG_FILE}
+echo "  <prerequisites path=\"${INST_ROOT}/env_products.sh\"/>" >> ${CONFIG_FILE}
 
 # begin <modules> tag
 echo "  <modules>" >> ${CONFIG_FILE}

diff --git a/config_files/docutils-0.3.9.sh b/config_files/docutils-0.3.9.sh
index e8cd3f5d2deb2d5bc0fd39e7579d0c2e5bd093c4..83ffb959a74863f52cccde550110a88dc8362ae2 100755 (executable)
--- a/config_files/docutils-0.3.9.sh
+++ b/config_files/docutils-0.3.9.sh
@@ -20,12 +20,12 @@ return 0
 print_env_bin(){
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PYTHONPATH=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
-export PATH=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin:\${PATH}
+export PYTHONPATH=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
+export PATH=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -36,22 +36,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -89,7 +89,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -115,7 +115,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -123,8 +123,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="docutils-0.3.9"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/doxygen-1.5.6.sh b/config_files/doxygen-1.5.6.sh
index 4cf45cb3833614b5a97c195020f0f54e3c854851..e5869caae0efc1327165eb4ebfb5134c9744d0b6 100755 (executable)
--- a/config_files/doxygen-1.5.6.sh
+++ b/config_files/doxygen-1.5.6.sh
@@ -33,11 +33,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export PATH=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin:\${PATH}
+export PATH=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/bin:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -48,22 +48,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -101,7 +101,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -116,7 +116,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -124,8 +124,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="doxygen-1.5.6"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/elementtree-1.2.6.sh b/config_files/elementtree-1.2.6.sh
index 9a9ecf04646ef95bd31515237c79b1939233208a..ca920342fa735caa39ac25f3d779ff2d32b32f05 100755 (executable)
--- a/config_files/elementtree-1.2.6.sh
+++ b/config_files/elementtree-1.2.6.sh
@@ -21,12 +21,12 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export elementtree_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export elementtree_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PYTHONPATH=\${elementtree_DIR}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -37,21 +37,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -83,7 +83,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -98,7 +98,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -107,8 +107,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="elementtree-1.2.6"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/gcc-common.sh b/config_files/gcc-common.sh
index cef7b4a69faae23ccb1e3428e01fe71f4c6720cf..c6124b3a0689e0435c66877ef3b0ccb84e56490b 100755 (executable)
--- a/config_files/gcc-common.sh
+++ b/config_files/gcc-common.sh
@@ -58,7 +58,7 @@ if [ -n "${gcc_root}" ] ; then
 #export LD_LIBRARY_PATH=${ld_library_path}
 ##
 EOF
-       make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+       make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 #######       THIS COULD BE USED FOR STRICT COMPARISON  ##############################
 #      if [ $maj_ver -eq 3 ] && [ $min_ver -eq 2 ] && [ $rel_ver -eq 0 ] ;  then 
 ######################################################################################
@@ -80,12 +80,12 @@ try_native
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
 export PRODUCT="gcc-$GCC_VERSION"
-export PRODUCT_DIR=${INSTALL_ROOT}/${PRODUCT}
+export PRODUCT_DIR=${INST_ROOT}/${PRODUCT}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/ghs3d-4.0.sh b/config_files/ghs3d-4.0.sh
index 801bc38bf4df4b6fc28d9af8ed049cbbe909a553..385d9064ddae8a83351b1222e50f13226d4fc998 100755 (executable)
--- a/config_files/ghs3d-4.0.sh
+++ b/config_files/ghs3d-4.0.sh
@@ -21,11 +21,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export PATH=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}/DISTENE/Tools/TetMesh-GHS3D4.0/bin:\$PATH
+export PATH=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}/DISTENE/Tools/TetMesh-GHS3D4.0/bin:\$PATH
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -36,12 +36,12 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
@@ -57,7 +57,7 @@ install_binary
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -72,7 +72,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -82,8 +82,8 @@ shift
 BIN_DIR=$9;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="ghs3d-4.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/graphviz-2.16.1.sh b/config_files/graphviz-2.16.1.sh
index 846a3be8e7a3bb48c3ca64228c553ee29c85d326..2adbbd5b7d2220935794a05af64f4e8dd437d521 100755 (executable)
--- a/config_files/graphviz-2.16.1.sh
+++ b/config_files/graphviz-2.16.1.sh
@@ -32,13 +32,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export GRAPHVIZHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export GRAPHVIZHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${GRAPHVIZHOME}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${GRAPHVIZHOME}/lib:\${GRAPHVIZHOME}/lib/graphviz:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -49,22 +49,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -103,7 +103,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -140,7 +140,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -148,8 +148,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="graphviz-2.16.1"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/hdf5-1.6.4.sh b/config_files/hdf5-1.6.4.sh
index 0b871958cadfa19c9bc33b05a5254c5bade368ad..7a7a19b6346557646e784a7add9515f2ec24a214 100755 (executable)
--- a/config_files/hdf5-1.6.4.sh
+++ b/config_files/hdf5-1.6.4.sh
@@ -35,13 +35,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export HDF5HOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export HDF5HOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${HDF5HOME}/bin:\$PATH
 export LD_LIBRARY_PATH=\${HDF5HOME}/lib:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -52,22 +52,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -109,7 +109,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -134,7 +134,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -142,8 +142,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="hdf5-1.6.4"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/libxml2-2.6.27.sh b/config_files/libxml2-2.6.27.sh
index a01b29ea1a5699ebc97e907f2fc294d1839985e4..d72b90f4769e2126befc26fb8682084cca9f3b22 100755 (executable)
--- a/config_files/libxml2-2.6.27.sh
+++ b/config_files/libxml2-2.6.27.sh
@@ -21,13 +21,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export LIBXML_DIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export LIBXML_DIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${LIBXML_DIR}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${LIBXML_DIR}/lib:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -38,21 +38,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -90,7 +90,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -115,7 +115,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -124,8 +124,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="libxml2-2.6.27"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/med-2.3.4.sh b/config_files/med-2.3.4.sh
index 0754255f32134bddc769ebb816b39ce27cea1f37..1ab7ecaf35e1bbbc5e379c150ddcd408432700b4 100755 (executable)
--- a/config_files/med-2.3.4.sh
+++ b/config_files/med-2.3.4.sh
@@ -30,13 +30,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export MED2HOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export MED2HOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${MED2HOME}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${MED2HOME}/lib:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -47,22 +47,22 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -99,11 +99,11 @@ if [ -e /etc/issue ] ; then
   grep -e "Fedora Core release 6" /etc/issue > /dev/null
   if [ $? == 0 ] ; then is_fedora6=1 ; fi
 fi
-if [ $is_mandriva2007 == 1 ] || [ $is_mandriva2008 == 1 ] || [ $is_fedora6 == 1 ] ; then
+
 chmod +w ./Makefile.am
 mv Makefile.am Makefile.am.orig
-sed -e 's/ include src tests tools doc / include src tools doc /g' Makefile.am.orig > Makefile.am
-fi
+sed -e 's/include src tests tools doc/include src tools doc/g' Makefile.am.orig > Makefile.am
+
 if [ $is_mandriva2006 == 1 ] || [ $is_mandriva2007 == 1 ]  || [ $is_mandriva2008 == 1 ] || [ $is_fedora4 == 1 ] || [ $is_fedora6 == 1 ] || [ $is_debian40 == 1 ] ; then
     if test `uname -m` = "x86_64" ; then
     echo "`pwd` -> ./configure --prefix=${PRODUCT_DIR} FFLAGS='-g -O2 -ffixed-line-length-none' CFLAGS=-m64 CXXFLAGS=-m64 >> ${PRODUCT_DIR}/CONFIGURE.LOG"
@@ -143,7 +143,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -196,7 +196,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -205,8 +205,8 @@ REMOVE_SRC_TMP=$8;
 shift
 SINGLE_DIR=$9
 export PRODUCT="med-2.3.4"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/metis-4.0.sh b/config_files/metis-4.0.sh
index 374638ef401ee7fb29893e23720ade082fea5cb5..17d1e8e49e02f30791a8e8403f69a32e5dd88be4 100755 (executable)
--- a/config_files/metis-4.0.sh
+++ b/config_files/metis-4.0.sh
@@ -21,11 +21,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export METISDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export METISDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -36,21 +36,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -72,7 +72,7 @@ install_binary
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -87,7 +87,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -97,8 +97,8 @@ shift
 BIN_DIR=$9;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="metis-4.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/msg2qm.sh b/config_files/msg2qm.sh
index 9489487680d3acab3d972b48dfacedd90f937846..b0fe8b3c30abdeb3b55a8d8773406e1c182af4a4 100755 (executable)
--- a/config_files/msg2qm.sh
+++ b/config_files/msg2qm.sh
@@ -25,12 +25,12 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export MSG2QM_ROOT=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export MSG2QM_ROOT=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${MSG2QM_ROOT}:\${PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -41,23 +41,23 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled()
 {
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -95,7 +95,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -110,7 +110,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -118,8 +118,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="msg2qm"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/netgen-4.5.sh b/config_files/netgen-4.5.sh
index 96ce77d146151eaf9589fe704e58117f02e7a9fc..3ae4bf91c32c01edaf24865bbc78ded799e86f46 100755 (executable)
--- a/config_files/netgen-4.5.sh
+++ b/config_files/netgen-4.5.sh
@@ -26,11 +26,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export NETGENHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export NETGENHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -41,21 +41,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 # unpack
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # apply general patch for SALOME
 if [ -f patches/netgen-4.5-for-SALOME.patch ] ; then
@@ -127,7 +127,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -142,7 +142,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -150,8 +150,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="netgen-4.5"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/omniORB-4.1.0.sh b/config_files/omniORB-4.1.0.sh
index ae01ad5930c1677c41417a2180cb0a63370b0a3e..1320f55a4f9fe3a4807b1a9e1f3a08fcd6258e31 100755 (executable)
--- a/config_files/omniORB-4.1.0.sh
+++ b/config_files/omniORB-4.1.0.sh
@@ -51,7 +51,7 @@ fi
 
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export OMNIORBDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export OMNIORBDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export OMNIORB_CONFIG=\${OMNIORBDIR}/.omniORB.cfg
 export PYTHONPATH=\${OMNIORBDIR}/lib${OMNI_LIB_PREFIX}:\${OMNIORBDIR}/lib${OMNI_LIB_PREFIX}/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
 export PATH=\$OMNIORBDIR/bin:\$PATH
@@ -64,7 +64,7 @@ InitRef = NameService=corbaname::`hostname`:2810
 EOF
 fi
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -75,18 +75,18 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 makedir ${PRODUCT_SRC_DIR}
@@ -178,7 +178,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -186,7 +186,7 @@ test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
 check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${PRODUCT_DIR}
 
-ln -sf ${PRODUCT_DIR} ${INSTALL_ROOT}/omni
+ln -sf ${PRODUCT_DIR} ${INST_ROOT}/omni
 
 cd ${PRODUCT_DIR}/bin
 sed -e "s%#\!.*python%#\!/usr/bin/env python%" omniidl > _omniidl
@@ -203,7 +203,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -211,8 +211,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="omniORB-4.1.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/qt-3.3.8.sh b/config_files/qt-3.3.8.sh
index 973d0df5af3291e5c3d517927a3fb4142699f87e..3f19fa4958e88d9b64fd1fbd2ca395f4654ca31b 100755 (executable)
--- a/config_files/qt-3.3.8.sh
+++ b/config_files/qt-3.3.8.sh
@@ -27,13 +27,13 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export QTDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export QTDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${QTDIR}/bin:\$PATH 
 export LD_LIBRARY_PATH=\${QTDIR}/lib:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -44,21 +44,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -111,14 +111,17 @@ GCC=`which gcc`
 cat >> ${PRODUCT_DIR}/MAKE.LOG <<EOF
 used gcc=$GCC
 EOF
-# small trick: INSTALL_ROOT is used inside qt-3.3.3 installation
-# so it should be set to empty string
-export INSTALL_ROOT_BACKUP=$INSTALL_ROOT
-export INSTALL_ROOT=""
+# small trick: INST_ROOT is used inside qt-3.3.3 installation
+# so it should be unset
+INSTALL_ROOT_PREV=$INSTALL_ROOT
+unset INSTALL_ROOT
+
 check_job ${PRODUCT_DIR}/MAKE.LOG make 
 check_job ${PRODUCT_DIR}/MAKEINSTALL.LOG make install
 
-export INSTALL_ROOT=$INSTALL_ROOT_BACKUP
+if [ "${INSTALL_ROOT_PREV}" != "" ] ; then
+    export INSTALL_ROOT=$INSTALL_ROOT_PREV
+fi
 
 for b in `find bin -mindepth 1 -maxdepth 1 -name "*"`; do
     b=`basename $b`;
@@ -156,7 +159,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -191,7 +194,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -199,8 +202,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="qt-3.3.8"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/qwt-4.2.0.sh b/config_files/qwt-4.2.0.sh
index 79b64a342fc035a39c643687b5918fdec88a772d..674686b6baf46f186c5077cb8200f017861c9633 100755 (executable)
--- a/config_files/qwt-4.2.0.sh
+++ b/config_files/qwt-4.2.0.sh
@@ -33,12 +33,12 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export QWTHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export QWTHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export LD_LIBRARY_PATH=\${QWTHOME}/lib:\${LD_LIBRARY_PATH} 
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -49,21 +49,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -78,6 +78,9 @@ install_source
 cd ${PRODUCT_SRC_DIR}
 test -z ${SINGLE_DIR} && makedir ${PRODUCT_DIR} || mkdir -p ${PRODUCT_DIR}
 
+INSTALL_ROOT_PREV=$INSTALL_ROOT
+unset INSTALL_ROOT
+
 qmake qwt.pro -o Makefile
 
 GCC=`which gcc`
@@ -86,6 +89,11 @@ used gcc=$GCC
 EOF
 
 check_job ${PRODUCT_DIR}/MAKE.LOG make 
+
+if [ "${INSTALL_ROOT_PREV}" != "" ] ; then
+    export INSTALL_ROOT=$INSTALL_ROOT_PREV
+fi
+
 cp -rf include lib ${PRODUCT_DIR}
 
 #du -sk ${PRODUCT_SRC_DIR} > ${PRODUCT_DIR}/size.log
@@ -102,7 +110,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -117,7 +125,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -125,8 +133,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="qwt-4.2.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/release_notes.sh b/config_files/release_notes.sh
index fb529107b4f141f03ffe5b863a4ca7a6afecee1f..42ad4015d680e7efb5cc27af96b5f520ae615d9d 100755 (executable)
--- a/config_files/release_notes.sh
+++ b/config_files/release_notes.sh
@@ -51,7 +51,7 @@ execute()
 #     $3 is the temporary directory path
 SCRIPT_DIR=`dirname $0`
 PROCEDURE=$1;
-INSTALL_ROOT=$2;
+INST_ROOT=$2;
 INSTALL_WORK=$3;
 
 # Run the procedure

diff --git a/config_files/scotch-4.0.sh b/config_files/scotch-4.0.sh
index 81ca2382f752271e921a1540ad15fdd69e6c759c..736f264ae2565d4db5642368ec6525c7a6e3c64e 100755 (executable)
--- a/config_files/scotch-4.0.sh
+++ b/config_files/scotch-4.0.sh
@@ -21,11 +21,11 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export SCOTCHDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SCOTCHDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -36,21 +36,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -72,7 +72,7 @@ install_binary
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -87,7 +87,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -97,8 +97,8 @@ shift
 BIN_DIR=$9;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="scotch-4.0"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE

diff --git a/config_files/sip-4.7.3.sh b/config_files/sip-4.7.3.sh
index 68324850d2ad71f86ef4768a8cf7c56ca4eaac69..e4c0326d06f7d1080751fe0a5e3d770a1e2d0ff0 100755 (executable)
--- a/config_files/sip-4.7.3.sh
+++ b/config_files/sip-4.7.3.sh
@@ -32,14 +32,14 @@ print_env_bin()
 
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export SIPDIR=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export SIPDIR=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${SIPDIR}/bin:\${PATH}
 export PYTHONPATH=\${SIPDIR}/lib/python\${PYTHON_VERSION}/site-packages:\${PYTHONPATH}
 export LD_LIBRARY_PATH=\${SIPDIR}/lib/python\${PYTHON_VERSION}/site-packages:\${LD_LIBRARY_PATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -50,21 +50,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SOURCE_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -108,7 +108,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -148,7 +148,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -156,8 +156,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="sip-4.7.3"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/start_salome.sh b/config_files/start_salome.sh
index cccf7024c72b45a14780eb0a4dc57d760e572db6..be007de80db8844d93e6cfa7884bf399cd6126b0 100755 (executable)
--- a/config_files/start_salome.sh
+++ b/config_files/start_salome.sh
@@ -16,8 +16,8 @@
 # Returns 0 in success and 1 if any error occurs.
 check_enabled()
 {
-    if [ -f ${INSTALL_ROOT}/env_products.sh ] ; then
-       source ${INSTALL_ROOT}/env_products.sh
+    if [ -f ${INST_ROOT}/env_products.sh ] ; then
+       source ${INST_ROOT}/env_products.sh
     fi
     if [ "${KERNEL_ROOT_DIR}" != "" ] && [ "${GUI_ROOT_DIR}" != "" ] && 
        [ -f ${KERNEL_ROOT_DIR}/bin/salome/runSalome ] ; then
@@ -30,8 +30,8 @@ check_enabled()
 # Returns 0 in success and 1 if any error occurs.
 execute()
 {
-    if [ -f ${INSTALL_ROOT}/env_products.sh ] ; then
-       source ${INSTALL_ROOT}/env_products.sh
+    if [ -f ${INST_ROOT}/env_products.sh ] ; then
+       source ${INST_ROOT}/env_products.sh
     fi
     if [ "${KERNEL_ROOT_DIR}" != "" ] && [ "${GUI_ROOT_DIR}" != "" ] && 
        [ -f ${KERNEL_ROOT_DIR}/bin/salome/runSalome ] ; then
@@ -50,7 +50,7 @@ execute()
 #     $3 is the temporary directory path
 SCRIPT_DIR=`dirname $0`
 PROCEDURE=$1;
-INSTALL_ROOT=$2;
+INST_ROOT=$2;
 INSTALL_WORK=$3;
 
 # Run the procedure

diff --git a/config_files/tcltk-8.4.14.sh b/config_files/tcltk-8.4.14.sh
index ebfb41ff8c9a4e678a0e0a8838bb017b90b80038..386ff363be4b534a2a254676ccfa867cad3c9458 100755 (executable)
--- a/config_files/tcltk-8.4.14.sh
+++ b/config_files/tcltk-8.4.14.sh
@@ -56,14 +56,14 @@ print_env_bin()
 {
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM
-export TCLHOME=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export TCLHOME=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${TCLHOME}/bin:\${PATH}
 export LD_LIBRARY_PATH=\${TCLHOME}/lib:\${LD_LIBRARY_PATH}
 export TCLLIBPATH="\${TCLHOME}/lib \${TCLHOME}/lib/tcl${VERSION} \${TCLHOME}/lib/tk${VERSION} \${TCLLIBPATH}"
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -74,18 +74,18 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
 mkdir -p ${PRODUCT_SRC_DIR}
@@ -216,7 +216,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a product directory
@@ -239,7 +239,7 @@ try_preinstalled
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -247,8 +247,8 @@ shift
 REMOVE_SRC_TMP=$8;
 test $# == 10 && shift && SINGLE_DIR=$9
 export PRODUCT="tcltk-8.4.14"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PRODUCT_WORK=${INSTALL_WORK}/${PRODUCT}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 source ./common.sh
 $PROCEDURE 

diff --git a/config_files/xdata-0.5.52.sh b/config_files/xdata-0.5.52.sh
index eb48113eee69a181d26333393fa7705137ed4b67..860d59efa0a0ab7959edf0dda6698a7aac80f9d5 100755 (executable)
--- a/config_files/xdata-0.5.52.sh
+++ b/config_files/xdata-0.5.52.sh
@@ -28,14 +28,14 @@ else
 fi
 cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh <<EOF 
 #$DELIM ${PRODUCT_TYPE} $DELIM 
-export XDATAROOT=\${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export XDATAROOT=\${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
 export PATH=\${XDATAROOT}/bin:\${PATH}
 export PYTHON_VERSION=\`python -c "import sys; print sys.version[:3]"\`
 export PYTHONPATH=\${XDATAROOT}/lib${PYTHON_LIB_PREFIX}/python\${PYTHON_VERSION}/site-packages/xdata:\${PYTHONPATH}
 ##
 EOF
 (test -w ${PRODUCT_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}.sh ${PRODUCT_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 print_env_src()
@@ -46,21 +46,21 @@ cat > ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh <<EOF
 ##
 EOF
 (test -w ${PRODUCT_SRC_DIR} && cp ${INSTALL_WORK}/env_${PRODUCT_TYPE}_src.sh ${PRODUCT_SRC_DIR})
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}"
 }
 
 try_preinstalled(){
-try_existing ${PRODUCT_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
-try_existing ${PRODUCT_SRC_DIR} ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+try_existing ${PRODUCT_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+try_existing ${PRODUCT_SRC_DIR} ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 return $?
 }
 
 install_source()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}_src
 source ${INSTALL_WORK}/$SHRC
 
-check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INSTALL_ROOT}
+check_jb tar xfz ${SRC_DIR}/${PRODUCT}.tar.gz -C ${INST_ROOT}
 
 # to generate environment scripts
 try_preinstalled
@@ -98,7 +98,7 @@ try_preinstalled
 
 install_binary()
 {
-make_env ${INSTALL_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
+make_env ${INST_ROOT} ${INSTALL_WORK} "${PRODUCT_SEQUENCE}" "${INSTALL_PRODUCTS}" ${PRODUCT_TYPE}
 source ${INSTALL_WORK}/$SHRC
 
 # create a module directory
@@ -115,7 +115,7 @@ source ./common.sh
 export PROCEDURE=$1;
 export INSTALL_WORK=$2;
 export SOURCE_DIR=$3;
-export INSTALL_ROOT=$4;
+export INST_ROOT=$4;
 export PRODUCT_SEQUENCE=$5;
 export PRODUCT_TYPE=$6;
 export INSTALL_PRODUCTS=$7;
@@ -126,6 +126,6 @@ shift
 SINGLE_DIR=$9;
 if [ -n "$SINGLE_DIR" ] ; then SINGLE_DIR=$SDIR_NAME; fi
 export PRODUCT="xdata-0.5.52"
-export PRODUCT_DIR=${INSTALL_ROOT}/${SINGLE_DIR:-${PRODUCT}}
-export PRODUCT_SRC_DIR=${INSTALL_ROOT}/${PRODUCT}_SRC
+export PRODUCT_DIR=${INST_ROOT}/${SINGLE_DIR:-${PRODUCT}}
+export PRODUCT_SRC_DIR=${INST_ROOT}/${PRODUCT}_SRC
 $PROCEDURE