From: maintenance team <salome-mnt@opencascade.com>
Date: Fri, 24 Oct 2008 08:33:24 +0000 (+0000)
Subject: Changing ${INSTALL_ROOT} to ${INST_ROOT}
X-Git-Tag: before_merging_with_4X~4
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=77b1e8d9c27a60a9d7052b9d92d3d0b4c34dd81e;p=tools%2Finstall.git

Changing ${INSTALL_ROOT} to ${INST_ROOT}
---

diff --git a/config_files/BLSURFPLUGIN.sh b/config_files/BLSURFPLUGIN.sh
index ecd793d..8fd5050 100755
--- 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 96c957e..c586a0e 100755
--- 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 3004eca..24abaa5 100755
--- 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 614812d..9b65d51 100755
--- 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 b3ddb68..12f4811 100755
--- 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 3f5b10f..d5d2ecf 100755
--- 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 d16024e..7c5ae2e 100755
--- 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 2a17ec9..1debe3b 100755
--- 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 c7d0660..75d4eb7 100755
--- 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 24d611c..3fdb71a 100755
--- 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 005e47e..f64ab18 100755
--- 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 a510f4f..d4bef9a 100755
--- 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 31d2404..25fa4bb 100755
--- 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 bb2f6d4..ce2228e 100755
--- 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 8ea80b3..9bdacf9 100755
--- 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 2fbf236..4fc5cea 100755
--- 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 6f44272..819918a 100755
--- 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 4aebadd..f3edf87 100755
--- 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 d0b6c06..466ee07 100755
--- 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 83be209..f137380 100755
--- 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 568dc57..2d559db 100755
--- 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 9d73126..610bbd2 100755
--- 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 067b7f2..69099f0 100755
--- 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 f70c33b..25204e7 100755
--- 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 6928f71..85464f4 100755
--- 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 1e8b949..a1547e5 100755
--- 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 79e5bab..70a460c 100755
--- 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 0f42bc4..fc238bd 100755
--- 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 94d7e11..342cf06 100755
--- 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 1832138..c4d0e29 100755
--- 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 41d8db8..0bd7dc7 100755
--- 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 21d5d3a..0aabff8 100755
--- 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 8c07a88..75c5911 100755
--- 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 e168674..4375991 100755
--- 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 8f5b86b..b140099 100755
--- 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 a8f7901..fbc8063 100755
--- 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 621a656..11d2d70 100755
--- 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 8763e9c..2c7a1a5 100755
--- 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 667a0eb..71d2cc5 100755
--- 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 e8cd3f5..83ffb95 100755
--- 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 4cf45cb..e5869ca 100755
--- 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 9a9ecf0..ca92034 100755
--- 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 cef7b4a..c6124b3 100755
--- 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 801bc38..385d906 100755
--- 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 846a3be..2adbbd5 100755
--- 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 0b87195..7a7a19b 100755
--- 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 a01b29e..d72b90f 100755
--- 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 0754255..1ab7eca 100755
--- 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 374638e..17d1e8e 100755
--- 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 9489487..b0fe8b3 100755
--- 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 96ce77d..3ae4bf9 100755
--- 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 ae01ad5..1320f55 100755
--- 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 973d0df..3f19fa4 100755
--- 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 79b64a3..674686b 100755
--- 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 fb52910..42ad401 100755
--- 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 81ca238..736f264 100755
--- 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 6832485..e4c0326 100755
--- 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 cccf702..be007de 100755
--- 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 ebfb41f..386ff36 100755
--- 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 eb48113..860d59e 100755
--- 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