salome_adm/cmake_files/am2cmake.py

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