salome_adm/cmake_files/am2cmake.py

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