salome_adm/cmake_files/am2cmake.py

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