scripts/hxx2salome

   1 #!/bin/bash
   2 #
   3 # directory where SALOME2 modules sources are stored. if present, generated module is created inside.
   4 SALOME_SRC_DIR=
   5 #
   6 # directory where you want to put build & install directories. may be the same than SALOME_SRC_DIR
   7 SALOME_BUILD_DIR=
   8 #
   9 # salome2 environment file (.bash or .sh)
  10 # if present, hxx2salome will try to compile new module, by sourcing ENVIRON_FILE file, and executing
  11 # build_configure, configure, make & make install
  12 # remark : hxx2salome has to be lanched with clean PATH, LD_LIBRARY_PATH & PYTHONPATH variables!
  13 ENVIRON_FILE=
  14 CONFIGURE_OPTION=--disable-debug
  15 #
  16 #
  17 usage()
  18 {
  19     echo -e "\n  Usage :\n"
  20     echo -e "  $HXX2SALOME_ROOT_DIR/hxx2salome cppComponent_root_dir cppComponent.hxx libcppComponent.so\n"
  21     echo -e "     - cppComponent_root_dir : install directory (absolute path) of the c++ component"
  22     echo -e "     - cppComponent.hxx : header of the component"
  23     echo -e "     - libcppComponent.so : library\n"
  24     echo -e "       (cppComponent.hxx and libcppComponent.so have to be found in cppComponent_root_dir)\n"
  25     exit
  26 }
  27 #
  28 welcome()
  29 {
  30     clear
  31     echo -e "\n\n"
  32     echo  "------------------------------------------------------------------------------------"
  33     echo
  34     echo  "                                hxx2salome"
  35     echo
  36     echo  "     Generation automatique d'un composant salome 2 à partir d'un composant C++"
  37     echo
  38     echo  "------------------------------------------------------------------------------------"
  39     echo
  40     echo
  41     echo
  42 }
  43 check_arguments()
  44 {
  45
  46     # check if $1 is a directory
  47     echo -e "-> check arguments\n"
  48     if [ ! -d $1 ]
  49     then
  50        echo -e "Error : directory $1 does not exist!\n"
  51        usage
  52     fi
  53     cpp_root_dir=$1
  54     echo "    C++ Component directory : ${cpp_root_dir}"
  55
  56     # look for include file $2
  57     nb=`find ${cpp_root_dir} -name $2 | wc -l` # number of files found, should be equal to 1
  58     extension=${2##*\.}
  59     if [ $nb -eq 0 ]
  60     then
  61           echo -e "\n  Error:\n  Include file $2 not found in $1 directory!\n"
  62           usage
  63     elif [ $nb -ge 2 ]
  64     then
  65          echo -e "\n  Error:\n  More than one file named $2 was found in $1!\n  Include file should be unique!"
  66          usage
  67     elif [ $extension != "hxx" -a $extension != "hh" -a $extension != "h" ]
  68     then
  69          echo -e "\n  Error:\n  Extension=$extension\n  Include file $2 should have extension .hxx .hh or .h !\n"
  70          usage
  71     fi
  72     hxx_file=`find ${cpp_root_dir} -name $2` # name of c++ header we will parse to generate salome module
  73     echo "    C++ Component header    : ${hxx_file}"
  74     hxx_dir=`dirname ${hxx_file}`
  75
  76     # look for library $3
  77     nb=`find ${cpp_root_dir} -name $3 | wc -l` # number of files found, should be equal to 1
  78     if [ $nb -eq 0 ]
  79     then
  80         echo -e "\n  Error:\n  Library file $3 not found in $1 directory!\n"
  81         usage
  82     elif [ $nb -ge 2 ]
  83     then
  84         echo -e "\n  Error:\n  More than one file named $3 was found in $1!\n  Library file should be unique!"
  85         usage
  86     fi
  87     so_file=`find ${cpp_root_dir} -name $3` # absolute path of library containing c++ module
  88     echo "    C++ Component library   : ${so_file}"
  89     lib_dir=`dirname ${so_file}`
  90     lib_file=${3%.so} # name without .so
  91     lib_file=${lib_file#lib} # name of library without lib an .so (needed by makefile)
  92 }
  93
  94 # retrieve python test file ending up with _test.py
  95 get_python_test_file()
  96 {
  97     cd ${cpp_root_dir}
  98     python_test_file=`ls *_test.py 2>/dev/null`
  99     if [ $? -eq 0 ]  # if there is python test file, copy them
 100     then
 101         cp ${python_test_file} ${tmp_dir}/${class_name}_SRC/src/${class_name}
 102     else
 103         python_test_file=""
 104     fi
 105     cd -
 106 }
 107 read_makefile_option()
 108 {
 109      echo -e -n "\n\nEnter new linking option :"
 110      read makefile_lib
 111      echo -e -n "\n\nEnter new include option :"
 112      read makefile_include
 113
 114 }
 115 get_info_makefile()
 116 {
 117     makefile_lib="-L\${${class_name}_CPP_ROOT}${lib_dir#${cpp_root_dir}} -l${lib_file}"
 118     makefile_include="-I\${${class_name}_CPP_ROOT}${hxx_dir#${cpp_root_dir}}"
 119     echo -e "\n\n[QUESTION]"
 120     echo -e "\nThe following option was generated to indicate where to find"
 121     echo -e "the needed libraries and include files when compiling and linking the c++ component :\n\n\t${makefile_lib}\n\t${makefile_include}"
 122     echo -e "\n\t(with \${${class_name}_CPP_ROOT} set to ${cpp_root_dir} at compile time)\n"
 123     echo -e "Do you want to modify it? (answer yes if something is wrong or a library is missing): "
 124     echo -e "                           answer no if flags are OK ):"
 125     read answer
 126     case $answer in
 127        y* | Y* | o* | O* ) read_makefile_option ;;
 128     esac
 129
 130     echo -e  "\nlinking option : $makefile_lib"
 131     echo -e  "include option : $makefile_include"
 132 }
 133
 134 compile()
 135 {
 136     clear
 137     echo "----------------- Compile ---------------------"
 138     make
 139     if [ $? -eq 0 ]
 140     then
 141         # compilation succeeded : we make install
 142         echo
 143         echo "----------------- Install ---------------------"
 144         make install
 145     else
 146         exit 1
 147     fi
 148 }
 149
 150 update_environ()
 151 {
 152     cp ${ENVIRON_FILE} ${ENVIRON_FILE}.old
 153     echo -e "##\n#------ ${class_name}-Src ------\nexport ${class_name}_SRC_DIR=${install_dir}/${class_name}_SRC" >> ${ENVIRON_FILE}
 154     echo -e "##\n#------ ${class_name}-Bin ------\nexport ${class_name}_ROOT_DIR=${SALOME_BUILD_DIR}/${class_name}_INSTALL" >> ${ENVIRON_FILE}
 155     echo -e "export ${class_name}_CPP_ROOT=${cpp_root_dir}" >> ${ENVIRON_FILE}
 156     echo -e "export LD_LIBRARY_PATH=\${${class_name}_CPP_ROOT}${lib_dir#${cpp_root_dir}}:\${LD_LIBRARY_PATH}" >> ${ENVIRON_FILE}
 157 }
 158
 159 good_bye()
 160 {
 161     echo -e "\n\nModule was created in ${install_dir}\nTo compile it, do the following : \n"
 162     echo -e "\tsetenv ${class_name}_CPP_ROOT ${cpp_root_dir}"
 163     echo -e "\tsetenv LD_LIBRARY_PATH \${${class_name}_CPP_ROOT}${lib_dir#${cpp_root_dir}}:\${LD_LIBRARY_PATH}"
 164     echo -e "\tcd ${install_dir}"
 165     echo -e "\t./build_configure"
 166     echo -e "\tcd build_directory"
 167     echo -e "\t${install_dir}/configure ${CONFIGURE_OPTION} --prefix=install_directory"
 168     echo -e "\tmake"
 169     echo -e "\tmake install"
 170     echo -e "\tsetenv ${class_name}_ROOT_DIR install_directory"
 171     echo -e "\tsource salome environment and run it"
 172     exit
 173 }
 174
 175 launch_salome()
 176 {
 177     ${KERNEL_ROOT_DIR}/bin/salome/runSalome --gui --modules=GEOM,SMESH,VISU,SUPERV,MED,`echo ${class_name}`  --containers=cpp,python --killall
 178 }
 179
 180 compile_module()
 181 {
 182     echo -e "\n-> Create build and install directories"
 183     if [ ! -d ${SALOME_BUILD_DIR} ]
 184     then
 185         SALOME_BUILD_DIR=${install_dir}
 186     else
 187         SALOME_BUILD_DIR=${SALOME_BUILD_DIR}/${class_name}
 188     fi
 189     if [ ! -d ${SALOME_BUILD_DIR} ]
 190     then
 191         mkdir ${SALOME_BUILD_DIR}
 192     fi
 193     if [ ! -d ${SALOME_BUILD_DIR}/${class_name}_BUILD ]
 194     then
 195         mkdir ${SALOME_BUILD_DIR}/${class_name}_BUILD
 196     fi
 197     if [ ! -d ${SALOME_BUILD_DIR}/${class_name}_INSTALL ]
 198     then
 199         mkdir ${SALOME_BUILD_DIR}/${class_name}_INSTALL
 200     fi
 201     rm -rf ${SALOME_BUILD_DIR}/${class_name}_INSTALL/* ${SALOME_BUILD_DIR}/${class_name}_BUILD/*
 202
 203
 204     echo -e "\n-> Source environment file ${ENVIRON_FILE}"
 205     export `echo ${class_name}`_ROOT_DIR=${SALOME_BUILD_DIR}/${class_name}_INSTALL
 206     export `echo ${class_name}`_CPP_ROOT=${cpp_root_dir}
 207     export LD_LIBRARY_PATH=${lib_dir}:${LD_LIBRARY_PATH}
 208     echo $CALC_CPP_DIR
 209     echo $CALC_ROOT_DIR
 210     echo LD_LIBRARY_PATH=$LD_LIBRARY_PATH
 211     echo
 212     echo -e "\n-> Build Configure"
 213     cd ${install_dir}/${class_name}_SRC
 214     ./build_configure
 215     cd ${SALOME_BUILD_DIR}/${class_name}_BUILD
 216     echo -e "\n-> Configure in ${SALOME_BUILD_DIR}/${class_name}_BUILD"
 217     ${install_dir}/${class_name}_SRC/configure ${CONFIGURE_OPTION} --prefix=${SALOME_BUILD_DIR}/${class_name}_INSTALL
 218    echo "Compile ?"
 219    echo
 220    read answer
 221    case $answer in
 222      y* | Y* | o* | O* )  compile ;;
 223      *) exit 1 ;;
 224    esac
 225    cd $SALOME_DIR
 226    export `echo ${SOURCE_NAME}`_ROOT_DIR=${INSTALL_ROOT_DIR}/${module}/${SOURCE_NAME}_INSTALL
 227 #  Mise à jour du script d'environnement
 228    echo -e "\n\n[QUESTION] Would you like to update your environment scrip  ${ENVIRON_FILE}?"
 229    echo -e -n "(add environment vaiable necessary to run and compile your salome component) : "
 230    read answer
 231    case $answer in
 232      y* | Y* | o* | O* )  update_environ ;;
 233    esac
 234
 235    echo -e -n "\n\n[QUESTION] Would you like to launch salome ?"
 236    read answer
 237    case $answer in
 238      y* | Y* | o* | O* )  launch_salome ;;
 239    esac
 240    echo "Good Bye!"
 241    exit
 242 }
 243 #
 244 #
 245 # ------------------------------------------------------------------------
 246 # --------------------------- MAIN PROGRAM -------------------------------
 247 # ------------------------------------------------------------------------
 248 #
 249 welcome # print some welcome info
 250 # check number of arguments
 251 #
 252 if [ $# -ne 3 ]
 253 then
 254    echo -e "\nBad number of arguments\n\n"
 255    usage
 256    exit
 257 fi
 258 check_arguments $1 $2 $3
 259 #
 260 # if there is an anvironment file, source it and set compilation flag
 261 if [ ${ENVIRON_FILE} ] && [ -f ${ENVIRON_FILE} ]
 262 then
 263    source ${ENVIRON_FILE}
 264    do_compile=1  # there is an environment file, we can compile
 265 else
 266    echo -e "\n[REMARK] NO environment file was specified, automatic compilation will not be done.\n\n"
 267 fi
 268 #
 269 if [ ${HXX2SALOME_ROOT_DIR} ] && [ -d ${HXX2SALOME_ROOT_DIR} ]
 270 then
 271     gene_dir=${HXX2SALOME_ROOT_DIR}
 272 else
 273     if [ ! -f parse1.awk -o ! -f parse2.awk ]
 274     then
 275         echo -e "\nError : Variable HXX2SALOME_ROOT_DIR shoud be set, or hxx2salome should be launched localy"
 276         usage
 277     else
 278         gene_dir=`pwd` # case where hxx2salome was launched from HXX2SALOME directory
 279     fi
 280 fi
 281 #
 282 # get class' name
 283 #
 284 class_name=`awk '$1 == "class" && $0 !~ /;/ {print $2}' ${hxx_file}`
 285 echo "    Name of class :" $class_name
 286 if [ ! $class_name ]
 287 then
 288     echo -e "\nError:\n  Sorry - No class definition was found!\n  Please check your header file\n"
 289     exit
 290 fi
 291 #
 292 # create temporary working directory
 293 #
 294 tmp_dir="/tmp/${class_name}_${USER}"
 295 if [ -d ${tmp_dir} ]
 296 then
 297     rm -rf ${tmp_dir}/*
 298 else
 299     mkdir ${tmp_dir}
 300 fi
 301 #
 302 # go in temporary directory to work on code generation
 303 cd ${tmp_dir}
 304 #
 305 #
 306 # -------------------------  parse hxx file and generate code  ---------------------------------------
 307 #
 308 echo -e "\n-> Extract public functions\n"
 309 cat ${hxx_file} | awk -f ${gene_dir}/parse1.awk > ${class_name}_public_functions
 310 cat ${class_name}_public_functions
 311 if [ ! -s ${class_name}_public_functions ]
 312 then
 313     echo -e "\nError:\n  Sorry - No compatible function was found!\n  Please check your header file\n"
 314     exit
 315 fi
 316 #
 317 echo -e "\n\n-> Parse public functions and generate Salome2 files\n\n  compatibility      function\n"
 318 cat ${class_name}_public_functions | awk -f ${gene_dir}/parse2.awk |\
 319 awk -v class_name=${class_name} -f ${gene_dir}/parse3.awk
 320 #
 321 # outputs
 322 echo -e "\n  IDL file:"
 323 cat parse_result > hxx2salome_journal
 324 echo -e "\n----------------- IDL file ------------------\n">>hxx2salome_journal
 325 cat code_idl >> hxx2salome_journal
 326 cat code_idl
 327 echo -e "\n----------------- hxx file ------------------\n" >> hxx2salome_journal
 328 cat code_hxx >> hxx2salome_journal
 329 echo -e "\n----------------- cxx file ------------------\n" >> hxx2salome_journal
 330 cat code_cxx >> hxx2salome_journal
 331 echo
 332 #
 333 #
 334 # -------------------  duplicates template module and insert generated code  ------------------------------
 335 #
 336 echo -e "\n-> Duplicate template module"
 337 cp -r ${gene_dir}/TEMPLATE_SRC ${class_name}_SRC
 338 ${gene_dir}/renameSalomeModule -i TEMPLATE ${class_name} ${class_name}_SRC >> hxx2salome_journal
 339 #
 340 echo -e "\n-> Substitute generated code in idl file"
 341 echo "// this idl file was generated by hxx2salome" > tmpfile
 342 cat ${class_name}_SRC/idl/${class_name}_Gen.idl |awk '
 343     $0 ~ "HXX2SALOME_IDL_CODE" {system("cat code_idl >> tmpfile")}
 344     $0 != "HXX2SALOME_IDL_CODE" { print $0 >> "tmpfile" }'
 345 mv tmpfile ${class_name}_SRC/idl/${class_name}_Gen.idl
 346 #
 347 echo -e "\n-> Substitute generated code in hxx file"
 348 echo "// this hxx file was generated by hxx2salome" > tmpfile
 349 cat ${class_name}_SRC/src/${class_name}/${class_name}_i.hxx |awk '
 350     $0 ~ "HXX2SALOME_HXX_CODE" {system("cat code_hxx >> tmpfile")}
 351     $0 !~ "HXX2SALOME" { print $0 >> "tmpfile" }'
 352 mv tmpfile ${class_name}_SRC/src/${class_name}/${class_name}_i.hxx
 353 #
 354 echo -e "\n-> Substitute generated code in cxx file"
 355 echo "// this cxx file was generated by hxx2salome" > tmpfile
 356 cat ${class_name}_SRC/src/${class_name}/${class_name}_i.cxx |awk -v cpp_include=$2 '
 357     $0 ~ "HXX2SALOME_CXX_CODE" {system("cat code_cxx >> tmpfile")}
 358     $0 ~ "HXX2SALOME_CPP_INCLUDE" { printf "#include \"%s\"\n",cpp_include >> "tmpfile" }
 359     $0 !~ "HXX2SALOME" { print $0 >> "tmpfile" }'
 360 mv tmpfile ${class_name}_SRC/src/${class_name}/${class_name}_i.cxx
 361 #
 362 # add flags in makefile
 363 get_python_test_file
 364 get_info_makefile
 365 echo -e "\n-> Substitute flags in Makefile.in"
 366 sed "s?HXX2SALOME_INCLUDE?${makefile_include}?g
 367      s?HXX2SALOME_PYTHON_FILE?${python_test_file}?g
 368      s?HXX2SALOME_LIB?${makefile_lib}?g
 369     " ${class_name}_SRC/src/${class_name}/Makefile.in > tmpfile
 370 mv tmpfile ${class_name}_SRC/src/${class_name}/Makefile.in
 371 #
 372 # generate component catalog
 373 if  [ $KERNEL_ROOT_DIR ]
 374 then
 375     echo -e "\n-> Generate component catalog\n\n" | tee hxx2salome_journal
 376     idlparser=${KERNEL_ROOT_DIR}/bin/salome/runIDLparser
 377     cd ${class_name}_SRC/resources
 378     VER=`cat ${KERNEL_ROOT_DIR}/bin/salome/VERSION | awk ' { print $NF }'` # extract number of version
 379     ${idlparser} -Wbcatalog=tmp.xml,icon=${class_name}.png,version=${VER} -I${KERNEL_ROOT_DIR}/idl/salome -I${MED_ROOT_DIR}/idl/salome ../idl/${class_name}_Gen.idl >> hxx2salome_journal 2>&1
 380     cat tmp.xml | sed 's/_Gen//g' > ${class_name}Catalog.xml
 381     rm tmp.xml
 382 else
 383     echo -e "\n-> CANNOT GENERATE component catalog : variable KERNEL_ROOT_DIR in not defined\n\n" | tee hxx2salome_journal
 384 fi
 385 #
 386 #
 387 # ---------------------  Installation of new module sources  ------------------------------------------------
 388 #
 389 today=`date +%b%d_%Hh%M`
 390 if [ ! -d ${SALOME_SRC_DIR} ] # ask for installation directory if not specified by SALOME_SRC_DIR
 391 then
 392    echo -e "\n\nThe new module ${class_name}_SRC was generated in ${tmp_dir}"
 393    echo -e -n "[QUESTION] In which directory do you want to move it? "
 394    read install_dir
 395 else
 396    install_dir=${SALOME_SRC_DIR}/${class_name}
 397    if [ ! -d ${install_dir} ] # create module directory if necessary
 398    then
 399       mkdir ${install_dir}
 400    fi
 401 fi
 402 if [ -d ${install_dir} ]
 403 then
 404     if [ -d ${install_dir}/${class_name}_SRC ]
 405     then
 406        echo -e "A module ${install_dir}/${class_name}_SRC already exist!"
 407        echo -e "It will be renamed ${class_name}_SRC_${today}"
 408        mv ${install_dir}/${class_name}_SRC ${install_dir}/${class_name}_SRC_${today}
 409     fi
 410     echo -> Create module ${class_name}_SRC in ${install_dir}
 411     mv ${tmp_dir}/${class_name}_SRC ${install_dir}
 412 fi
 413 #
 414 #
 415 # ------------------- Modification of Salome environment file  ---------------------------------------------
 416 #
 417 if [ ${do_compile} -eq 1 ]
 418 then
 419     echo -e -n "\n\n[QUESTION] Do you want to compile new module? "
 420     read answer
 421     case $answer in
 422        y* | Y* | o* | O* ) compile_module ;;
 423     esac
 424 fi
 425 good_bye
 426