salome_adm/cmake_files/deprecated/am2cmake.py

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