salome_adm/cmake_files/am2cmake.py

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