config_files/patches/netgen-4.9.13-for-CMake.patch

   1 diff -Naur netgen-4.9.13.occ/Makefile.am netgen-4.9.13/Makefile.am
   2 --- netgen-4.9.13.occ/Makefile.am       2009-08-10 11:40:52.000000000 +0000
   3 +++ netgen-4.9.13/Makefile.am   2011-04-26 15:48:32.540050641 +0000
   4 @@ -2,7 +2,7 @@
   5
   6  METASOURCES = AUTO
   7
   8 -SUBDIRS = libsrc ng nglib tutorials doc windows
   9 +SUBDIRS = libsrc nglib tutorials doc windows
  10
  11  # TESTS = ng/netgen -batchmode
  12
  13 diff -Naur netgen-4.9.13.occ/build_cmake netgen-4.9.13/build_cmake
  14 --- netgen-4.9.13.occ/build_cmake       1970-01-01 00:00:00.000000000 +0000
  15 +++ netgen-4.9.13/build_cmake   2011-04-26 15:16:35.400428886 +0000
  16 @@ -0,0 +1,9 @@
  17 +#!/bin/sh
  18 +
  19 +CURRENT_DIR=`pwd`
  20 +CONF_DIR=`echo $0 | sed -e "s,[^/]*$,,;s,/$,,;s,^$,.,"`
  21 +cd ${CONF_DIR}
  22 +python cmake/am2cmake.py --netgen
  23 +status=$?
  24 +cd ${CURRENT_DIR}
  25 +exit $status
  26 diff -Naur netgen-4.9.13.occ/build_cmake.bat netgen-4.9.13/build_cmake.bat
  27 --- netgen-4.9.13.occ/build_cmake.bat   1970-01-01 00:00:00.000000000 +0000
  28 +++ netgen-4.9.13/build_cmake.bat       2011-04-26 15:16:50.690050021 +0000
  29 @@ -0,0 +1,2 @@
  30 +
  31 +%PYTHONBIN% cmake\am2cmake.py --netgen
  32 diff -Naur netgen-4.9.13.occ/cmake/FindCAS.cmake netgen-4.9.13/cmake/FindCAS.cmake
  33 --- netgen-4.9.13.occ/cmake/FindCAS.cmake       1970-01-01 00:00:00.000000000 +0000
  34 +++ netgen-4.9.13/cmake/FindCAS.cmake   2011-04-26 15:35:58.110362203 +0000
  35 @@ -0,0 +1,172 @@
  36 +#  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
  37 +#
  38 +#  This library is free software; you can redistribute it and/or
  39 +#  modify it under the terms of the GNU Lesser General Public
  40 +#  License as published by the Free Software Foundation; either
  41 +#  version 2.1 of the License.
  42 +#
  43 +#  This library is distributed in the hope that it will be useful,
  44 +#  but WITHOUT ANY WARRANTY; without even the implied warranty of
  45 +#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  46 +#  Lesser General Public License for more details.
  47 +#
  48 +#  You should have received a copy of the GNU Lesser General Public
  49 +#  License along with this library; if not, write to the Free Software
  50 +#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  51 +#
  52 +#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  53 +#
  54 +
  55 +SET(CASROOT $ENV{CASROOT})
  56 +
  57 +# SET(OCC_VERSION_MAJOR 6)
  58 +# SET(OCC_VERSION_MINOR 3)
  59 +# SET(OCC_VERSION_MAINTENANCE 10)
  60 +
  61 +SET(CAS_CPPFLAGS)
  62 +# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MAJOR=${OCC_VERSION_MAJOR})
  63 +# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MINOR=${OCC_VERSION_MINOR})
  64 +# SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DOCC_VERSION_MAINTENANCE=${OCC_VERSION_MAINTENANCE})
  65 +SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DLIN -DLINTEL -DCSFDB)
  66 +SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DNo_exception)
  67 +SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DHAVE_CONFIG_H)
  68 +SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -DHAVE_LIMITS_H)
  69 +SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -I${CASROOT}/inc)
  70 +
  71 +IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
  72 +  SET(CAS_CPPFLAGS ${CAS_CPPFLAGS} -D_OCC64)
  73 +ENDIF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
  74 +
  75 +IF(NOT WINDOWS)
  76 +  FIND_LIBRARY(Xmu Xmu)
  77 +  IF(Xmu)
  78 +    SET(CAS_LDPATH ${Xmu})
  79 +  ENDIF(Xmu)
  80 +ENDIF(NOT WINDOWS)
  81 +
  82 +IF(WINDOWS)
  83 +  IF(CMAKE_BUILD_TYPE STREQUAL Debug)
  84 +    SET(CASROOT_LIBDIR ${CASROOT}/win32/libd)
  85 +  ELSE(CMAKE_BUILD_TYPE STREQUAL Debug)
  86 +    SET(CASROOT_LIBDIR ${CASROOT}/win32/lib)
  87 +  ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
  88 +ELSE(WINDOWS)
  89 +  SET(CASROOT_LIBDIR ${CASROOT}/lib)
  90 +ENDIF(WINDOWS)
  91 +
  92 +FIND_LIBRARY(BinLPlugin BinLPlugin PATHS ${CASROOT_LIBDIR})
  93 +FIND_LIBRARY(BinPlugin BinPlugin PATHS ${CASROOT_LIBDIR})
  94 +FIND_LIBRARY(BinTObjPlugin BinTObjPlugin PATHS ${CASROOT_LIBDIR})
  95 +FIND_LIBRARY(BinXCAFPlugin BinXCAFPlugin PATHS ${CASROOT_LIBDIR})
  96 +FIND_LIBRARY(FWOSPlugin FWOSPlugin PATHS ${CASROOT_LIBDIR})
  97 +# FIND_LIBRARY(mscmd mscmd PATHS ${CASROOT_LIBDIR})
  98 +FIND_LIBRARY(PTKernel PTKernel PATHS ${CASROOT_LIBDIR})
  99 +FIND_LIBRARY(StdLPlugin StdLPlugin PATHS ${CASROOT_LIBDIR})
 100 +FIND_LIBRARY(StdPlugin StdPlugin PATHS ${CASROOT_LIBDIR})
 101 +FIND_LIBRARY(TKAdvTools TKAdvTools PATHS ${CASROOT_LIBDIR})
 102 +FIND_LIBRARY(TKBin TKBin PATHS ${CASROOT_LIBDIR})
 103 +FIND_LIBRARY(TKBinL TKBinL PATHS ${CASROOT_LIBDIR})
 104 +FIND_LIBRARY(TKBinTObj TKBinTObj PATHS ${CASROOT_LIBDIR})
 105 +FIND_LIBRARY(TKBinXCAF TKBinXCAF PATHS ${CASROOT_LIBDIR})
 106 +FIND_LIBRARY(TKBO TKBO PATHS ${CASROOT_LIBDIR})
 107 +FIND_LIBRARY(TKBool TKBool PATHS ${CASROOT_LIBDIR})
 108 +FIND_LIBRARY(TKBRep TKBRep PATHS ${CASROOT_LIBDIR})
 109 +FIND_LIBRARY(TKCAF TKCAF PATHS ${CASROOT_LIBDIR})
 110 +FIND_LIBRARY(TKCDF TKCDF PATHS ${CASROOT_LIBDIR})
 111 +# FIND_LIBRARY(TKCDLFront TKCDLFront PATHS ${CASROOT_LIBDIR})
 112 +# FIND_LIBRARY(TKCPPClient TKCPPClient PATHS ${CASROOT_LIBDIR})
 113 +# FIND_LIBRARY(TKCPPExt TKCPPExt PATHS ${CASROOT_LIBDIR})
 114 +# FIND_LIBRARY(TKCPPIntExt TKCPPIntExt PATHS ${CASROOT_LIBDIR})
 115 +# FIND_LIBRARY(TKCPPJini TKCPPJini PATHS ${CASROOT_LIBDIR})
 116 +# FIND_LIBRARY(TKCSFDBSchema TKCSFDBSchema PATHS ${CASROOT_LIBDIR})
 117 +# FIND_LIBRARY(TKDCAF TKDCAF PATHS ${CASROOT_LIBDIR})
 118 +# FIND_LIBRARY(TKDraw TKDraw PATHS ${CASROOT_LIBDIR})
 119 +FIND_LIBRARY(TKernel TKernel PATHS ${CASROOT_LIBDIR})
 120 +FIND_LIBRARY(TKFeat TKFeat PATHS ${CASROOT_LIBDIR})
 121 +FIND_LIBRARY(TKFillet TKFillet PATHS ${CASROOT_LIBDIR})
 122 +FIND_LIBRARY(TKG2d TKG2d PATHS ${CASROOT_LIBDIR})
 123 +FIND_LIBRARY(TKG3d TKG3d PATHS ${CASROOT_LIBDIR})
 124 +FIND_LIBRARY(TKGeomAlgo TKGeomAlgo PATHS ${CASROOT_LIBDIR})
 125 +FIND_LIBRARY(TKGeomBase TKGeomBase PATHS ${CASROOT_LIBDIR})
 126 +FIND_LIBRARY(TKHLR TKHLR PATHS ${CASROOT_LIBDIR})
 127 +# FIND_LIBRARY(TKIDLFront TKIDLFront PATHS ${CASROOT_LIBDIR})
 128 +FIND_LIBRARY(TKIGES TKIGES PATHS ${CASROOT_LIBDIR})
 129 +FIND_LIBRARY(TKLCAF TKLCAF PATHS ${CASROOT_LIBDIR})
 130 +FIND_LIBRARY(TKMath TKMath PATHS ${CASROOT_LIBDIR})
 131 +FIND_LIBRARY(TKMesh TKMesh PATHS ${CASROOT_LIBDIR})
 132 +FIND_LIBRARY(TKMeshVS TKMeshVS PATHS ${CASROOT_LIBDIR})
 133 +FIND_LIBRARY(TKNIS TKNIS PATHS ${CASROOT_LIBDIR})
 134 +FIND_LIBRARY(TKOffset TKOffset PATHS ${CASROOT_LIBDIR})
 135 +FIND_LIBRARY(TKOpenGl TKOpenGl PATHS ${CASROOT_LIBDIR})
 136 +FIND_LIBRARY(TKPCAF TKPCAF PATHS ${CASROOT_LIBDIR})
 137 +FIND_LIBRARY(TKPLCAF TKPLCAF PATHS ${CASROOT_LIBDIR})
 138 +FIND_LIBRARY(TKPrim TKPrim PATHS ${CASROOT_LIBDIR})
 139 +FIND_LIBRARY(TKPShape TKPShape PATHS ${CASROOT_LIBDIR})
 140 +FIND_LIBRARY(TKService TKService PATHS ${CASROOT_LIBDIR})
 141 +FIND_LIBRARY(TKShapeSchema TKShapeSchema PATHS ${CASROOT_LIBDIR})
 142 +FIND_LIBRARY(TKShHealing TKShHealing PATHS ${CASROOT_LIBDIR})
 143 +FIND_LIBRARY(TKStdLSchema TKStdLSchema PATHS ${CASROOT_LIBDIR})
 144 +FIND_LIBRARY(TKStdSchema TKStdSchema PATHS ${CASROOT_LIBDIR})
 145 +FIND_LIBRARY(TKSTEP TKSTEP PATHS ${CASROOT_LIBDIR})
 146 +FIND_LIBRARY(TKSTEP209 TKSTEP209 PATHS ${CASROOT_LIBDIR})
 147 +FIND_LIBRARY(TKSTEPAttr TKSTEPAttr PATHS ${CASROOT_LIBDIR})
 148 +FIND_LIBRARY(TKSTEPBase TKSTEPBase PATHS ${CASROOT_LIBDIR})
 149 +FIND_LIBRARY(TKSTL TKSTL PATHS ${CASROOT_LIBDIR})
 150 +# FIND_LIBRARY(TKTCPPExt TKTCPPExt PATHS ${CASROOT_LIBDIR})
 151 +FIND_LIBRARY(TKTObj TKTObj PATHS ${CASROOT_LIBDIR})
 152 +# FIND_LIBRARY(TKTObjDRAW TKTObjDRAW PATHS ${CASROOT_LIBDIR})
 153 +FIND_LIBRARY(TKTopAlgo TKTopAlgo PATHS ${CASROOT_LIBDIR})
 154 +# FIND_LIBRARY(TKTopTest TKTopTest PATHS ${CASROOT_LIBDIR})
 155 +FIND_LIBRARY(TKV2d TKV2d PATHS ${CASROOT_LIBDIR})
 156 +FIND_LIBRARY(TKV3d TKV3d PATHS ${CASROOT_LIBDIR})
 157 +# FIND_LIBRARY(TKViewerTest TKViewerTest PATHS ${CASROOT_LIBDIR})
 158 +FIND_LIBRARY(TKVRML TKVRML PATHS ${CASROOT_LIBDIR})
 159 +# FIND_LIBRARY(TKWOK TKWOK PATHS ${CASROOT_LIBDIR})
 160 +# FIND_LIBRARY(TKWOKTcl TKWOKTcl PATHS ${CASROOT_LIBDIR})
 161 +FIND_LIBRARY(TKXCAF TKXCAF PATHS ${CASROOT_LIBDIR})
 162 +FIND_LIBRARY(TKXCAFSchema TKXCAFSchema PATHS ${CASROOT_LIBDIR})
 163 +# FIND_LIBRARY(TKXDEDRAW TKXDEDRAW PATHS ${CASROOT_LIBDIR})
 164 +FIND_LIBRARY(TKXDEIGES TKXDEIGES PATHS ${CASROOT_LIBDIR})
 165 +FIND_LIBRARY(TKXDESTEP TKXDESTEP PATHS ${CASROOT_LIBDIR})
 166 +FIND_LIBRARY(TKXMesh TKXMesh PATHS ${CASROOT_LIBDIR})
 167 +FIND_LIBRARY(TKXml TKXml PATHS ${CASROOT_LIBDIR})
 168 +FIND_LIBRARY(TKXmlL TKXmlL PATHS ${CASROOT_LIBDIR})
 169 +FIND_LIBRARY(TKXmlTObj TKXmlTObj PATHS ${CASROOT_LIBDIR})
 170 +FIND_LIBRARY(TKXmlXCAF TKXmlXCAF PATHS ${CASROOT_LIBDIR})
 171 +FIND_LIBRARY(TKXSBase TKXSBase PATHS ${CASROOT_LIBDIR})
 172 +# FIND_LIBRARY(TKXSDRAW TKXSDRAW PATHS ${CASROOT_LIBDIR})
 173 +# FIND_LIBRARY(wokcmd wokcmd PATHS ${CASROOT_LIBDIR})
 174 +# FIND_LIBRARY(wokdeliverysteps wokdeliverysteps PATHS ${CASROOT_LIBDIR})
 175 +# FIND_LIBRARY(wokdfltsteps wokdfltsteps PATHS ${CASROOT_LIBDIR})
 176 +# FIND_LIBRARY(wokobjssteps wokobjssteps PATHS ${CASROOT_LIBDIR})
 177 +# FIND_LIBRARY(wokorbixsteps wokorbixsteps PATHS ${CASROOT_LIBDIR})
 178 +# FIND_LIBRARY(woksteps woksteps PATHS ${CASROOT_LIBDIR})
 179 +# FIND_LIBRARY(woktoolscmd woktoolscmd PATHS ${CASROOT_LIBDIR})
 180 +# FIND_LIBRARY(wokutilscmd wokutilscmd PATHS ${CASROOT_LIBDIR})
 181 +FIND_LIBRARY(XCAFPlugin XCAFPlugin PATHS ${CASROOT_LIBDIR})
 182 +FIND_LIBRARY(XmlLPlugin XmlLPlugin PATHS ${CASROOT_LIBDIR})
 183 +FIND_LIBRARY(XmlPlugin XmlPlugin PATHS ${CASROOT_LIBDIR})
 184 +FIND_LIBRARY(XmlTObjPlugin XmlTObjPlugin PATHS ${CASROOT_LIBDIR})
 185 +FIND_LIBRARY(XmlXCAFPlugin XmlXCAFPlugin PATHS ${CASROOT_LIBDIR})
 186 +
 187 +SET(CAS_KERNEL ${TKernel} ${TKMath})
 188 +SET(CAS_OCAF ${TKernel} ${TKMath} ${TKCDF} ${TKLCAF})
 189 +SET(CAS_VIEWER ${TKService} ${TKV3d} ${TKG3d} ${TKGeomBase} ${TKBRep})
 190 +SET(CAS_OCAFVIS ${TKCAF} ${TKBRep} ${TKG2d})
 191 +SET(CAS_MODELER ${TKG3d} ${TKGeomBase} ${TKGeomAlgo} ${TKBRep} ${TKTopAlgo} ${TKG2d})
 192 +
 193 +SET(TKV3d_EA ${TKernel} ${TKMath} ${TKV3d})
 194 +SET(TKBool_EA ${TKernel} ${TKMath} ${TKBRep} ${TKG2d} ${TKG3d} ${TKGeomBase} ${TKGeomAlgo} ${TKTopAlgo} ${TKBool})
 195 +SET(TKBRep_EA ${TKernel} ${TKMath} ${TKBRep})
 196 +SET(TKIGES_EA ${TKernel} ${TKMath} ${TKXSBase} ${TKBRep} ${TKIGES})
 197 +SET(TKSTEP_EA ${TKernel} ${TKMath} ${TKXSBase} ${TKBRep} ${TKSTEP})
 198 +SET(TKSTL_EA ${TKernel} ${TKMath} ${TKSTL})
 199 +SET(TKCAF_EA ${TKPrim} ${TKCAF})
 200 +
 201 +SET(TKV3d ${TKV3d_EA})
 202 +SET(TKBool ${TKBool_EA})
 203 +SET(TKBRep ${TKBRep_EA})
 204 +SET(TKIGES ${TKIGES_EA})
 205 +SET(TKSTEP ${TKSTEP_EA})
 206 +SET(TKSTL ${TKSTL_EA})
 207 +SET(TKCAF ${TKCAF_EA})
 208 diff -Naur netgen-4.9.13.occ/cmake/FindPLATFORM.cmake netgen-4.9.13/cmake/FindPLATFORM.cmake
 209 --- netgen-4.9.13.occ/cmake/FindPLATFORM.cmake  1970-01-01 00:00:00.000000000 +0000
 210 +++ netgen-4.9.13/cmake/FindPLATFORM.cmake      2011-04-28 08:11:30.203175382 +0000
 211 @@ -0,0 +1,119 @@
 212 +#  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
 213 +#
 214 +#  This library is free software; you can redistribute it and/or
 215 +#  modify it under the terms of the GNU Lesser General Public
 216 +#  License as published by the Free Software Foundation; either
 217 +#  version 2.1 of the License.
 218 +#
 219 +#  This library is distributed in the hope that it will be useful,
 220 +#  but WITHOUT ANY WARRANTY; without even the implied warranty of
 221 +#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 222 +#  Lesser General Public License for more details.
 223 +#
 224 +#  You should have received a copy of the GNU Lesser General Public
 225 +#  License along with this library; if not, write to the Free Software
 226 +#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 227 +#
 228 +#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 229 +#
 230 +
 231 +MARK_AS_ADVANCED(ISSUE)
 232 +FIND_FILE(ISSUE issue /etc)
 233 +IF(ISSUE)
 234 +  SET(WINDOWS 0)
 235 +ELSE()
 236 +  SET(WINDOWS 1)
 237 +ENDIF(ISSUE)
 238 +
 239 +IF(WINDOWS)
 240 +  SET(MACHINE WINDOWS)
 241 +ELSE(WINDOWS)
 242 +  SET(MACHINE PCLINUX)
 243 +ENDIF(WINDOWS)
 244 +
 245 +SET(CMAKE_INSTALL_PREFIX_ENV $ENV{CMAKE_INSTALL_PREFIX})
 246 +IF(CMAKE_INSTALL_PREFIX_ENV)
 247 +  SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX_ENV} CACHE PATH "installation prefix" FORCE)
 248 +ENDIF(CMAKE_INSTALL_PREFIX_ENV)
 249 +
 250 +IF(NOT CMAKE_BUILD_TYPE)
 251 +  SET(CMAKE_BUILD_TYPE $ENV{CMAKE_BUILD_TYPE})
 252 +ENDIF(NOT CMAKE_BUILD_TYPE)
 253 +
 254 +IF(NOT CMAKE_BUILD_TYPE)
 255 +  SET(CMAKE_BUILD_TYPE Release)
 256 +ENDIF(NOT CMAKE_BUILD_TYPE)
 257 +
 258 +IF(WINDOWS)
 259 +ELSE(WINDOWS)
 260 +  SET(ADD_WERROR ON)
 261 +  SET(NAMES ACCEPT_SALOME_WARNINGS ACCEPT_${MODULE}_WARNINGS I_AM_A_TROLL_I_DO_NOT_FIX_${MODULE}_WARNINGS)
 262 +  FOREACH(name ${NAMES})
 263 +    SET(VAL $ENV{${name}})
 264 +    IF(X${VAL} STREQUAL X0)
 265 +      SET(ADD_WERROR ON)
 266 +    ENDIF(X${VAL} STREQUAL X0)
 267 +    IF(X${VAL} STREQUAL X1)
 268 +      SET(ADD_WERROR OFF)
 269 +    ENDIF(X${VAL} STREQUAL X1)
 270 +  ENDFOREACH(name ${NAMES})
 271 +  IF(ADD_WERROR)
 272 +    SET(CMAKE_C_FLAGS "-Werror")
 273 +    SET(CMAKE_CXX_FLAGS "-Werror")
 274 +  ENDIF(ADD_WERROR)
 275 +ENDIF(WINDOWS)
 276 +
 277 +IF(CMAKE_BUILD_TYPE)
 278 +  IF(WINDOWS)
 279 +    MARK_AS_ADVANCED(CLEAR CMAKE_CONFIGURATION_TYPES)
 280 +    SET(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE} CACHE STRING "compilation types" FORCE)
 281 +  ELSE(WINDOWS)
 282 +    IF(CMAKE_BUILD_TYPE STREQUAL Debug)
 283 +      SET(CMAKE_C_FLAGS_DEBUG "-g")
 284 +      SET(CMAKE_CXX_FLAGS_DEBUG "-g")
 285 +    ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
 286 +    IF(CMAKE_BUILD_TYPE STREQUAL Release)
 287 +      SET(CMAKE_C_FLAGS_RELEASE "-O1 -DNDEBUG")
 288 +      SET(CMAKE_CXX_FLAGS_RELEASE "-O1 -DNDEBUG")
 289 +    ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
 290 +  ENDIF(WINDOWS)
 291 +ENDIF(CMAKE_BUILD_TYPE)
 292 +
 293 +SET(PLATFORM_CPPFLAGS)
 294 +SET(PLATFORM_LDFLAGS)
 295 +SET(PLATFORM_LIBADD)
 296 +IF(WINDOWS)
 297 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} /W0)
 298 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_CRT_SECURE_NO_WARNINGS)  # To disable windows warnings for strcpy, fopen, ...
 299 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SCL_SECURE_NO_WARNINGS)  # To disable windows warnings std::copy, std::transform, ...
 300 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DWNT)
 301 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DPPRO_NT) # For medfile
 302 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_USE_MATH_DEFINES) # At least for MEDMEM
 303 +  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_WIN32_WINNT=0x0500) # Windows 2000 or later API is required
 304 +  SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} Ws2_32.lib)
 305 +  SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} Userenv.lib) # At least for GEOM suit
 306 +ELSE(WINDOWS)
 307 +  # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wparentheses)
 308 +  # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wreturn-type)
 309 +  # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wmissing-declarations)
 310 +  # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wunused)
 311 +  # SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -Wall)
 312 +  SET(PLATFORM_LIBADD ${PLATFORM_LIBADD} -ldl)
 313 +ENDIF(WINDOWS)
 314 +
 315 +SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DSIZEOF_FORTRAN_INTEGER=4 -DSIZEOF_LONG=${CMAKE_SIZEOF_VOID_P} -DSIZEOF_INT=4)
 316 +
 317 +#  SET(PLATFORM_CPPFLAGS)
 318 +#  #  #  SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -DWNT -D_CRT_SECURE_NO_WARNINGS)
 319 +#  #  SET(RM del)
 320 +#ELSE(WINDOWS)
 321 +#  #  SET(RM /bin/rm)
 322 +#ENDIF(WINDOWS)
 323 +
 324 +### SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_DEBUG_)
 325 +
 326 +##SET(RCP rcp)
 327 +##SET(RSH rsh)
 328 +##SET(RCP rcp)
 329 +
 330 +## MESSAGE(FATAL_ERROR "ZZZZZZZ")
 331 diff -Naur netgen-4.9.13.occ/cmake/am2cmake.py netgen-4.9.13/cmake/am2cmake.py
 332 --- netgen-4.9.13.occ/cmake/am2cmake.py 1970-01-01 00:00:00.000000000 +0000
 333 +++ netgen-4.9.13/cmake/am2cmake.py     2011-04-28 08:16:50.931646630 +0000
 334 @@ -0,0 +1,2287 @@
 335 +#  -*- coding: iso-8859-1 -*-
 336 +#  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
 337 +#
 338 +#  This library is free software; you can redistribute it and/or
 339 +#  modify it under the terms of the GNU Lesser General Public
 340 +#  License as published by the Free Software Foundation; either
 341 +#  version 2.1 of the License.
 342 +#
 343 +#  This library is distributed in the hope that it will be useful,
 344 +#  but WITHOUT ANY WARRANTY; without even the implied warranty of
 345 +#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 346 +#  Lesser General Public License for more details.
 347 +#
 348 +#  You should have received a copy of the GNU Lesser General Public
 349 +#  License along with this library; if not, write to the Free Software
 350 +#  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 351 +#
 352 +#  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 353 +#
 354 +
 355 +import re
 356 +
 357 +# ----
 358 +# A set of regular expressions used ...
 359 +# ----
 360 +
 361 +p_multiline = re.compile(r"""
 362 +\\           # One backslash
 363 +\s*          # 0 or more space
 364 +\n           # One CR
 365 +""", re.VERBOSE)
 366 +
 367 +p_dollar = re.compile(r"""
 368 +\$\(           # a $ then a (
 369 +(?P<val>       # open the group val
 370 +[^)]*          # the group contain 0 or more non ) characters
 371 +)              # close the group
 372 +\)             # a ) at the end
 373 +""", re.VERBOSE)
 374 +
 375 +p_arobas = re.compile(r"""
 376 +@              # a @
 377 +(?P<val>       # open the group val
 378 +[^@]*            # the group contain 0 or more non @ characters
 379 +)              # close the group
 380 +@              # a @ at the end
 381 +""", re.VERBOSE)
 382 +
 383 +p_if = re.compile(r"""
 384 +^          # beginning of the string
 385 +\s*        # 0 or more space
 386 +if         # an if
 387 +\s+        # 1 or more space
 388 +(?P<val>   # open the group val
 389 +.+         # the group contain 1 or more non space characters
 390 +)          # close the group
 391 +""", re.VERBOSE)
 392 +
 393 +p_else = re.compile(r"""
 394 +^          # beginning of the line
 395 +\s*        # 0 or more space
 396 +else       #
 397 +\s*        # 0 or more space
 398 +""", re.VERBOSE)
 399 +
 400 +p_endif = re.compile(r"""
 401 +^          # beginning of the line
 402 +\s*        # 0 or more space
 403 +endif      # a endif
 404 +\s*        # 0 or more space
 405 +""", re.VERBOSE)
 406 +
 407 +p_attribution = re.compile(r"""
 408 +^              # beginning of the line
 409 +(?P<spaces>    # open the group spaces
 410 +\s*            # 0 or more space
 411 +)              # close the group
 412 +(?P<key>       # open the group key
 413 +\w+            # the group contain 1 or more alphanumeric characters
 414 +)              # close the group
 415 +\s*            # 0 or more space
 416 +(?P<method>    # open the group method
 417 +\+?            # 0 or 1 +
 418 +=              # One =
 419 +)              # close the group
 420 +(?P<value>     # open the group value
 421 +.*             # 0 or more any characters
 422 +)              # close the group
 423 +""", re.VERBOSE)
 424 +
 425 +# -----
 426 +
 427 +class CMakeFile(object):
 428 +
 429 +    def __init__(self, the_root, root, dirs, files, f, module):
 430 +        #
 431 +        self.the_root = the_root
 432 +        self.root = root
 433 +        self.dirs = dirs
 434 +        self.files = files
 435 +        self.module = module
 436 +        #
 437 +        from os.path import join
 438 +        self.amFile = join(root, f)
 439 +        self.listsFile = join(root, "CMakeLists.txt")
 440 +        #
 441 +        self.parseFile()
 442 +        #
 443 +        return
 444 +
 445 +    def parseFile(self):
 446 +
 447 +        # --
 448 +        # Read the Makefile.am file
 449 +        # --
 450 +        amFile = self.amFile
 451 +        stream = open(amFile)
 452 +        content = stream.read()
 453 +        stream.close()
 454 +
 455 +        # --
 456 +        # Replace the composed lines separated by "\\n" by an unique line
 457 +        # --
 458 +        content = p_multiline.sub(r' ', content)
 459 +
 460 +        # --
 461 +        # Compatibility netgen plugin
 462 +        # --
 463 +        content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
 464 +
 465 +        # --
 466 +        cas_list = [
 467 +            "BinLPlugin",
 468 +            "BinPlugin",
 469 +            "BinTObjPlugin",
 470 +            "BinXCAFPlugin",
 471 +            "FWOSPlugin",
 472 +            "PTKernel",
 473 +            "StdLPlugin",
 474 +            "StdPlugin",
 475 +            "TKAdvTools",
 476 +            "TKBin",
 477 +            "TKBinL",
 478 +            "TKBinTObj",
 479 +            "TKBinXCAF",
 480 +            "TKBO",
 481 +            "TKBool",
 482 +            "TKBRep",
 483 +            "TKCAF",
 484 +            "TKCDF",
 485 +            "TKernel",
 486 +            "TKFeat",
 487 +            "TKFillet",
 488 +            "TKG2d",
 489 +            "TKG3d",
 490 +            "TKGeomAlgo",
 491 +            "TKGeomBase",
 492 +            "TKHLR",
 493 +            "TKIGES",
 494 +            "TKLCAF",
 495 +            "TKMath",
 496 +            "TKMesh",
 497 +            "TKMeshVS",
 498 +            "TKNIS",
 499 +            "TKOffset",
 500 +            "TKOpenGl",
 501 +            "TKPCAF",
 502 +            "TKPLCAF",
 503 +            "TKPrim",
 504 +            "TKPShape",
 505 +            "TKService",
 506 +            "TKShapeSchema",
 507 +            "TKShHealing",
 508 +            "TKStdLSchema",
 509 +            "TKStdSchema",
 510 +            "TKSTEP",
 511 +            "TKSTEP209",
 512 +            "TKSTEPAttr",
 513 +            "TKSTEPBase",
 514 +            "TKSTL",
 515 +            "TKTObj",
 516 +            "TKTopAlgo",
 517 +            "TKV2d",
 518 +            "TKV3d",
 519 +            "TKVRML",
 520 +            "TKXCAF",
 521 +            "TKXCAFSchema",
 522 +            "TKXDEIGES",
 523 +            "TKXDESTEP",
 524 +            "TKXMesh",
 525 +            "TKXml",
 526 +            "TKXmlL",
 527 +            "TKXmlTObj",
 528 +            "TKXmlXCAF",
 529 +            "TKXSBase",
 530 +            "XCAFPlugin",
 531 +            "XmlLPlugin",
 532 +            "XmlPlugin",
 533 +            "XmlTObjPlugin",
 534 +            "XmlXCAFPlugin",
 535 +            ]
 536 +        vtk_list = [
 537 +            "vtkCommonPythonD",
 538 +            "vtkGraphicsPythonD",
 539 +            "vtkImagingPythonD",
 540 +            ]
 541 +        kernel_list  = [
 542 +            "CalciumC",
 543 +            "DF",
 544 +            "Launcher",
 545 +            "LifeCycleCORBATest",
 546 +            "NamingServiceTest",
 547 +            "OpUtil",
 548 +            "Registry",
 549 +            "ResourcesManager",
 550 +            "SALOMEBasics",
 551 +            "SalomeCatalog",
 552 +            "SalomeCommunication",
 553 +            "SalomeContainer",
 554 +            "SalomeDatastream",
 555 +            "SalomeDSCContainer",
 556 +            "SalomeDSClient",
 557 +            "SalomeDSCSupervBasic",
 558 +            "SalomeDSCSuperv",
 559 +            "SalomeDSImpl",
 560 +            "SALOMEDSImplTest",
 561 +            "SalomeDS",
 562 +            "SALOMEDSTest",
 563 +            "SalomeGenericObj",
 564 +            "SalomeHDFPersist",
 565 +            "SalomeIDLKernel",
 566 +            "SalomeLauncher",
 567 +            "SalomeLifeCycleCORBA",
 568 +            "SALOMELocalTrace",
 569 +            "SALOMELocalTraceTest",
 570 +            "SalomeLoggerServer",
 571 +            "SalomeMPIContainer",
 572 +            "SalomeNotification",
 573 +            "SalomeNS",
 574 +            "SalomeResourcesManager",
 575 +            "SalomeTestComponentEngine",
 576 +            "SalomeTestMPIComponentEngine",
 577 +            "SALOMETraceCollectorTest",
 578 +            "TOOLSDS",
 579 +            "UtilsTest",
 580 +            "with_loggerTraceCollector",
 581 +            ]
 582 +        gui_list = [
 583 +            "caf",
 584 +            "CAM",
 585 +            "CASCatch",
 586 +            "DDS",
 587 +            "Event",
 588 +            "GLViewer",
 589 +            "LightApp",
 590 +            "LogWindow",
 591 +            "ObjBrowser",
 592 +            "OCCViewer",
 593 +            "OpenGLUtils",
 594 +            "Plot2d",
 595 +            "PyConsole",
 596 +            "PyInterp",
 597 +            "QDS",
 598 +            "qtx",
 599 +            "QxScene",
 600 +            "SalomeApp",
 601 +            "SalomeAppTest",
 602 +            "SalomeIDLGUI",
 603 +            "SalomeObject",
 604 +            "SalomePrs",
 605 +            "SalomePyQtGUILight",
 606 +            "SalomePyQtGUI",
 607 +            "SalomePyQt",
 608 +            "SalomePy",
 609 +            "SalomeSession",
 610 +            "SalomeStyle",
 611 +            "SOCC",
 612 +            "SPlot2d",
 613 +            "std",
 614 +            "SUITApp",
 615 +            "suit",
 616 +            "SUPERVGraph",
 617 +            "SVTK",
 618 +            "ToolsGUI",
 619 +            "ViewerTools",
 620 +            "VTKViewer",
 621 +            ]
 622 +        geom_list = [
 623 +            "AdvancedGUI",
 624 +            "BasicGUI",
 625 +            "BlocksGUI",
 626 +            "BooleanGUI",
 627 +            "BREPExport",
 628 +            "BREPImport",
 629 +            "BuildGUI",
 630 +            "DisplayGUI",
 631 +            "DlgRef",
 632 +            "EntityGUI",
 633 +            "GenerationGUI",
 634 +            "GEOMAlgo",
 635 +            "GEOMArchimede",
 636 +            "GEOMBase",
 637 +            "GEOMbasic",
 638 +            "GEOMClient",
 639 +            "GEOMEngine",
 640 +            "GEOMFiltersSelection",
 641 +            "GEOMimpl",
 642 +            "GEOMObject",
 643 +            "GEOMSketcher",
 644 +            "GEOM",
 645 +            "GEOM_SupervEngine",
 646 +            "GEOMToolsGUI",
 647 +            "GroupGUI",
 648 +            "IGESExport",
 649 +            "IGESImport",
 650 +            "MeasureGUI",
 651 +            "NMTDS",
 652 +            "NMTTools",
 653 +            "OCC2VTK",
 654 +            "OperationGUI",
 655 +            "PrimitiveGUI",
 656 +            "RepairGUI",
 657 +            "SalomeIDLGEOM",
 658 +            "ShHealOper",
 659 +            "STEPExport",
 660 +            "STEPImport",
 661 +            "STLExport",
 662 +            "TransformationGUI",
 663 +            "VTKExport",
 664 +            ]
 665 +        med_list = [
 666 +            "interpkernel",
 667 +            "InterpKernelTest",
 668 +            "MEDClientcmodule",
 669 +            "medcouplingclient",
 670 +            "medcouplingcorba",
 671 +            "medcouplingremapper",
 672 +            "medcoupling",
 673 +            "MEDEngine",
 674 +            "medloader",
 675 +            "MEDMEMCppTest",
 676 +            "MEDMEMImpl",
 677 +            "medmem",
 678 +            "MED",
 679 +            "medsplitter",
 680 +            "MEDSPLITTERTest",
 681 +            "med_V2_1",
 682 +            "MEDWrapperBase",
 683 +            "MEDWrapper",
 684 +            "MEDWrapper_V2_1",
 685 +            "MEDWrapper_V2_2",
 686 +            "paramedcouplingcorba",
 687 +            "paramedloader",
 688 +            "paramedmemcompo",
 689 +            "paramedmem",
 690 +            "ParaMEDMEMTest",
 691 +            "SalomeIDLMED",
 692 +            "SalomeIDLMEDTests",
 693 +            ]
 694 +        smesh_list = [
 695 +            "GeomSelectionTools",
 696 +            "MEFISTO2D",
 697 +            "MeshDriverDAT",
 698 +            "MeshDriverMED",
 699 +            "MeshDriver",
 700 +            "MeshDriverSTL",
 701 +            "MeshDriverUNV",
 702 +            "SalomeIDLSMESH",
 703 +            "SMDS",
 704 +            "SMESHClient",
 705 +            "SMESHControls",
 706 +            "SMESHDS",
 707 +            "SMESHEngine",
 708 +            "SMESHFiltersSelection",
 709 +            "SMESHimpl",
 710 +            "SMESHObject",
 711 +            "SMESH",
 712 +            "StdMeshersEngine",
 713 +            "StdMeshersGUI",
 714 +            "StdMeshers",
 715 +            ]
 716 +        full_list  = cas_list + vtk_list
 717 +        full_list += kernel_list + gui_list
 718 +        full_list += geom_list + med_list + smesh_list
 719 +        # --
 720 +        # E.A. : sort by len before substitution ...
 721 +        # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 722 +        # And you understand ...
 723 +        # --
 724 +        full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 725 +        # --
 726 +        for key in full_list:
 727 +            content = content.replace("-l%s"%(key), "${%s}"%(key))
 728 +            pass
 729 +
 730 +        # --
 731 +        # Split content in lines to treat each one separately
 732 +        # --
 733 +        lines = content.split('\n')
 734 +
 735 +        # --
 736 +        # newlines contains the lines of the future CMakeLists.txt file
 737 +        # --
 738 +        newlines = []
 739 +
 740 +        # --
 741 +        # opened_ifs is used to deals with nested conditionnals
 742 +        # --
 743 +        opened_ifs = []
 744 +
 745 +        # --
 746 +        # the __thedict__ dictionnary contains key, val
 747 +        # of the Makefile.am file
 748 +        # --
 749 +        self.__thedict__ = {}
 750 +
 751 +        # --
 752 +        # Initialize file ... mainly includes other cmake files
 753 +        # --
 754 +        self.initialize(newlines)
 755 +
 756 +        # --
 757 +        # Do the job for each line
 758 +        # --
 759 +        for line in lines:
 760 +            self.treatLine(line, newlines, opened_ifs)
 761 +            pass
 762 +
 763 +        # --
 764 +        # Finalize file ... it is in here the cmake job is done
 765 +        # --
 766 +        self.finalize(newlines)
 767 +
 768 +        # --
 769 +        # Concatenate newlines into content
 770 +        # --
 771 +        content = '\n'.join(newlines)
 772 +
 773 +        # --
 774 +        # Add a CR at end if necessary
 775 +        # --
 776 +        lines = content.split('\n')
 777 +        # lines = [ l.strip() for l in lines ]
 778 +        if len(lines[-1]) != 0:
 779 +            lines.append('')
 780 +            pass
 781 +        content = '\n'.join(lines)
 782 +
 783 +        # --
 784 +        self.content = content
 785 +
 786 +        # --
 787 +        return
 788 +
 789 +    def initialize(self, newlines):
 790 +        if self.root == self.the_root:
 791 +            # --
 792 +            newlines.append("""
 793 +            CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
 794 +            IF(COMMAND cmake_policy)
 795 +            cmake_policy(SET CMP0003 NEW)
 796 +            ENDIF(COMMAND cmake_policy)
 797 +            """)
 798 +            # --
 799 +            newlines.append("""
 800 +            ENABLE_TESTING()
 801 +            """)
 802 +            # --
 803 +            newlines.append("""
 804 +            SET(MODULE %s)
 805 +            """%(self.module.upper()))
 806 +            # --
 807 +            if self.module == "netgen":
 808 +                newlines.append("""
 809 +                INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindPLATFORM.cmake)
 810 +                INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindCAS.cmake)
 811 +                """)
 812 +            else:
 813 +                if self.module == "kernel":
 814 +                    newlines.append("""
 815 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 816 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 817 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 818 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 819 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 820 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 821 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 822 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 823 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 824 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 825 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 826 +                    INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
 827 +                    """)
 828 +                    pass
 829 +                else:
 830 +                    if self.module == "med":
 831 +                        newlines.append("""
 832 +                        SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 833 +                        IF(KERNEL_ROOT_DIR)
 834 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 835 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 836 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 837 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 838 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 839 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 840 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 841 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 842 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 843 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 844 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 845 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
 846 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 847 +                        ELSE(KERNEL_ROOT_DIR)
 848 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
 849 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
 850 +                        ENDIF(KERNEL_ROOT_DIR)
 851 +                        """)
 852 +                    else:
 853 +                        newlines.append("""
 854 +                        SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 855 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 856 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 857 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 858 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 859 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 860 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 861 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 862 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 863 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 864 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 865 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 866 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
 867 +                        INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 868 +                        """)
 869 +                        pass
 870 +                    if self.module == "gui":
 871 +                        newlines.append("""
 872 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 873 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 874 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 875 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 876 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 877 +                        INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 878 +                        """)
 879 +                    else:
 880 +                        newlines.append("""
 881 +                        SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 882 +                        IF(GUI_ROOT_DIR)
 883 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 884 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 885 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 886 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 887 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 888 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 889 +                        INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 890 +                        ENDIF(GUI_ROOT_DIR)
 891 +                        """)
 892 +                        if self.module == "med":
 893 +                            newlines.append("""
 894 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 895 +                            IF(WINDOWS)
 896 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
 897 +                            ENDIF(WINDOWS)
 898 +                            """)
 899 +                            pass
 900 +                        if self.module == "smesh":
 901 +                            newlines.append("""
 902 +                            SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 903 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 904 +                            INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 905 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 906 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 907 +                            """)
 908 +                            pass
 909 +                        if self.module == "netgenplugin":
 910 +                            newlines.append("""
 911 +                            SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 912 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 913 +                            SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 914 +                            INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 915 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 916 +                            INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 917 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 918 +                            """)
 919 +                            pass
 920 +                        if self.module == "blsurfplugin":
 921 +                            newlines.append("""
 922 +                            SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 923 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 924 +                            SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 925 +                            INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 926 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 927 +                            INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 928 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 929 +                            """)
 930 +                            pass
 931 +                        if self.module in ["ghs3dplugin", "hexoticplugin"]:
 932 +                            newlines.append("""
 933 +                            SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 934 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 935 +                            SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 936 +                            INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 937 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 938 +                            INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 939 +                            """)
 940 +                            pass
 941 +                        if self.module == "ghs3dprlplugin":
 942 +                            newlines.append("""
 943 +                            SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 944 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 945 +                            SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 946 +                            INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 947 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 948 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 949 +                            INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 950 +                            """)
 951 +                            pass
 952 +                        if self.module == "visu":
 953 +                            newlines.append("""
 954 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 955 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 956 +                            """)
 957 +                            pass
 958 +                        if self.module == "yacs":
 959 +                            newlines.append("""
 960 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 961 +                            INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 962 +                            """)
 963 +                            pass
 964 +                        if self.module == "hxx2salome":
 965 +                            newlines.append("""
 966 +                            SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 967 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 968 +                            INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 969 +                            """)
 970 +                            pass
 971 +                        pass
 972 +                    pass
 973 +                pass
 974 +            # --
 975 +            newlines.append("""
 976 +            SET(DOXYGEN_IS_OK 0)
 977 +            """)
 978 +            if self.module not in ['med']:
 979 +                newlines.append("""
 980 +                IF(WINDOWS)
 981 +                SET(CPPUNIT_IS_OK 0)
 982 +                ENDIF(WINDOWS)
 983 +                """)
 984 +                pass
 985 +            # --
 986 +            if self.module == "kernel":
 987 +                newlines.append("""
 988 +                SET(WITH_LOCAL 1)
 989 +                SET(WITH_BATCH 1)
 990 +                SET(CALCIUM_IDL_INT_F77 long)
 991 +                SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 992 +                SET(LONG_OR_INT int)
 993 +                """)
 994 +            elif self.module == "gui":
 995 +                newlines.append("""
 996 +                SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 997 +                SET(ENABLE_VTKVIEWER ON)
 998 +                SET(ENABLE_SALOMEOBJECT ON)
 999 +                SET(ENABLE_OCCVIEWER ON)
1000 +                SET(ENABLE_GLVIEWER ON)
1001 +                SET(ENABLE_PLOT2DVIEWER ON)
1002 +                SET(ENABLE_PYCONSOLE ON)
1003 +                SET(ENABLE_SUPERVGRAPHVIEWER ON)
1004 +                SET(ENABLE_QXGRAPHVIEWER ON)
1005 +                """)
1006 +                pass
1007 +            elif self.module == "jobmanager":
1008 +                newlines.append("""
1009 +                IF(GUI_ROOT_DIR)
1010 +                SET(HAS_GUI ON)
1011 +                ENDIF(GUI_ROOT_DIR)
1012 +                """)
1013 +                pass
1014 +            elif self.module == "geom":
1015 +                newlines.append("""
1016 +                IF(GUI_ROOT_DIR)
1017 +                SET(GEOM_ENABLE_GUI ON)
1018 +                ENDIF(GUI_ROOT_DIR)
1019 +                """)
1020 +                pass
1021 +            elif self.module == "medfile":
1022 +                newlines.append("""
1023 +                SET(MED_NUM_MAJEUR 2)
1024 +                SET(MED_NUM_MINEUR 3)
1025 +                SET(MED_NUM_RELEASE 5)
1026 +                SET(LONG_OR_INT int)
1027 +                IF(NOT WINDOWS)
1028 +                SET(FLIBS -lgfortranbegin -lgfortran)
1029 +                ENDIF(NOT WINDOWS)
1030 +                """)
1031 +                pass
1032 +            elif self.module == "med":
1033 +                newlines.append("""
1034 +                IF(KERNEL_ROOT_DIR)
1035 +                SET(MED_ENABLE_KERNEL ON)
1036 +                IF(NOT WINDOWS)
1037 +                SET(MED_ENABLE_SPLITTER ON)
1038 +                ENDIF(NOT WINDOWS)
1039 +                ENDIF(KERNEL_ROOT_DIR)
1040 +                IF(GUI_ROOT_DIR)
1041 +                SET(MED_ENABLE_GUI ON)
1042 +                ENDIF(GUI_ROOT_DIR)
1043 +                """)
1044 +                pass
1045 +            elif self.module == "smesh":
1046 +                newlines.append("""
1047 +                IF(GUI_ROOT_DIR)
1048 +                SET(SMESH_ENABLE_GUI ON)
1049 +                ENDIF(GUI_ROOT_DIR)
1050 +                """)
1051 +                pass
1052 +            elif self.module == "netgen":
1053 +                newlines.append("""
1054 +                SET(OCCFLAGS ${CAS_CPPFLAGS})
1055 +                SET(OCCLIBS ${CAS_LDPATH})
1056 +                SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
1057 +                SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
1058 +                SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
1059 +                """)
1060 +                pass
1061 +            elif self.module == "netgenplugin":
1062 +                newlines.append("""
1063 +                IF(GUI_ROOT_DIR)
1064 +                SET(NETGENPLUGIN_ENABLE_GUI ON)
1065 +                ENDIF(GUI_ROOT_DIR)
1066 +                """)
1067 +                pass
1068 +            elif self.module == "blsurfplugin":
1069 +                newlines.append("""
1070 +                IF(GUI_ROOT_DIR)
1071 +                SET(BLSURFPLUGIN_ENABLE_GUI ON)
1072 +                ENDIF(GUI_ROOT_DIR)
1073 +                """)
1074 +                pass
1075 +            elif self.module == "ghs3dplugin":
1076 +                newlines.append("""
1077 +                IF(GUI_ROOT_DIR)
1078 +                SET(GHS3DPLUGIN_ENABLE_GUI ON)
1079 +                ENDIF(GUI_ROOT_DIR)
1080 +                """)
1081 +                pass
1082 +            elif self.module == "hexoticplugin":
1083 +                newlines.append("""
1084 +                IF(GUI_ROOT_DIR)
1085 +                SET(HEXOTICPLUGIN_ENABLE_GUI ON)
1086 +                ENDIF(GUI_ROOT_DIR)
1087 +                """)
1088 +                pass
1089 +            elif self.module == "ghs3dprlplugin":
1090 +                newlines.append("""
1091 +                IF(GUI_ROOT_DIR)
1092 +                SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
1093 +                ENDIF(GUI_ROOT_DIR)
1094 +                """)
1095 +                pass
1096 +            elif self.module == "yacs":
1097 +                newlines.append("""
1098 +                SET(SALOME_KERNEL ON)
1099 +                SET(HAS_GUI ON)
1100 +                SET(WITH_QT4 ON)
1101 +                """)
1102 +                pass
1103 +            # --
1104 +            newlines.append("""
1105 +            set(VERSION 6.3.0)
1106 +            set(XVERSION 0x060300)
1107 +            """)
1108 +            pass
1109 +        # --
1110 +        newlines.append("""
1111 +        SET(VERSION_INFO 0.0.0)
1112 +        SET(SOVERSION_INFO 0)
1113 +        SET(SUBDIRS)
1114 +        SET(AM_CPPFLAGS)
1115 +        SET(AM_CXXFLAGS)
1116 +        SET(LDADD)
1117 +        SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
1118 +        SET(salomepythondir ${pythondir}/salome)
1119 +        SET(salomepypkgdir ${salomepythondir}/salome)
1120 +        """)
1121 +        if self.module == "netgen":
1122 +            newlines.append(r'''
1123 +            SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_BINARY_DIR} -I${CMAKE_CURRENT_SOURCE_DIR})
1124 +            ''')
1125 +        elif self.module == "kernel":
1126 +            newlines.append(r'''
1127 +            SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
1128 +            SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
1129 +            ''')
1130 +        else:
1131 +            if self.module not in ["yacs"]:
1132 +                newlines.append(r'''
1133 +                IF(KERNEL_ROOT_DIR)
1134 +                SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
1135 +                SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
1136 +                ENDIF(KERNEL_ROOT_DIR)
1137 +                ''')
1138 +                pass
1139 +            if self.module == "gui":
1140 +                newlines.append(r'''
1141 +                IF(KERNEL_ROOT_DIR)
1142 +                SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER)
1143 +                SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER)
1144 +                ENDIF(KERNEL_ROOT_DIR)
1145 +                ''')
1146 +                pass
1147 +            if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin"]:
1148 +                newlines.append(r'''
1149 +                SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
1150 +                SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
1151 +                ''')
1152 +                pass
1153 +            if self.module == "hxx2salome":
1154 +                key = "_SRC"
1155 +                if self.the_root[-len(key):] != key:
1156 +                    msg = "Source dir must finished with %s !"%(key)
1157 +                    raise Exception(msg)
1158 +                hxxmodule = self.the_root[:-len(key)]
1159 +                from os.path import basename
1160 +                hxxmodule = basename(hxxmodule)
1161 +                hxxmodule = hxxmodule.lower()
1162 +                self.hxxmodule = hxxmodule
1163 +                newlines.append(r'''
1164 +                SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
1165 +                SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
1166 +                SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
1167 +                SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
1168 +                '''%(hxxmodule.upper()))
1169 +                pass
1170 +            pass
1171 +        # --
1172 +        return
1173 +
1174 +    def treatLine(self, line, newlines, opened_ifs):
1175 +
1176 +        # --
1177 +        # Print the comment above the line itself
1178 +        # --
1179 +        if line.find('#') >= 0:
1180 +            fields = line.split('#')
1181 +            line = fields[0]
1182 +            comment = '#'.join([''] + fields[1:])
1183 +            newlines.append(comment)
1184 +            if len(line) == 0:
1185 +                return
1186 +            pass
1187 +
1188 +        # --
1189 +        # If the line begins with 'include ', just comment it
1190 +        # --
1191 +        if line.find("include ") == 0:
1192 +            newlines.append("# " + line)
1193 +            return
1194 +
1195 +        # --
1196 +        # If the line begins with '-include', just comment it
1197 +        # --
1198 +        if line.find("-include") == 0:
1199 +            newlines.append("# " + line)
1200 +            return
1201 +
1202 +        # --
1203 +        # If the line is a definition of a make rule, just comment it
1204 +        # --
1205 +        if line.count(':') == 1:
1206 +            newlines.append("# " + line)
1207 +            return
1208 +
1209 +        # --
1210 +        # A particuliar case where there are two ":" on the same line
1211 +        # --
1212 +        if line.find('install-exec-local:') == 0:
1213 +            newlines.append("# " + line)
1214 +            return
1215 +
1216 +        # --
1217 +        # If the line begin by a tabulation, consider it's a makefile command and comment it
1218 +        # --
1219 +        if line.find("\t") == 0:
1220 +            newlines.append("# " + line)
1221 +            return
1222 +
1223 +        # --
1224 +        # --
1225 +        key = "-version-info"
1226 +        if line.find(key) >= 0:
1227 +            # --
1228 +            before = line.split(key)[0]
1229 +            after = line[len(before)+len(key):]
1230 +            sep = after[0]
1231 +            after = after[1:]
1232 +            version_info = after.split()[0]
1233 +            line = line.replace(key+sep+version_info, "")
1234 +            # --
1235 +            version_info = version_info.replace(':', '.')
1236 +            soversion_info = version_info.split('.')[0]
1237 +            newlines.append("SET(VERSION_INFO " + version_info + ")")
1238 +            newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
1239 +            # --
1240 +            pass
1241 +
1242 +        # --
1243 +        # Replace the $(TOTO) by ${TOTO}
1244 +        # Replace the @TOTO@  by ${TOTO}
1245 +        # --
1246 +        line = p_dollar.sub(r"${\1}", line)
1247 +        line = p_arobas.sub(r"${\1}", line)
1248 +
1249 +        # --
1250 +        line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
1251 +        line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
1252 +        line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
1253 +        line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
1254 +        line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
1255 +
1256 +        # --
1257 +        # Check if the line is a 'if' condition
1258 +        # If yes, replace it by a cmake grammar
1259 +        # --
1260 +        match = p_if.match(line)
1261 +        if match:
1262 +            theif = match.group("val")
1263 +            if theif[0] == "!":
1264 +                theif = "NOT " + theif[1:]
1265 +                pass
1266 +            line = p_if.sub(r"IF(%s)"%(theif), line)
1267 +            opened_ifs.append(theif)
1268 +            newlines.append(line)
1269 +            return
1270 +
1271 +        # --
1272 +        # Check if the line is a 'else' condition
1273 +        # If yes, replace it by a cmake grammar
1274 +        # --
1275 +        match = p_else.match(line)
1276 +        if match:
1277 +            line = "ELSE(%s)"%(opened_ifs[-1])
1278 +            newlines.append(line)
1279 +            return
1280 +
1281 +        # --
1282 +        # Check if the line is a 'endif' condition
1283 +        # If yes, replace it by a cmake grammar
1284 +        # --
1285 +        match = p_endif.match(line)
1286 +        if match:
1287 +            line = "ENDIF(%s)"%(opened_ifs[-1])
1288 +            opened_ifs[-1:] = []
1289 +            newlines.append(line)
1290 +            return
1291 +
1292 +        # --
1293 +        # Check if the line is an attribution '=' or '+='
1294 +        # --
1295 +        match = p_attribution.match(line)
1296 +        if match:
1297 +            self.treatAttribution(match, newlines)
1298 +            return
1299 +
1300 +        # --
1301 +        newlines.append(line)
1302 +
1303 +        # --
1304 +        return
1305 +
1306 +    def treatAttribution(self, match, newlines):
1307 +
1308 +        spaces = match.group("spaces")
1309 +        key = match.group("key")
1310 +        method = match.group("method")
1311 +        value = match.group("value")
1312 +        # print [spaces, key, method, value]
1313 +
1314 +        # --
1315 +        # Open cmake SET command
1316 +        # --
1317 +        newlines.append(spaces + "SET(" + key)
1318 +
1319 +        # --
1320 +        # If method is '+=', put the previous definition as first value
1321 +        # --
1322 +        if method == "+=":
1323 +            newlines.append("%s    ${%s}"%(spaces, key))
1324 +            pass
1325 +
1326 +        # --
1327 +        fields = value.split()
1328 +        for i in range(len(fields)):
1329 +            newlines.append("%s    %s"%(spaces, fields[i]))
1330 +            pass
1331 +
1332 +        # --
1333 +        if method == "+=":
1334 +            # --
1335 +            # The try: except KeyError is here if the +=
1336 +            # is an error which occurs in salome ...
1337 +            # --
1338 +            try:
1339 +                self.__thedict__[key] += fields[:]
1340 +            except KeyError:
1341 +                self.__thedict__[key] = fields[:]
1342 +                pass
1343 +            pass
1344 +        else:
1345 +            self.__thedict__[key]  = fields[:]
1346 +            pass
1347 +
1348 +        # --
1349 +        # Close cmake SET command
1350 +        # --
1351 +
1352 +        newlines.append("%s)"%(spaces))
1353 +
1354 +        return
1355 +
1356 +    def finalize(self, newlines):
1357 +
1358 +        # --
1359 +        # Convert the .in files in build dir
1360 +        # --
1361 +
1362 +        import operator
1363 +        mod = self.module
1364 +        if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1365 +            newlines.append(r'''
1366 +            SET(top_builddir
1367 +                ${CMAKE_BINARY_DIR}
1368 +            )
1369 +            SET(top_srcdir
1370 +                ${CMAKE_SOURCE_DIR}
1371 +            )
1372 +            SET(srcdir
1373 +                ${CMAKE_CURRENT_SOURCE_DIR}
1374 +            )
1375 +            SET(builddir
1376 +                ${CMAKE_CURRENT_BINARY_DIR}
1377 +            )
1378 +            SET(datadir
1379 +                ${CMAKE_INSTALL_PREFIX}/share
1380 +            )
1381 +            SET(docdir
1382 +                ${datadir}/doc/salome
1383 +            )
1384 +            ''')
1385 +            self.files.append("static/header.html.in")
1386 +        elif self.root[-len(mod):] == mod.upper() and operator.contains(self.root, 'doc') or mod in ['kernel', 'gui', 'geom', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1387 +            newlines.append(r'''
1388 +            SET(top_builddir
1389 +                ${CMAKE_BINARY_DIR}
1390 +            )
1391 +            SET(top_srcdir
1392 +                ${CMAKE_SOURCE_DIR}
1393 +            )
1394 +            SET(srcdir
1395 +                ${CMAKE_CURRENT_SOURCE_DIR}
1396 +            )
1397 +            SET(builddir
1398 +                ${CMAKE_CURRENT_BINARY_DIR}
1399 +            )
1400 +            SET(datadir
1401 +                ${CMAKE_INSTALL_PREFIX}/share
1402 +            )
1403 +            SET(docdir
1404 +                ${datadir}/doc/salome
1405 +            )
1406 +            ''')
1407 +            self.files.append("static/header.html.in")
1408 +        if self.module == "yacs":
1409 +            key = "salomegui"
1410 +            if self.root[-len(key):] == key:
1411 +                self.files.append("resources/YACSCatalog.xml.in")
1412 +                pass
1413 +            pass
1414 +        for f in self.files:
1415 +            if f[-3:] == ".in":
1416 +                if self.module == 'yacs' and f == "Doxyfile.in":
1417 +                    continue
1418 +                if f == "sstream.in":
1419 +                    continue
1420 +                if f in ["runContainer.in", "stopContainer.in"]:
1421 +                    if self.module == "med":
1422 +                        if self.root[-3:] == "csh":
1423 +                            continue
1424 +                        pass
1425 +                    pass
1426 +                if f == "SALOMEconfig.ref.in":
1427 +                    out = "SALOMEconfig.h"
1428 +                else:
1429 +                    out = f[:-3]
1430 +                    pass
1431 +                newlines.append(r'''
1432 +                SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1433 +                '''%(f))
1434 +                newlines.append(r'''
1435 +                SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1436 +                '''%(out))
1437 +                newlines.append(r'''
1438 +                MESSAGE(STATUS "Creation of ${output}")
1439 +                CONFIGURE_FILE(${input} ${output})
1440 +                ''')
1441 +                pass
1442 +            pass
1443 +
1444 +       # --
1445 +       # add commands for generating of user's documentation
1446 +       # --
1447 +
1448 +        upmod = self.module.upper()
1449 +        doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1450 +        doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1451 +        doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1452 +        head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1453 +        if mod == 'kernel':
1454 +            copytree_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files"
1455 +        else:
1456 +            copytree_src = "$ENV{KERNEL_ROOT_DIR}/salome_adm/cmake_files"
1457 +        str = "import re \nimport sys \noutfile = open(sys.argv[1], 'wb') \nfor line in open(sys.argv[2], 'rb').readlines():"
1458 +        str += "\n    if re.match('class '+sys.argv[3]+'DC', line): \n        continue \n    line = re.sub(r'^\s+\#', '#', line) \n    line = re.sub(r'^\s+def', 'def', line) \n    line = re.sub(sys.argv[3]+'DC', sys.argv[3], line)"
1459 +        str += "\n    outfile.write(line) \noutfile.close()"
1460 +
1461 +        if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1462 +            if mod == 'med':
1463 +                doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1464 +                input = "Doxyfile_med_user"
1465 +            else:
1466 +                doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1467 +                input = ""
1468 +            newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1469 +            COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1470 +            VERBATIM
1471 +            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1472 +            )"""%(input, copytree_src, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1473 +
1474 +        if mod in ['geom', 'smesh', 'visu'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc'):
1475 +            ign = r"""'tempfile', '*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1476 +            if mod in ['geom', 'smesh']:
1477 +                if mod == 'geom':
1478 +                    tmp = 'geompy'
1479 +                    input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1480 +                else:
1481 +                    tmp =  'smesh'
1482 +                    input = ''
1483 +                newlines.append(r"""
1484 +                FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1485 +                ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1486 +                %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1487 +                COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1488 +                COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1489 +                COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''', r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''', r'''%s''')"
1490 +                VERBATIM
1491 +                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1492 +                )"""%(str, upmod, tmp, upmod, tmp, tmp, input, upmod, tmp, copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1493 +            else:
1494 +               newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} doxyfile_idl
1495 +                COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1496 +                COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''',True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''',r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''',r'''%s''')"
1497 +                VERBATIM
1498 +                WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1499 +                )"""%(copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1500 +
1501 +       # --
1502 +       # add commands for generating of developer's documentation
1503 +       # --
1504 +
1505 +        upmod = self.module.upper()
1506 +        if mod in ['kernel', 'gui', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1507 +            if mod == 'kernel':
1508 +                tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1509 +            COMMAND ${DOXYGEN_EXECUTABLE}
1510 +            COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')"  """
1511 +                tmp1=""
1512 +            else:
1513 +                tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1514 +                if mod == 'visu':
1515 +                    tmp1= r"""\n           COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/visuscreen.png''', r'''%s''')" """%(doc_tui_destination)
1516 +                elif mod == 'smesh':
1517 +                    extra_srcdir = "${CMAKE_CURRENT_SOURCE_DIR}/extra"
1518 +                    tmp1= """\n            COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.pdf''', r'''%s'''); copy(r'''%s/PluginMeshers.html''', r'''%s''')"
1519 +            COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''%s/AddNetgenInSalome2.ps''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.sxw''', r'''%s''')" """%(doc_tui_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination,extra_srcdir,doc_destination)
1520 +                else:
1521 +                    tmp1=""
1522 +            doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1523 +            newlines.append(tmp + """
1524 +            COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')" """%(copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination) + tmp1 + """
1525 +            VERBATIM
1526 +            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1527 +            )""")
1528 +        if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1529 +            tmp = 'geompy'
1530 +            doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1531 +            newlines.append(r"""
1532 +            FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1533 +            ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1534 +            COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1535 +            COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1536 +            COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s'''); shutil.copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/geomscreen.png''', r'''%s''')"
1537 +            VERBATIM
1538 +            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1539 +            )"""%(str, upmod, tmp, upmod, tmp, tmp, upmod, tmp, copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination, doc_tui_destination))
1540 +
1541 +        # --
1542 +        # convert the SUBDIRS in cmake grammar
1543 +        # --
1544 +        if 1: # self.__thedict__.has_key("SUBDIRS"):
1545 +            newlines.append(r'''
1546 +            FOREACH(dir ${SUBDIRS})
1547 +            IF(NOT dir STREQUAL .)
1548 +            ADD_SUBDIRECTORY(${dir})
1549 +            ENDIF(NOT dir STREQUAL .)
1550 +            ENDFOREACH(dir ${SUBDIRS})
1551 +            ''')
1552 +            pass
1553 +
1554 +        # --
1555 +        # --
1556 +        for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
1557 +            if self.__thedict__.has_key(key):
1558 +                self.addLibTarget(key, newlines)
1559 +                pass
1560 +            pass
1561 +
1562 +        # --
1563 +        # --
1564 +        for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1565 +            if self.__thedict__.has_key(key):
1566 +                self.addBinTarget(key, newlines)
1567 +                pass
1568 +            pass
1569 +
1570 +        # --
1571 +        # --
1572 +        if self.__thedict__.has_key("BASEIDL_FILES"):
1573 +            if not self.__thedict__.has_key("IDL_FILES"):
1574 +                self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1575 +                newlines.append('''
1576 +                SET(IDL_FILES ${BASEIDL_FILES})
1577 +                ''')
1578 +                pass
1579 +            pass
1580 +
1581 +        # --
1582 +        # --
1583 +
1584 +        key = "IDL_FILES"
1585 +        if self.__thedict__.has_key(key):
1586 +            if self.module == "kernel":
1587 +                newlines.append('''
1588 +                SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1589 +                ''')
1590 +                pass
1591 +            newlines.append('''
1592 +            FOREACH(input ${IDL_FILES})
1593 +            STRING(REGEX REPLACE ".idl" "" base ${input})
1594 +            SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1595 +            SET(outputs ${src})
1596 +            SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1597 +            SET(outputs ${outputs} ${dynsrc})
1598 +            SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1599 +            SET(outputs ${outputs} ${inc})
1600 +            IF(input STREQUAL Calcium_Ports.idl)
1601 +            SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1602 +            ELSE(input STREQUAL Calcium_Ports.idl)
1603 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1604 +            ENDIF(input STREQUAL Calcium_Ports.idl)
1605 +            SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1606 +            STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1607 +            IF(NOT ISBCXX)
1608 +            SET(flags -bcxx ${flags})
1609 +            ENDIF(NOT ISBCXX)
1610 +            ADD_CUSTOM_COMMAND(
1611 +            OUTPUT ${outputs}
1612 +            COMMAND ${OMNIORB_IDL} ${flags} ${input}
1613 +            MAIN_DEPENDENCY ${input}
1614 +            )
1615 +            ''')
1616 +            newlines.append('''
1617 +            install(FILES ${input} DESTINATION idl/salome)
1618 +            ''')
1619 +            if self.module not in ["pyhello"]:
1620 +                newlines.append('''
1621 +                SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1622 +                install(FILES ${IDL_HEADER} DESTINATION include/salome)
1623 +                ''')
1624 +                pass
1625 +            newlines.append('''
1626 +            INSTALL(CODE "SET(IDL_FILE ${input})")
1627 +            INSTALL(CODE "SET(DIR ${salomepythondir})")
1628 +            IF(WINDOWS)
1629 +            INSTALL(CODE "SET(DIR bin/salome)")
1630 +            ENDIF(WINDOWS)
1631 +            INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1632 +            INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1633 +            # --
1634 +            SET(flags)
1635 +            FOREACH(f ${IDLPYFLAGS})
1636 +            SET(flags "${flags} ${f}")
1637 +            ENDFOREACH(f ${IDLPYFLAGS})
1638 +            STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1639 +            IF(NOT ISBPYTHON)
1640 +            SET(flags "-bpython ${flags}")
1641 +            ENDIF(NOT ISBPYTHON)
1642 +            SET(IDLPYFLAGS ${flags})
1643 +            STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1644 +            INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1645 +            # --
1646 +            ''')
1647 +            if self.module == "kernel":
1648 +                newlines.append('''
1649 +                INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1650 +                ''')
1651 +            else:
1652 +                newlines.append('''
1653 +                STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1654 +                INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1655 +                ''')
1656 +                pass
1657 +            newlines.append('''
1658 +            ENDFOREACH(input ${IDL_FILES})
1659 +            ''')
1660 +            pass
1661 +
1662 +        # --
1663 +        # --
1664 +        for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1665 +            if self.__thedict__.has_key(key):
1666 +                newlines.append('''
1667 +                SET(SWIG_SOURCES ${%s})
1668 +                '''%(key))
1669 +                self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1670 +                pass
1671 +            pass
1672 +
1673 +        # --
1674 +        # --
1675 +        if self.__thedict__.has_key("SWIG_SOURCES"):
1676 +            newlines.append('''
1677 +            IF(SWIG_SOURCES MATCHES ";")
1678 +            STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1679 +            ELSE(SWIG_SOURCES MATCHES ";")
1680 +            SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1681 +            ENDIF(SWIG_SOURCES MATCHES ";")
1682 +            SET(flags)
1683 +            FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1684 +            SET(test ON)
1685 +            IF(flags)
1686 +            LIST(FIND flags ${f} index)
1687 +            IF(NOT index EQUAL -1)
1688 +            SET(test OFF)
1689 +            ENDIF(NOT index EQUAL -1)
1690 +            ENDIF(flags)
1691 +            IF(test)
1692 +            SET(flags ${flags} ${f})
1693 +            ENDIF(test)
1694 +            ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1695 +            ADD_CUSTOM_COMMAND(
1696 +            OUTPUT ${build_srcs}
1697 +            COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1698 +            MAIN_DEPENDENCY ${SWIG_SOURCES}
1699 +            )
1700 +            ''')
1701 +            pass
1702 +
1703 +        # --
1704 +        # --
1705 +        if self.__thedict__.has_key("BUILT_SOURCES"):
1706 +            newlines.append('''
1707 +            FOREACH(f ${BUILT_SOURCES})
1708 +            IF(f MATCHES "WRAP.cxx$")
1709 +            # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1710 +            STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1711 +            ADD_CUSTOM_COMMAND(
1712 +            OUTPUT ${f} # ${inc}
1713 +            COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1714 +            MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1715 +            )
1716 +            ENDIF(f MATCHES "WRAP.cxx$")
1717 +            ENDFOREACH(f ${BUILT_SOURCES})
1718 +            ''')
1719 +            pass
1720 +
1721 +        # --
1722 +        # --
1723 +        key = "MOC_FILES"
1724 +        if self.__thedict__.has_key(key):
1725 +            newlines.append('''
1726 +            FOREACH(output ${MOC_FILES})
1727 +            ''')
1728 +            if self.module in ["jobmanager", "yacs"]:
1729 +                newlines.append('''
1730 +                STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1731 +                ''')
1732 +            else:
1733 +                newlines.append('''
1734 +                STRING(REGEX REPLACE _moc.cxx .h input ${output})
1735 +                ''')
1736 +                pass
1737 +            newlines.append('''
1738 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1739 +            SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1740 +            ADD_CUSTOM_COMMAND(
1741 +            OUTPUT ${output}
1742 +            COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1743 +            MAIN_DEPENDENCY ${input}
1744 +            )
1745 +            ENDFOREACH(output ${MOC_FILES})
1746 +            ''')
1747 +            pass
1748 +
1749 +        # --
1750 +        # --
1751 +        key = "UIC_FILES"
1752 +        if self.__thedict__.has_key(key):
1753 +            newlines.append('''
1754 +            FOREACH(output ${UIC_FILES})
1755 +            STRING(REPLACE "ui_" "" input ${output})
1756 +            STRING(REPLACE ".h" ".ui" input ${input})
1757 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1758 +            SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1759 +            ADD_CUSTOM_COMMAND(
1760 +            OUTPUT ${output}
1761 +            COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1762 +            MAIN_DEPENDENCY ${input}
1763 +            )
1764 +            ENDFOREACH(output ${UIC_FILES})
1765 +            ''')
1766 +            pass
1767 +
1768 +        # --
1769 +        # --
1770 +        key = "QRC_FILES"
1771 +        if self.__thedict__.has_key(key):
1772 +            newlines.append('''
1773 +            FOREACH(output ${QRC_FILES})
1774 +            STRING(REGEX REPLACE "qrc_" "" input ${output})
1775 +            STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1776 +            STRING(REGEX REPLACE ".qrc" "" name ${input})
1777 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1778 +            SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1779 +            ADD_CUSTOM_COMMAND(
1780 +            OUTPUT ${output}
1781 +            COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1782 +            MAIN_DEPENDENCY ${input}
1783 +            )
1784 +            ENDFOREACH(output ${QRC_FILES})
1785 +            ''')
1786 +            pass
1787 +
1788 +        # --
1789 +        # --
1790 +        key = "SIP_FILES"
1791 +        if self.__thedict__.has_key(key):
1792 +            newlines.append('''
1793 +            FOREACH(input ${SIP_FILES})
1794 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1795 +            SET(output)
1796 +            FOREACH(out ${SIP_SRC})
1797 +            SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1798 +            ENDFOREACH(out ${SIP_SRC})
1799 +            ADD_CUSTOM_COMMAND(
1800 +            OUTPUT ${output}
1801 +            COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1802 +            MAIN_DEPENDENCY ${input}
1803 +            )
1804 +            ENDFOREACH(input ${SIP_FILES})
1805 +            ''')
1806 +            pass
1807 +
1808 +        # --
1809 +        # For make check
1810 +        # --
1811 +        for key in ["TESTS"]:
1812 +            if self.__thedict__.has_key(key):
1813 +                newlines.append('''
1814 +                SET(UNIT_TEST_PROG ${%s})
1815 +                '''%(key))
1816 +                self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1817 +                pass
1818 +            pass
1819 +        key = "UNIT_TEST_PROG"
1820 +        if self.__thedict__.has_key(key):
1821 +            newlines.append('''
1822 +            FOREACH(input ${UNIT_TEST_PROG})
1823 +            GET_FILENAME_COMPONENT(ext ${input} EXT)
1824 +            IF(ext STREQUAL .py)
1825 +            SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1826 +            ELSE(ext STREQUAL .py)
1827 +            IF(WINDOWS)
1828 +            SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1829 +            ELSE()
1830 +            SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1831 +            ENDIF()
1832 +            ENDIF(ext STREQUAL .py)
1833 +            ADD_TEST(${input} ${test})
1834 +            SET(fail_regex "KO")
1835 +            SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1836 +            # IF(NOT WINDOWS)
1837 +            # ADD_TEST(${input}_valgrind valgrind ${test})
1838 +            # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1839 +            # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1840 +            # ENDIF()
1841 +            ENDFOREACH(input ${UNIT_TEST_PROG})
1842 +            ''')
1843 +            pass
1844 +
1845 +        # --
1846 +        # Treat the install targets
1847 +        # --
1848 +        resdir = self.module
1849 +        if resdir == "hxx2salome":
1850 +            resdir = self.hxxmodule
1851 +            pass
1852 +        d = {
1853 +            "salomeadmux_DATA"                 :  "salome_adm/unix",
1854 +            "dist_salomeadmux_DATA"            :  "salome_adm/unix",
1855 +            "dist_salome_cmake_DATA"           :  "salome_adm/cmake_files",
1856 +            "dist_salomem4_DATA"               :  "salome_adm/unix/config_files",
1857 +            "dist_salome4depr_DATA"            :  "salome_adm/unix/config_files/DEPRECATED",
1858 +            "dist_admlocalm4_DATA"             :  "adm_local/unix/config_files",
1859 +            "dist_admlocal_cmake_DATA"         :  "adm_local/cmake_files",
1860 +            "salomeinclude_DATA"               :  "include/salome",
1861 +            "salomeinclude_HEADERS"            :  "include/salome",
1862 +            "nodist_salomeinclude_HEADERS"     :  "include/salome",
1863 +            "dist_salomeres_DATA"              :  "share/salome/resources/%s"%(resdir),
1864 +            "nodist_salomeres_DATA"            :  "share/salome/resources/%s"%(resdir),
1865 +            "nodist_salomeres_SCRIPTS"         :  "share/salome/resources/%s"%(resdir),
1866 +            "dist_salomescript_SCRIPTS"        :  "bin/salome",
1867 +            "dist_salomescript_DATA"           :  "bin/salome",
1868 +            "dist_salomescript_PYTHON"         :  "bin/salome",
1869 +            "nodist_salomescript_DATA"         :  "bin/salome",
1870 +            "salomepython_PYTHON"              :  "${salomepythondir}",
1871 +            "nodist_salomepython_PYTHON"       :  "${salomepythondir}",
1872 +            "dist_salomepython_DATA"           :  "${salomepythondir}",
1873 +            "sharedpkgpython_PYTHON"           :  "${salomepythondir}/shared_modules",
1874 +            "salomepypkg_PYTHON"               :  "${salomepypkgdir}",
1875 +            "mypkgpython_PYTHON"               :  "${mypkgpythondir}",
1876 +            }
1877 +        if self.module == "jobmanager":
1878 +            d["bin_SCRIPTS"] = "bin"
1879 +            pass
1880 +        if self.module == "medfile":
1881 +            d = {
1882 +                "include_HEADERS"        :  "include",
1883 +                "nodist_include_HEADERS" :  "include",
1884 +                "bin_SCRIPTS"            :  "bin",
1885 +                "doc_DATA"               :  "${docdir}",
1886 +                }
1887 +            pass
1888 +        if self.module == "netgen":
1889 +            d = {
1890 +                "include_HEADERS"        :  "include",
1891 +                "noinst_HEADERS"         :  "share/netgen/include",
1892 +                "dist_pkgdata_DATA"      :  "share/netgen",
1893 +                "dist_doc_DATA"          :  "share/doc/netgen",
1894 +                }
1895 +            pass
1896 +        for key, value in d.items():
1897 +            if self.__thedict__.has_key(key):
1898 +                self.addInstallTarget(key, value, newlines)
1899 +                pass
1900 +            pass
1901 +
1902 +        # --
1903 +        return
1904 +
1905 +    def setLibAdd(self, key, newlines):
1906 +        # --
1907 +        newlines.append(r'''
1908 +        SET(libadd)
1909 +        ''')
1910 +        # --
1911 +        newlines.append(r'''
1912 +        IF(WINDOWS)
1913 +        SET(targets)
1914 +        SET(targets ${targets} MEFISTO2D)
1915 +        FOREACH(target ${targets})
1916 +        IF(name STREQUAL ${target})
1917 +        SET(dir $ENV{F2CHOME})
1918 +        STRING(REPLACE "\\\\" "/" dir ${dir})
1919 +        SET(libadd ${libadd} ${dir}/LIBF77.lib)
1920 +        SET(libadd ${libadd} ${dir}/LIBI77.lib)
1921 +        ENDIF(name STREQUAL ${target})
1922 +        ENDFOREACH(target ${targets})
1923 +        ENDIF(WINDOWS)
1924 +        ''')
1925 +        # --
1926 +        newlines.append(r'''
1927 +        SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1928 +        FOREACH(lib SALOMEBasics SalomeBatch)
1929 +        IF(name STREQUAL lib)
1930 +        SET(libs ${libs} ${PTHREAD_LIBS})
1931 +        ENDIF(name STREQUAL lib)
1932 +        ENDFOREACH(lib SALOMEBasics SalomeBatch)
1933 +        ''')
1934 +        # --
1935 +        newlines.append(r'''
1936 +        FOREACH(lib ${libs})
1937 +        GET_FILENAME_COMPONENT(ext ${lib} EXT)
1938 +        IF(ext STREQUAL .la)
1939 +        GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1940 +        STRING(REGEX REPLACE "^lib" "" lib ${lib})
1941 +        ENDIF(ext STREQUAL .la)
1942 +        SET(vars)
1943 +        SET(vars ${vars} -no-undefined)
1944 +        SET(vars ${vars} -lvtkWidgets)
1945 +        IF(WINDOWS)
1946 +        SET(vars ${vars} -module)
1947 +        SET(vars ${vars} -Wl,-E)
1948 +        SET(vars ${vars} -Xlinker)
1949 +        SET(vars ${vars} -export-dynamic)
1950 +        SET(vars ${vars} -lm)
1951 +        SET(vars ${vars} -lboost_thread)
1952 +        SET(vars ${vars} -lboost_signals)
1953 +        SET(vars ${vars} -pthread -lpthread -ldl)
1954 +        ENDIF(WINDOWS)
1955 +        FOREACH(v ${vars})
1956 +        IF(lib STREQUAL v)
1957 +        SET(lib)
1958 +        ENDIF(lib STREQUAL v)
1959 +        ENDFOREACH(v ${vars})
1960 +        SET(test OFF)
1961 +        IF(lib)
1962 +        STRING(REGEX MATCH "^-lQt" test ${lib})
1963 +        ENDIF(lib)
1964 +        IF(NOT test)
1965 +        SET(libadd ${libadd} ${lib})
1966 +        ENDIF(NOT test)
1967 +        ENDFOREACH(lib ${libs})
1968 +        TARGET_LINK_LIBRARIES(${name} ${libadd})
1969 +        ''')
1970 +        # --
1971 +        newlines.append(r'''
1972 +        IF(WINDOWS)
1973 +        SET(targets)
1974 +        SET(targets ${targets} MEFISTO2D)
1975 +        FOREACH(target ${targets})
1976 +        IF(name STREQUAL ${target})
1977 +        IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1978 +        SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1979 +        ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1980 +        ENDIF(name STREQUAL ${target})
1981 +        ENDFOREACH(target ${targets})
1982 +        ENDIF(WINDOWS)
1983 +        ''')
1984 +        # --
1985 +        return
1986 +
1987 +    def setCompilationFlags(self, key, newlines):
1988 +        newlines.append(r'''
1989 +        SET(var)
1990 +        IF(WINDOWS)
1991 +        SET(targets)
1992 +        SET(targets ${targets} SalomeIDLKernel)
1993 +        SET(targets ${targets} SalomeDS)
1994 +        SET(targets ${targets} SALOMEDSTest)
1995 +        SET(targets ${targets} SALOMEDS_Client_exe)
1996 +        SET(targets ${targets} SalomeIDLGEOM)
1997 +        SET(targets ${targets} GEOMEngine)
1998 +        SET(targets ${targets} MEDEngine)
1999 +        SET(targets ${targets} SMESHEngine)
2000 +        SET(targets ${targets} SMESH)
2001 +        FOREACH(target ${targets})
2002 +        IF(name STREQUAL ${target})
2003 +        SET(var ${var} -DNOGDI)
2004 +        ENDIF(name STREQUAL ${target})
2005 +        ENDFOREACH(target ${targets})
2006 +        ENDIF(WINDOWS)
2007 +        ''')
2008 +        # --
2009 +        if self.module in ["medfile", "yacs"]:
2010 +            newlines.append(r'''
2011 +            IF(WINDOWS)
2012 +            SET(var ${var} -DNOGDI)
2013 +            ENDIF(WINDOWS)
2014 +            ''')
2015 +            pass
2016 +        # --
2017 +        newlines.append(r'''
2018 +        IF(WINDOWS)
2019 +        SET(targets)
2020 +        SET(targets ${targets} MEFISTO2D)
2021 +        FOREACH(target ${targets})
2022 +        IF(name STREQUAL ${target})
2023 +        SET(dir $ENV{F2CHOME})
2024 +        STRING(REPLACE "\\\\" "/" dir ${dir})
2025 +        SET(var ${var} -I${dir})
2026 +        SET(var ${var} -DF2C_BUILD)
2027 +        ENDIF(name STREQUAL ${target})
2028 +        ENDFOREACH(target ${targets})
2029 +        ENDIF(WINDOWS)
2030 +        ''')
2031 +        # --
2032 +        if self.module in ["geom", "med"]:
2033 +            newlines.append(r'''
2034 +            SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
2035 +            SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
2036 +            ''')
2037 +            pass
2038 +        newlines.append(r'''
2039 +        SET(var ${var} ${AM_CPPFLAGS})
2040 +        SET(var ${var} ${AM_CXXFLAGS})
2041 +        ''')
2042 +        # --
2043 +        newlines.append(r'''
2044 +        IF(type STREQUAL STATIC)
2045 +        SET(var ${var} -fPIC)
2046 +        ENDIF(type STREQUAL STATIC)
2047 +        ''')
2048 +        # --
2049 +        if self.module == "yacs":
2050 +            newlines.append(r'''
2051 +            SET(var ${var} -DYACS_PTHREAD)
2052 +            SET(var ${var} -DCMAKE_BUILD)
2053 +            SET(var ${var} -DSALOME_KERNEL)
2054 +            SET(var ${var} -DDSC_PORTS)
2055 +            SET(var ${var} -DOMNIORB)
2056 +            ''')
2057 +            pass
2058 +        newlines.append(r'''
2059 +       SET(var ${var} ${PLATFORM_CPPFLAGS})
2060 +       SET(var ${var} ${PTHREAD_CFLAGS})
2061 +       SET(var ${var} ${${amname}_CPPFLAGS})
2062 +       SET(var ${var} ${${amname}_CXXFLAGS})
2063 +       SET(var ${var} ${${amname}_CFLAGS})
2064 +        SET(vars)
2065 +        IF(WINDOWS)
2066 +        SET(vars ${vars} -include SALOMEconfig.h)
2067 +        SET(vars ${vars} -ftemplate-depth-32)
2068 +        SET(vars ${vars} -fPIC)
2069 +        SET(vars ${vars} -g)
2070 +        ENDIF(WINDOWS)
2071 +        SET(flags)
2072 +        FOREACH(f ${var})
2073 +        FOREACH(v ${vars})
2074 +        IF(f STREQUAL v)
2075 +        SET(f)
2076 +        ENDIF(f STREQUAL v)
2077 +        ENDFOREACH(v ${vars})
2078 +        IF(f)
2079 +        string(REGEX MATCH "^-I" test_include ${f})
2080 +        if(test_include)
2081 +        string(REGEX REPLACE "^-I" "" include_dir ${f})
2082 +        if(include_dir)
2083 +        if(include_dir STREQUAL /usr/include)
2084 +        else(include_dir STREQUAL /usr/include)
2085 +        string(REGEX MATCH "^\\." test_dot ${include_dir})
2086 +        if(test_dot)
2087 +        set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
2088 +        endif(test_dot)
2089 +        include_directories(${include_dir})
2090 +        endif(include_dir STREQUAL /usr/include)
2091 +        endif(include_dir)
2092 +        else(test_include)
2093 +        SET(flags "${flags} ${f}")
2094 +        endif(test_include)
2095 +        ENDIF(f)
2096 +        ENDFOREACH(f ${var})
2097 +        SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2098 +        ''')
2099 +        return
2100 +
2101 +    def addLibTarget(self, key, newlines):
2102 +        newlines.append(r'''
2103 +        FOREACH(amname ${%s})
2104 +        '''%(key))
2105 +        # --
2106 +        # Replace .la by _la ...
2107 +        # --
2108 +        newlines.append(r'''
2109 +        STRING(REPLACE .la _la amname ${amname})
2110 +        ''')
2111 +        # --
2112 +        # Remove the _la for the cmake name
2113 +        # --
2114 +        newlines.append(r'''
2115 +        STRING(LENGTH ${amname} len)
2116 +        MATH(EXPR newlen "${len}-3")
2117 +        STRING(SUBSTRING ${amname} 0 ${newlen} name)
2118 +        ''')
2119 +        # --
2120 +        # Does the target begins with lib ??
2121 +        # If yes, remove lib at beginning for cmake name
2122 +        # --
2123 +        newlines.append(r'''
2124 +        STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2125 +        IF(BEGIN_WITH_lib)
2126 +        STRING(LENGTH ${name} len)
2127 +        MATH(EXPR newlen "${len}-3")
2128 +        STRING(SUBSTRING ${name} 3 ${newlen} name)
2129 +        ENDIF(BEGIN_WITH_lib)
2130 +        ''')
2131 +        # --
2132 +        # Does the target is an idl library
2133 +        # --
2134 +        newlines.append(r'''
2135 +        STRING(REGEX MATCH "IDL" ISIDL ${name})
2136 +        ''')
2137 +        # --
2138 +        # Set the type of the library
2139 +        # --
2140 +        newlines.append(r'''
2141 +        IF(ISIDL)
2142 +        IF(WINDOWS)
2143 +        SET(type STATIC)
2144 +        ELSE(WINDOWS)
2145 +        SET(type SHARED)
2146 +        ENDIF(WINDOWS)
2147 +        ELSE(ISIDL)
2148 +        SET(type SHARED)
2149 +        ENDIF(ISIDL)
2150 +        ''')
2151 +        if key == "noinst_LTLIBRARIES":
2152 +            newlines.append(r'''
2153 +            IF(WINDOWS)
2154 +            SET(type STATIC)
2155 +            ELSE(WINDOWS)
2156 +            SET(type STATIC)
2157 +            ENDIF(WINDOWS)
2158 +            ''')
2159 +            pass
2160 +        # --
2161 +        # Set sources for the library
2162 +        # --
2163 +        newlines.append(r'''
2164 +        SET(srcs)
2165 +        FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2166 +        GET_FILENAME_COMPONENT(ext ${src} EXT)
2167 +        IF(ext STREQUAL .f)
2168 +        IF(src STREQUAL trte.f)
2169 +        SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2170 +        STRING(REPLACE ".f" ".c" src ${src})
2171 +        SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2172 +        SET(output ${src})
2173 +        SET(cmd f2c)
2174 +        IF(NOT WINDOWS)
2175 +        IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2176 +        SET(cmd valgrind f2c)  # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2177 +        ENDIF()
2178 +        ENDIF(NOT WINDOWS)
2179 +        ADD_CUSTOM_COMMAND(
2180 +        OUTPUT ${output}
2181 +        COMMAND ${cmd} ${input}
2182 +        MAIN_DEPENDENCY ${input}
2183 +        )
2184 +        ELSE(src STREQUAL trte.f)
2185 +        SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2186 +        STRING(REPLACE ".f" ".o" src ${src})
2187 +        SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2188 +        SET(output ${src})
2189 +        IF(WINDOWS)
2190 +        SET(F77 g77)
2191 +        ELSE(WINDOWS)
2192 +        SET(F77 gfortran)
2193 +        ENDIF(WINDOWS)
2194 +        ADD_CUSTOM_COMMAND(
2195 +        OUTPUT ${output}
2196 +        COMMAND ${F77} -c -o ${output} ${input}
2197 +        MAIN_DEPENDENCY ${input}
2198 +        )
2199 +        ENDIF(src STREQUAL trte.f)
2200 +        ENDIF(ext STREQUAL .f)
2201 +        SET(srcs ${srcs} ${src})
2202 +        ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2203 +        ''')
2204 +        newlines.append(r'''
2205 +        SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2206 +        FOREACH(f ${l})
2207 +        SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2208 +        SET(srcs ${srcs} ${src})
2209 +        ENDFOREACH(f ${l})
2210 +        ''')
2211 +        newlines.append(r'''
2212 +        SET(build_srcs)
2213 +        SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2214 +        FOREACH(f ${l})
2215 +        GET_FILENAME_COMPONENT(ext ${f} EXT)
2216 +        IF(ext STREQUAL .py)
2217 +        SET(fff)
2218 +        ELSE(ext STREQUAL .py)
2219 +        SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2220 +        ENDIF(ext STREQUAL .py)
2221 +        IF(fff)
2222 +        IF(build_srcs)
2223 +        LIST(FIND build_srcs ${fff} index)
2224 +        IF(NOT index EQUAL -1)
2225 +        SET(fff)
2226 +        ENDIF(NOT index EQUAL -1)
2227 +        ENDIF(build_srcs)
2228 +        ENDIF(fff)
2229 +        IF(fff)
2230 +        SET(build_srcs ${build_srcs} ${fff})
2231 +        ENDIF(fff)
2232 +        ENDFOREACH(f ${l})
2233 +        ''')
2234 +        # --
2235 +        # Add the library to cmake
2236 +        # --
2237 +        newlines.append(r'''
2238 +        ADD_LIBRARY(${name} ${type} ${srcs})
2239 +        ''')
2240 +        # --
2241 +        # The compilation flags
2242 +        # --
2243 +        self.setCompilationFlags(key, newlines)
2244 +        # --
2245 +        newlines.append(r'''
2246 +        SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2247 +        ''')
2248 +        # --
2249 +        self.setLibAdd(key, newlines)
2250 +        # --
2251 +        if 1: # key != "noinst_LTLIBRARIES":
2252 +            newlines.append(r'''
2253 +            SET(key %s)
2254 +            '''%(key))
2255 +            newlines.append(r'''
2256 +            SET(test ON)
2257 +            IF(${key} STREQUAL noinst_LTLIBRARIES)
2258 +            SET(test OFF)
2259 +            ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2260 +            ''')
2261 +            if self.module == "netgen" :
2262 +                newlines.append(r'''
2263 +                IF(${key} STREQUAL noinst_LTLIBRARIES)
2264 +                IF(WINDOWS)
2265 +                SET(test ON)
2266 +                ENDIF(WINDOWS)
2267 +                ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2268 +                ''')
2269 +                pass
2270 +            newlines.append(r'''
2271 +            IF(test)
2272 +            ''')
2273 +            if self.module in ["medfile", "netgen"]:
2274 +                newlines.append(r'''
2275 +                SET(DEST lib)
2276 +                ''')
2277 +            else:
2278 +                newlines.append(r'''
2279 +                SET(DEST lib/salome)
2280 +                ''')
2281 +                pass
2282 +            newlines.append(r'''
2283 +            IF(BEGIN_WITH_lib)
2284 +            INSTALL(TARGETS ${name} DESTINATION ${DEST})
2285 +            ''')
2286 +            if self.module == "gui":
2287 +                newlines.append(r'''
2288 +                FOREACH(lib SalomePyQt)
2289 +                IF(name STREQUAL lib)
2290 +                IF(WINDOWS)
2291 +                IF(CMAKE_BUILD_TYPE STREQUAL Release)
2292 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2293 +                ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2294 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2295 +                ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2296 +                ELSE(WINDOWS)
2297 +                INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2298 +                ENDIF(WINDOWS)
2299 +                ENDIF(name STREQUAL lib)
2300 +                ENDFOREACH(lib SalomePyQt)
2301 +                FOREACH(lib SalomePy)
2302 +                IF(name STREQUAL lib)
2303 +                IF(WINDOWS)
2304 +                IF(CMAKE_BUILD_TYPE STREQUAL Release)
2305 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2306 +                ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2307 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2308 +                ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2309 +                ENDIF(WINDOWS)
2310 +                ENDIF(name STREQUAL lib)
2311 +                ENDFOREACH(lib SalomePy)
2312 +                ''')
2313 +                pass
2314 +            if self.module == "geom":
2315 +                newlines.append(r'''
2316 +                IF(WINDOWS)
2317 +                STRING(REGEX MATCH "Export" ISExport ${name})
2318 +                IF(ISExport)
2319 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2320 +                ENDIF(ISExport)
2321 +                STRING(REGEX MATCH "Import" ISImport ${name})
2322 +                IF(ISImport)
2323 +                INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2324 +                ENDIF(ISImport)
2325 +                ENDIF(WINDOWS)
2326 +                ''')
2327 +                pass
2328 +            newlines.append(r'''
2329 +            ELSE(BEGIN_WITH_lib)
2330 +            ''')
2331 +            newlines.append(r'''
2332 +            IF(WINDOWS)
2333 +            INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2334 +            IF(CMAKE_BUILD_TYPE STREQUAL Release)
2335 +            INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2336 +            ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2337 +            INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2338 +            ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2339 +            ELSE(WINDOWS)
2340 +            GET_TARGET_PROPERTY(version ${name} VERSION)
2341 +            GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2342 +            INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2343 +            INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2344 +            INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2345 +            ENDIF(WINDOWS)
2346 +            ''')
2347 +            newlines.append(r'''
2348 +            ENDIF(BEGIN_WITH_lib)
2349 +            ''')
2350 +            newlines.append(r'''
2351 +            ENDIF(test)
2352 +            ''')
2353 +            pass
2354 +        # --
2355 +        newlines.append(r'''
2356 +        ENDFOREACH(amname ${%s})
2357 +        '''%(key))
2358 +        # --
2359 +        return
2360 +
2361 +    def addBinTarget(self, key, newlines):
2362 +        # --
2363 +        newlines.append(r'''
2364 +        FOREACH(amname ${%s})
2365 +        '''%(key))
2366 +        # --
2367 +        newlines.append(r'''
2368 +        SET(test ON)
2369 +        ''')
2370 +        if key == "check_PROGRAMS":
2371 +            newlines.append(r'''
2372 +            IF(bin_PROGRAMS)
2373 +            STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2374 +            IF(is_present)
2375 +            SET(test OFF)
2376 +            ENDIF(is_present)
2377 +            ENDIF(bin_PROGRAMS)
2378 +            ''')
2379 +            pass
2380 +        newlines.append(r'''
2381 +        IF(test)
2382 +        ''')
2383 +        # --
2384 +        newlines.append(r'''
2385 +        SET(name "${amname}_exe")
2386 +        SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2387 +        SET(l ${nodist_${amname}_SOURCES})
2388 +        FOREACH(f ${l})
2389 +        SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2390 +        SET(srcs ${srcs} ${src})
2391 +        ENDFOREACH(f ${l})
2392 +        LIST(LENGTH srcs nb)
2393 +        IF(nb)
2394 +        ADD_EXECUTABLE(${name} ${srcs})
2395 +        ''')
2396 +        # --
2397 +        self.setCompilationFlags(key, newlines)
2398 +        # --
2399 +        self.setLibAdd(key, newlines)
2400 +        # --
2401 +        if self.module in ["jobmanager", "medfile", "netgen"]:
2402 +            newlines.append(r'''
2403 +            SET(DEST bin)
2404 +            ''')
2405 +        else:
2406 +            newlines.append(r'''
2407 +            SET(DEST bin/salome)
2408 +            ''')
2409 +            pass
2410 +        # --
2411 +        if key == "bin_PROGRAMS":
2412 +            newlines.append(r'''
2413 +            IF(WINDOWS)
2414 +            INSTALL(TARGETS ${name} DESTINATION ${DEST})
2415 +            INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2416 +            INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2417 +            ELSE(WINDOWS)
2418 +            SET(PERMS)
2419 +            SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2420 +            SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2421 +            SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2422 +            INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2423 +            ENDIF(WINDOWS)
2424 +            ''')
2425 +            pass
2426 +        # --
2427 +        newlines.append(r'''
2428 +        ENDIF(nb)
2429 +        ''')
2430 +        # --
2431 +        newlines.append(r'''
2432 +        ENDIF(test)
2433 +        ''')
2434 +        newlines.append(r'''
2435 +        ENDFOREACH(amname ${%s})
2436 +        '''%(key))
2437 +        # --
2438 +        return
2439 +
2440 +    def addInstallTarget(self, key, destination, newlines):
2441 +        newlines.append(r"FOREACH(f ${%s})"%(key))
2442 +        newlines.append(r'''
2443 +        SET(DEST %s)
2444 +        '''%(destination))
2445 +        newlines.append(r'''
2446 +        STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2447 +        IF(test_SALOMEconfig.h.in)
2448 +        INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2449 +        ELSE(test_SALOMEconfig.h.in)
2450 +        SET(dummy dummy-NOTFOUND)
2451 +        MARK_AS_ADVANCED(dummy)
2452 +        # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2453 +        FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2454 +        IF(dummy)
2455 +        ''')
2456 +        if key in ['dist_salomescript_SCRIPTS']:
2457 +            newlines.append(r'''
2458 +            SET(PERMS)
2459 +            SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2460 +            SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2461 +            SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2462 +            INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2463 +            ''')
2464 +        else:
2465 +            newlines.append(r'''
2466 +            GET_FILENAME_COMPONENT(ext ${f} EXT)
2467 +            IF(ext STREQUAL .py)
2468 +            IF(DEST STREQUAL bin/salome)
2469 +            SET(PERMS)
2470 +            SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2471 +            SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2472 +            SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2473 +            INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2474 +            ELSE(DEST STREQUAL bin/salome)
2475 +            INSTALL(FILES ${f} DESTINATION ${DEST})
2476 +            ENDIF(DEST STREQUAL bin/salome)
2477 +            ELSE(ext STREQUAL .py)
2478 +            INSTALL(FILES ${f} DESTINATION ${DEST})
2479 +            ENDIF(ext STREQUAL .py)
2480 +            ''')
2481 +            pass
2482 +        newlines.append(r'''
2483 +        ELSE(dummy)
2484 +        GET_FILENAME_COMPONENT(ext ${f} EXT)
2485 +        IF(ext STREQUAL .qm)
2486 +        STRING(REGEX REPLACE .qm .ts input ${f})
2487 +        ''')
2488 +        if self.module in ["kernel", "gui", "yacs"]:
2489 +            newlines.append(r'''
2490 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2491 +            ''')
2492 +        else:
2493 +            newlines.append(r'''
2494 +            SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2495 +            ''')
2496 +            pass
2497 +        newlines.append(r'''
2498 +        SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2499 +        # ADD_CUSTOM_COMMAND(
2500 +        # OUTPUT ${output}
2501 +        # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2502 +        # MAIN_DEPENDENCY ${input}
2503 +        # )
2504 +        EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2505 +        ENDIF(ext STREQUAL .qm)
2506 +        INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2507 +        ENDIF(dummy)
2508 +        ENDIF(test_SALOMEconfig.h.in)
2509 +        ''')
2510 +        newlines.append(r'''
2511 +        GET_FILENAME_COMPONENT(ext ${f} EXT)
2512 +        IF(ext STREQUAL .py)
2513 +        INSTALL(CODE "SET(PYTHON_FILE ${f})")
2514 +        INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2515 +        INSTALL(CODE "SET(DEST ${DEST})")
2516 +        INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2517 +        ''')
2518 +        if self.module == "kernel":
2519 +            newlines.append('''
2520 +            IF(f STREQUAL SALOME_ContainerPy.py)
2521 +            ELSE(f STREQUAL SALOME_ContainerPy.py)
2522 +            IF(f STREQUAL am2cmake.py)
2523 +            ELSE(f STREQUAL am2cmake.py)
2524 +            IF(f STREQUAL copytree1.py)
2525 +            ELSE(f STREQUAL copytree1.py)
2526 +            INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2527 +            ENDIF(f STREQUAL copytree1.py)
2528 +            ENDIF(f STREQUAL am2cmake.py)
2529 +            ENDIF(f STREQUAL SALOME_ContainerPy.py)
2530 +            ''')
2531 +        else:
2532 +            newlines.append('''
2533 +            STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2534 +            INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2535 +            ''')
2536 +            pass
2537 +        newlines.append(r'''
2538 +        ENDIF(ext STREQUAL .py)
2539 +        ''')
2540 +        newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2541 +        return
2542 +
2543 +    def writeListsFile(self):
2544 +        f = open(self.listsFile, "w")
2545 +        f.write(self.content)
2546 +        f.close()
2547 +        return
2548 +
2549 +    pass
2550 +
2551 +def convertAmFile(the_root, root, dirs, files, f, module):
2552 +    cmake = CMakeFile(the_root, root, dirs, files, f, module)
2553 +    cmake.writeListsFile()
2554 +    return
2555 +
2556 +def usage(exit_status):
2557 +    from sys import exit
2558 +    from sys import argv
2559 +    print "Usage: %s --module"%(argv[0])
2560 +    exit(exit_status)
2561 +    return
2562 +
2563 +if __name__ == "__main__":
2564 +    #
2565 +    from sys import argv
2566 +    if len(argv) != 2:
2567 +        usage(1)
2568 +        pass
2569 +    #
2570 +    module = argv[1]
2571 +    if module.find('--') != 0:
2572 +        usage(1)
2573 +        pass
2574 +    module = module[2:]
2575 +    if len(module) == 0:
2576 +        usage(1)
2577 +        pass
2578 +    #
2579 +    from os import getcwd
2580 +    the_root = getcwd()
2581 +    #
2582 +    nok = 0
2583 +    #
2584 +    from os import walk
2585 +    for root, dirs, files in walk(the_root):
2586 +        # --
2587 +        # E.A. : Remove 'CVS' in dirs
2588 +        # E.A. : It allows to not recurse in CVS dirs
2589 +        # E.A. : See os module python documentation
2590 +        # --
2591 +        try:
2592 +            dirs.remove('CVS')
2593 +        except ValueError:
2594 +            pass
2595 +        # --
2596 +        if "Makefile.am.cmake" in files:
2597 +            if "Makefile.am" in files:
2598 +                files.remove("Makefile.am")
2599 +                pass
2600 +            pass
2601 +        # --
2602 +        from sys import stdout
2603 +        for f in files:
2604 +            if f in ["Makefile.am", "Makefile.am.cmake"]:
2605 +                convertAmFile(the_root, root, dirs, files, f, module)
2606 +                nok += 1
2607 +                pass
2608 +            pass
2609 +        pass
2610 +    #
2611 +    if nok:
2612 +        if nok == 1:
2613 +            msg = "%s file has been converted to cmake"%(nok)
2614 +        else:
2615 +            msg = "%s files have been converted to cmake"%(nok)
2616 +            pass
2617 +        stdout.write(msg)
2618 +        stdout.write("\n")
2619 +        stdout.flush()
2620 +        pass
2621 +    pass
2622 diff -Naur netgen-4.9.13.occ/config.h.in netgen-4.9.13/config.h.in
2623 --- netgen-4.9.13.occ/config.h.in       2010-05-20 23:29:37.000000000 +0000
2624 +++ netgen-4.9.13/config.h.in   2011-04-28 08:21:18.760077010 +0000
2625 @@ -68,7 +68,7 @@
2626  #undef PACKAGE_TARNAME
2627
2628  /* Define to the version of this package. */
2629 -#undef PACKAGE_VERSION
2630 +#define PACKAGE_VERSION "4.9.13"
2631
2632  /* Define to 1 if you have the ANSI C header files. */
2633  #undef STDC_HEADERS
2634 diff -Naur netgen-4.9.13.occ/libsrc/include/Makefile.am netgen-4.9.13/libsrc/include/Makefile.am
2635 --- netgen-4.9.13.occ/libsrc/include/Makefile.am        2009-08-10 11:40:50.000000000 +0000
2636 +++ netgen-4.9.13/libsrc/include/Makefile.am    2011-04-26 15:48:56.300050773 +0000
2637 @@ -1,7 +1,9 @@
2638 -noinst_HEADERS = acisgeom.hpp gprim.hpp meshing.hpp occgeom.hpp        \
2639 +noinst_HEADERS_orig = acisgeom.hpp gprim.hpp meshing.hpp occgeom.hpp   \
2640  visual.hpp csg.hpp incvis.hpp myadt.hpp opti.hpp geometry2d.hpp        \
2641  linalg.hpp mydefs.hpp parallel.hpp stlgeom.hpp mystdlib.h
2642
2643 +noinst_HEADERS = incvis.hpp mydefs.hpp mystdlib.h
2644 +
2645  include_HEADERS = nginterface.h nginterface_v2.hpp parallelinterface.hpp
2646
2647  AM_CPPFLAGS =