salome_adm/cmake_files/deprecated/am2cmake.py

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