salome_adm/cmake_files/am2cmake.py

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