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