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 in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin"]:
 807                 newlines.append(r'''
 808                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
 809                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
 810                 ''')
 811                 pass
 812             if self.module == "hxx2salome":
 813                 key = "_SRC"
 814                 if self.the_root[-len(key):] != key:
 815                     msg = "Source dir must finished with %s !"%(key)
 816                     raise Exception(msg)
 817                 hxxmodule = self.the_root[:-len(key)]
 818                 from os.path import basename
 819                 hxxmodule = basename(hxxmodule)
 820                 hxxmodule = hxxmodule.lower()
 821                 self.hxxmodule = hxxmodule
 822                 newlines.append(r'''
 823                 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
 824                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 825                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 826                 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
 827                 '''%(hxxmodule.upper()))
 828                 pass
 829             pass
 830         # --
 831         return
 832
 833     def treatLine(self, line, newlines, opened_ifs):
 834
 835         # --
 836         # Print the comment above the line itself
 837         # --
 838         if line.find('#') >= 0:
 839             fields = line.split('#')
 840             line = fields[0]
 841             comment = '#'.join([''] + fields[1:])
 842             newlines.append(comment)
 843             if len(line) == 0:
 844                 return
 845             pass
 846
 847         # --
 848         # If the line begins with 'include ', just comment it
 849         # --
 850         if line.find("include ") == 0:
 851             newlines.append("# " + line)
 852             return
 853
 854         # --
 855         # If the line begins with '-include', just comment it
 856         # --
 857         if line.find("-include") == 0:
 858             newlines.append("# " + line)
 859             return
 860
 861         # --
 862         # If the line is a definition of a make rule, just comment it
 863         # --
 864         if line.count(':') == 1:
 865             newlines.append("# " + line)
 866             return
 867
 868         # --
 869         # A particuliar case where there are two ":" on the same line
 870         # --
 871         if line.find('install-exec-local:') == 0:
 872             newlines.append("# " + line)
 873             return
 874
 875         # --
 876         # If the line begin by a tabulation, consider it's a makefile command and comment it
 877         # --
 878         if line.find("\t") == 0:
 879             newlines.append("# " + line)
 880             return
 881
 882         # --
 883         # --
 884         key = "-version-info"
 885         if line.find(key) >= 0:
 886             # --
 887             before = line.split(key)[0]
 888             after = line[len(before)+len(key):]
 889             sep = after[0]
 890             after = after[1:]
 891             version_info = after.split()[0]
 892             line = line.replace(key+sep+version_info, "")
 893             # --
 894             version_info = version_info.replace(':', '.')
 895             soversion_info = version_info.split('.')[0]
 896             newlines.append("SET(VERSION_INFO " + version_info + ")")
 897             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 898             # --
 899             pass
 900
 901         # --
 902         # Replace the $(TOTO) by ${TOTO}
 903         # Replace the @TOTO@  by ${TOTO}
 904         # --
 905         line = p_dollar.sub(r"${\1}", line)
 906         line = p_arobas.sub(r"${\1}", line)
 907
 908         # --
 909         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 910         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 911         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 912         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 913         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 914
 915         # --
 916         # Check if the line is a 'if' condition
 917         # If yes, replace it by a cmake grammar
 918         # --
 919         match = p_if.match(line)
 920         if match:
 921             theif = match.group("val")
 922             if theif[0] == "!":
 923                 theif = "NOT " + theif[1:]
 924                 pass
 925             line = p_if.sub(r"IF(%s)"%(theif), line)
 926             opened_ifs.append(theif)
 927             newlines.append(line)
 928             return
 929
 930         # --
 931         # Check if the line is a 'else' condition
 932         # If yes, replace it by a cmake grammar
 933         # --
 934         match = p_else.match(line)
 935         if match:
 936             line = "ELSE(%s)"%(opened_ifs[-1])
 937             newlines.append(line)
 938             return
 939
 940         # --
 941         # Check if the line is a 'endif' condition
 942         # If yes, replace it by a cmake grammar
 943         # --
 944         match = p_endif.match(line)
 945         if match:
 946             line = "ENDIF(%s)"%(opened_ifs[-1])
 947             opened_ifs[-1:] = []
 948             newlines.append(line)
 949             return
 950
 951         # --
 952         # Check if the line is an attribution '=' or '+='
 953         # --
 954         match = p_attribution.match(line)
 955         if match:
 956             self.treatAttribution(match, newlines)
 957             return
 958
 959         # --
 960         newlines.append(line)
 961
 962         # --
 963         return
 964
 965     def treatAttribution(self, match, newlines):
 966
 967         spaces = match.group("spaces")
 968         key = match.group("key")
 969         method = match.group("method")
 970         value = match.group("value")
 971         # print [spaces, key, method, value]
 972
 973         # --
 974         # Open cmake SET command
 975         # --
 976         newlines.append(spaces + "SET(" + key)
 977
 978         # --
 979         # If method is '+=', put the previous definition as first value
 980         # --
 981         if method == "+=":
 982             newlines.append("%s    ${%s}"%(spaces, key))
 983             pass
 984
 985         # --
 986         fields = value.split()
 987         for i in range(len(fields)):
 988             newlines.append("%s    %s"%(spaces, fields[i]))
 989             pass
 990
 991         # --
 992         if method == "+=":
 993             # --
 994             # The try: except KeyError is here if the +=
 995             # is an error which occurs in salome ...
 996             # --
 997             try:
 998                 self.__thedict__[key] += fields[:]
 999             except KeyError:
1000                 self.__thedict__[key] = fields[:]
1001                 pass
1002             pass
1003         else:
1004             self.__thedict__[key]  = fields[:]
1005             pass
1006
1007         # --
1008         # Close cmake SET command
1009         # --
1010
1011         newlines.append("%s)"%(spaces))
1012
1013         return
1014
1015     def finalize(self, newlines):
1016
1017         # --
1018         # Convert the .in files in build dir
1019         # --
1020
1021         import operator
1022         mod = self.module
1023         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1024             newlines.append(r'''
1025             SET(top_builddir
1026                 ${CMAKE_BINARY_DIR}
1027             )
1028             SET(top_srcdir
1029                 ${CMAKE_SOURCE_DIR}
1030             )
1031             SET(srcdir
1032                 ${CMAKE_CURRENT_SOURCE_DIR}
1033             )
1034             SET(builddir
1035                 ${CMAKE_CURRENT_BINARY_DIR}
1036             )
1037             SET(datadir
1038                 ${CMAKE_INSTALL_PREFIX}/share
1039             )
1040             SET(docdir
1041                 ${datadir}/doc/salome
1042             )
1043             ''')
1044             self.files.append("static/header.html.in")
1045         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':
1046             newlines.append(r'''
1047             SET(top_builddir
1048                 ${CMAKE_BINARY_DIR}
1049             )
1050             SET(top_srcdir
1051                 ${CMAKE_SOURCE_DIR}
1052             )
1053             SET(srcdir
1054                 ${CMAKE_CURRENT_SOURCE_DIR}
1055             )
1056             SET(builddir
1057                 ${CMAKE_CURRENT_BINARY_DIR}
1058             )
1059             SET(datadir
1060                 ${CMAKE_INSTALL_PREFIX}/share
1061             )
1062             SET(docdir
1063                 ${datadir}/doc/salome
1064             )
1065             ''')
1066             self.files.append("static/header.html.in")
1067         if self.module == "yacs":
1068             key = "salomegui"
1069             if self.root[-len(key):] == key:
1070                 self.files.append("resources/YACSCatalog.xml.in")
1071                 pass
1072             pass
1073         for f in self.files:
1074             if f[-3:] == ".in":
1075                 if self.module == 'yacs' and f == "Doxyfile.in":
1076                     continue
1077                 if f == "sstream.in":
1078                     continue
1079                 if f in ["runContainer.in", "stopContainer.in"]:
1080                     if self.module == "med":
1081                         if self.root[-3:] == "csh":
1082                             continue
1083                         pass
1084                     pass
1085                 if f == "SALOMEconfig.ref.in":
1086                     out = "SALOMEconfig.h"
1087                 else:
1088                     out = f[:-3]
1089                     pass
1090                 newlines.append(r'''
1091                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1092                 '''%(f))
1093                 newlines.append(r'''
1094                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1095                 '''%(out))
1096                 newlines.append(r'''
1097                 MESSAGE(STATUS "Creation of ${output}")
1098                 CONFIGURE_FILE(${input} ${output})
1099                 ''')
1100                 pass
1101             pass
1102
1103         # --
1104         # add commands for generating of user's documentation
1105         # --
1106
1107         upmod = self.module.upper()
1108         doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1109         doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1110         doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1111         head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1112         if mod == 'kernel':
1113             copytree_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files"
1114         else:
1115             copytree_src = "$ENV{KERNEL_ROOT_DIR}/salome_adm/cmake_files"
1116         str = "import re \nimport sys \noutfile = open(sys.argv[1], 'wb') \nfor line in open(sys.argv[2], 'rb').readlines():"
1117         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)"
1118         str += "\n    outfile.write(line) \noutfile.close()"
1119
1120         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1121             if mod == 'med':
1122                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1123                 input = "Doxyfile_med_user"
1124             else:
1125                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1126                 input = ""
1127             newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1128             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''')"
1129             VERBATIM
1130             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1131             )"""%(input, copytree_src, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1132
1133         if mod in ['geom', 'smesh', 'visu'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc'):
1134             ign = r"""'tempfile', '*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1135             if mod in ['geom', 'smesh']:
1136                 if mod == 'geom':
1137                     tmp = 'geompy'
1138                     input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1139                 else:
1140                     tmp =  'smesh'
1141                     input = ''
1142                 newlines.append(r"""
1143                 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1144                 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
1145                 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1146                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1147                 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1148                 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''')"
1149                 VERBATIM
1150                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1151                 )"""%(str, upmod, tmp, upmod, tmp, tmp, input, upmod, tmp, copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1152             else:
1153                 newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} doxyfile_idl
1154                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1155                 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''')"
1156                 VERBATIM
1157                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1158                 )"""%(copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1159
1160         # --
1161         # add commands for generating of developer's documentation
1162         # --
1163
1164         upmod = self.module.upper()
1165         if mod in ['kernel', 'gui', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1166             if mod == 'kernel':
1167                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1168             COMMAND ${DOXYGEN_EXECUTABLE}
1169             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')"  """
1170                 tmp1=""
1171             else:
1172                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1173                 if mod == 'visu':
1174                     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)
1175                 elif mod == 'smesh':
1176                     extra_srcdir = "${CMAKE_CURRENT_SOURCE_DIR}/extra"
1177                     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''')"
1178             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)
1179                 else:
1180                     tmp1=""
1181             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1182             newlines.append(tmp + """
1183             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 + """
1184             VERBATIM
1185             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1186             )""")
1187         if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1188             tmp = 'geompy'
1189             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1190             newlines.append(r"""
1191             FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1192             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
1193             COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1194             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1195             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''')"
1196             VERBATIM
1197             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1198             )"""%(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))
1199
1200         # --
1201         # convert the SUBDIRS in cmake grammar
1202         # --
1203         if 1: # self.__thedict__.has_key("SUBDIRS"):
1204             newlines.append(r'''
1205             FOREACH(dir ${SUBDIRS})
1206             IF(NOT dir STREQUAL .)
1207             ADD_SUBDIRECTORY(${dir})
1208             ENDIF(NOT dir STREQUAL .)
1209             ENDFOREACH(dir ${SUBDIRS})
1210             ''')
1211             pass
1212
1213         # --
1214         # --
1215         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
1216             if self.__thedict__.has_key(key):
1217                 self.addLibTarget(key, newlines)
1218                 pass
1219             pass
1220
1221         # --
1222         # --
1223         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1224             if self.__thedict__.has_key(key):
1225                 self.addBinTarget(key, newlines)
1226                 pass
1227             pass
1228
1229         # --
1230         # --
1231         if self.__thedict__.has_key("BASEIDL_FILES"):
1232             if not self.__thedict__.has_key("IDL_FILES"):
1233                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1234                 newlines.append('''
1235                 SET(IDL_FILES ${BASEIDL_FILES})
1236                 ''')
1237                 pass
1238             pass
1239
1240         # --
1241         # --
1242
1243         key = "IDL_FILES"
1244         if self.__thedict__.has_key(key):
1245             if self.module == "kernel":
1246                 newlines.append('''
1247                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1248                 ''')
1249                 pass
1250             newlines.append('''
1251             FOREACH(input ${IDL_FILES})
1252             STRING(REGEX REPLACE ".idl" "" base ${input})
1253             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1254             SET(outputs ${src})
1255             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1256             SET(outputs ${outputs} ${dynsrc})
1257             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1258             SET(outputs ${outputs} ${inc})
1259             IF(input STREQUAL Calcium_Ports.idl)
1260             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1261             ELSE(input STREQUAL Calcium_Ports.idl)
1262             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1263             ENDIF(input STREQUAL Calcium_Ports.idl)
1264             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1265             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1266             IF(NOT ISBCXX)
1267             SET(flags -bcxx ${flags})
1268             ENDIF(NOT ISBCXX)
1269             ADD_CUSTOM_COMMAND(
1270             OUTPUT ${outputs}
1271             COMMAND ${OMNIORB_IDL} ${flags} ${input}
1272             MAIN_DEPENDENCY ${input}
1273             )
1274             ''')
1275             newlines.append('''
1276             install(FILES ${input} DESTINATION idl/salome)
1277             ''')
1278             if self.module not in ["pyhello"]:
1279                 newlines.append('''
1280                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1281                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1282                 ''')
1283                 pass
1284             newlines.append('''
1285             INSTALL(CODE "SET(IDL_FILE ${input})")
1286             INSTALL(CODE "SET(DIR ${salomepythondir})")
1287             IF(WINDOWS)
1288             INSTALL(CODE "SET(DIR bin/salome)")
1289             ENDIF(WINDOWS)
1290             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1291             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1292             # --
1293             SET(flags)
1294             FOREACH(f ${IDLPYFLAGS})
1295             SET(flags "${flags} ${f}")
1296             ENDFOREACH(f ${IDLPYFLAGS})
1297             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1298             IF(NOT ISBPYTHON)
1299             SET(flags "-bpython ${flags}")
1300             ENDIF(NOT ISBPYTHON)
1301             SET(IDLPYFLAGS ${flags})
1302             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1303             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1304             # --
1305             ''')
1306             if self.module == "kernel":
1307                 newlines.append('''
1308                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1309                 ''')
1310             else:
1311                 newlines.append('''
1312                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1313                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1314                 ''')
1315                 pass
1316             newlines.append('''
1317             ENDFOREACH(input ${IDL_FILES})
1318             ''')
1319             pass
1320
1321         # --
1322         # --
1323         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1324             if self.__thedict__.has_key(key):
1325                 newlines.append('''
1326                 SET(SWIG_SOURCES ${%s})
1327                 '''%(key))
1328                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1329                 pass
1330             pass
1331
1332         # --
1333         # --
1334         if self.__thedict__.has_key("SWIG_SOURCES"):
1335             newlines.append('''
1336             IF(SWIG_SOURCES MATCHES ";")
1337             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1338             ELSE(SWIG_SOURCES MATCHES ";")
1339             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1340             ENDIF(SWIG_SOURCES MATCHES ";")
1341             SET(flags)
1342             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1343             SET(test ON)
1344             IF(flags)
1345             LIST(FIND flags ${f} index)
1346             IF(NOT index EQUAL -1)
1347             SET(test OFF)
1348             ENDIF(NOT index EQUAL -1)
1349             ENDIF(flags)
1350             IF(test)
1351             SET(flags ${flags} ${f})
1352             ENDIF(test)
1353             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1354             ADD_CUSTOM_COMMAND(
1355             OUTPUT ${build_srcs}
1356             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1357             MAIN_DEPENDENCY ${SWIG_SOURCES}
1358             )
1359             ''')
1360             pass
1361
1362         # --
1363         # --
1364         if self.__thedict__.has_key("BUILT_SOURCES"):
1365             newlines.append('''
1366             FOREACH(f ${BUILT_SOURCES})
1367             IF(f MATCHES "WRAP.cxx$")
1368             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1369             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1370             ADD_CUSTOM_COMMAND(
1371             OUTPUT ${f} # ${inc}
1372             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1373             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1374             )
1375             ENDIF(f MATCHES "WRAP.cxx$")
1376             ENDFOREACH(f ${BUILT_SOURCES})
1377             ''')
1378             pass
1379
1380         # --
1381         # --
1382         key = "MOC_FILES"
1383         if self.__thedict__.has_key(key):
1384             newlines.append('''
1385             FOREACH(output ${MOC_FILES})
1386             ''')
1387             if self.module in ["jobmanager", "yacs"]:
1388                 newlines.append('''
1389                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1390                 ''')
1391             else:
1392                 newlines.append('''
1393                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1394                 ''')
1395                 pass
1396             newlines.append('''
1397             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1398             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1399             ADD_CUSTOM_COMMAND(
1400             OUTPUT ${output}
1401             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1402             MAIN_DEPENDENCY ${input}
1403             )
1404             ENDFOREACH(output ${MOC_FILES})
1405             ''')
1406             pass
1407
1408         # --
1409         # --
1410         key = "UIC_FILES"
1411         if self.__thedict__.has_key(key):
1412             newlines.append('''
1413             FOREACH(output ${UIC_FILES})
1414             STRING(REPLACE "ui_" "" input ${output})
1415             STRING(REPLACE ".h" ".ui" input ${input})
1416             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1417             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1418             ADD_CUSTOM_COMMAND(
1419             OUTPUT ${output}
1420             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1421             MAIN_DEPENDENCY ${input}
1422             )
1423             ENDFOREACH(output ${UIC_FILES})
1424             ''')
1425             pass
1426
1427         # --
1428         # --
1429         key = "QRC_FILES"
1430         if self.__thedict__.has_key(key):
1431             newlines.append('''
1432             FOREACH(output ${QRC_FILES})
1433             STRING(REGEX REPLACE "qrc_" "" input ${output})
1434             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1435             STRING(REGEX REPLACE ".qrc" "" name ${input})
1436             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1437             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1438             ADD_CUSTOM_COMMAND(
1439             OUTPUT ${output}
1440             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1441             MAIN_DEPENDENCY ${input}
1442             )
1443             ENDFOREACH(output ${QRC_FILES})
1444             ''')
1445             pass
1446
1447         # --
1448         # --
1449         key = "SIP_FILES"
1450         if self.__thedict__.has_key(key):
1451             newlines.append('''
1452             FOREACH(input ${SIP_FILES})
1453             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1454             SET(output)
1455             FOREACH(out ${SIP_SRC})
1456             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1457             ENDFOREACH(out ${SIP_SRC})
1458             ADD_CUSTOM_COMMAND(
1459             OUTPUT ${output}
1460             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1461             MAIN_DEPENDENCY ${input}
1462             )
1463             ENDFOREACH(input ${SIP_FILES})
1464             ''')
1465             pass
1466
1467         # --
1468         # For make check
1469         # --
1470         for key in ["TESTS"]:
1471             if self.__thedict__.has_key(key):
1472                 newlines.append('''
1473                 SET(UNIT_TEST_PROG ${%s})
1474                 '''%(key))
1475                 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1476                 pass
1477             pass
1478         key = "UNIT_TEST_PROG"
1479         if self.__thedict__.has_key(key):
1480             newlines.append('''
1481             FOREACH(input ${UNIT_TEST_PROG})
1482             GET_FILENAME_COMPONENT(ext ${input} EXT)
1483             IF(ext STREQUAL .py)
1484             SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1485             ELSE(ext STREQUAL .py)
1486             IF(WINDOWS)
1487             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1488             ELSE()
1489             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1490             ENDIF()
1491             ENDIF(ext STREQUAL .py)
1492             ADD_TEST(${input} ${test})
1493             SET(fail_regex "KO")
1494             SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1495             # IF(NOT WINDOWS)
1496             # ADD_TEST(${input}_valgrind valgrind ${test})
1497             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1498             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1499             # ENDIF()
1500             ENDFOREACH(input ${UNIT_TEST_PROG})
1501             ''')
1502             pass
1503
1504         # --
1505         # Treat the install targets
1506         # --
1507         resdir = self.module
1508         if resdir == "hxx2salome":
1509             resdir = self.hxxmodule
1510             pass
1511         d = {
1512             "salomeadmux_DATA"                 :  "salome_adm/unix",
1513             "dist_salomeadmux_DATA"            :  "salome_adm/unix",
1514             "dist_salome_cmake_DATA"           :  "salome_adm/cmake_files",
1515             "dist_salomem4_DATA"               :  "salome_adm/unix/config_files",
1516             "dist_salome4depr_DATA"            :  "salome_adm/unix/config_files/DEPRECATED",
1517             "dist_admlocalm4_DATA"             :  "adm_local/unix/config_files",
1518             "dist_admlocal_cmake_DATA"         :  "adm_local/cmake_files",
1519             "salomeinclude_DATA"               :  "include/salome",
1520             "salomeinclude_HEADERS"            :  "include/salome",
1521             "nodist_salomeinclude_HEADERS"     :  "include/salome",
1522             "dist_salomeres_DATA"              :  "share/salome/resources/%s"%(resdir),
1523             "nodist_salomeres_DATA"            :  "share/salome/resources/%s"%(resdir),
1524             "nodist_salomeres_SCRIPTS"         :  "share/salome/resources/%s"%(resdir),
1525             "dist_salomescript_SCRIPTS"        :  "bin/salome",
1526             "dist_salomescript_DATA"           :  "bin/salome",
1527             "dist_salomescript_PYTHON"         :  "bin/salome",
1528             "nodist_salomescript_DATA"         :  "bin/salome",
1529             "salomepython_PYTHON"              :  "${salomepythondir}",
1530             "nodist_salomepython_PYTHON"       :  "${salomepythondir}",
1531             "dist_salomepython_DATA"           :  "${salomepythondir}",
1532             "sharedpkgpython_PYTHON"           :  "${salomepythondir}/shared_modules",
1533             "salomepypkg_PYTHON"               :  "${salomepypkgdir}",
1534             "mypkgpython_PYTHON"               :  "${mypkgpythondir}",
1535             }
1536         if self.module == "jobmanager":
1537             d["bin_SCRIPTS"] = "bin"
1538             pass
1539         if self.module == "medfile":
1540             d = {
1541                 "include_HEADERS"        :  "include",
1542                 "nodist_include_HEADERS" :  "include",
1543                 "bin_SCRIPTS"            :  "bin",
1544                 "doc_DATA"               :  "${docdir}",
1545                 }
1546             pass
1547         if self.module == "netgen":
1548             d = {
1549                 "include_HEADERS"        :  "include",
1550                 "noinst_HEADERS"         :  "share/netgen/include",
1551                 "dist_pkgdata_DATA"      :  "share/netgen",
1552                 "dist_doc_DATA"          :  "share/doc/netgen",
1553                 }
1554             pass
1555         for key, value in d.items():
1556             if self.__thedict__.has_key(key):
1557                 self.addInstallTarget(key, value, newlines)
1558                 pass
1559             pass
1560
1561         # --
1562         return
1563
1564     def setLibAdd(self, key, newlines):
1565         # --
1566         newlines.append(r'''
1567         SET(libadd)
1568         ''')
1569         # --
1570         newlines.append(r'''
1571         IF(WINDOWS)
1572         SET(targets)
1573         SET(targets ${targets} MEFISTO2D)
1574         FOREACH(target ${targets})
1575         IF(name STREQUAL ${target})
1576         SET(dir $ENV{F2CHOME})
1577         STRING(REPLACE "\\\\" "/" dir ${dir})
1578         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1579         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1580         ENDIF(name STREQUAL ${target})
1581         ENDFOREACH(target ${targets})
1582         ENDIF(WINDOWS)
1583         ''')
1584         # --
1585         newlines.append(r'''
1586         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1587         FOREACH(lib SALOMEBasics SalomeBatch)
1588         IF(name STREQUAL lib)
1589         SET(libs ${libs} ${PTHREAD_LIBS})
1590         ENDIF(name STREQUAL lib)
1591         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1592         ''')
1593         # --
1594         newlines.append(r'''
1595         FOREACH(lib ${libs})
1596         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1597         IF(ext STREQUAL .la)
1598         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1599         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1600         ENDIF(ext STREQUAL .la)
1601         SET(vars)
1602         SET(vars ${vars} -no-undefined)
1603         SET(vars ${vars} -lvtkWidgets)
1604         IF(WINDOWS)
1605         SET(vars ${vars} -module)
1606         SET(vars ${vars} -Wl,-E)
1607         SET(vars ${vars} -Xlinker)
1608         SET(vars ${vars} -export-dynamic)
1609         SET(vars ${vars} -lm)
1610         SET(vars ${vars} -lboost_thread)
1611         SET(vars ${vars} -lboost_signals)
1612         SET(vars ${vars} -pthread -lpthread -ldl)
1613         ENDIF(WINDOWS)
1614         FOREACH(v ${vars})
1615         IF(lib STREQUAL v)
1616         SET(lib)
1617         ENDIF(lib STREQUAL v)
1618         ENDFOREACH(v ${vars})
1619         SET(test OFF)
1620         IF(lib)
1621         STRING(REGEX MATCH "^-lQt" test ${lib})
1622         ENDIF(lib)
1623         IF(NOT test)
1624         SET(libadd ${libadd} ${lib})
1625         ENDIF(NOT test)
1626         ENDFOREACH(lib ${libs})
1627         TARGET_LINK_LIBRARIES(${name} ${libadd})
1628         ''')
1629         # --
1630         newlines.append(r'''
1631         IF(WINDOWS)
1632         SET(targets)
1633         SET(targets ${targets} MEFISTO2D)
1634         FOREACH(target ${targets})
1635         IF(name STREQUAL ${target})
1636         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1637         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1638         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1639         ENDIF(name STREQUAL ${target})
1640         ENDFOREACH(target ${targets})
1641         ENDIF(WINDOWS)
1642         ''')
1643         # --
1644         return
1645
1646     def setCompilationFlags(self, key, newlines):
1647         newlines.append(r'''
1648         SET(var)
1649         IF(WINDOWS)
1650         SET(targets)
1651         SET(targets ${targets} SalomeIDLKernel)
1652         SET(targets ${targets} SalomeDS)
1653         SET(targets ${targets} SALOMEDSTest)
1654         SET(targets ${targets} SALOMEDS_Client_exe)
1655         SET(targets ${targets} SalomeIDLGEOM)
1656         SET(targets ${targets} GEOMEngine)
1657         SET(targets ${targets} MEDEngine)
1658         SET(targets ${targets} SMESHEngine)
1659         SET(targets ${targets} SMESH)
1660         FOREACH(target ${targets})
1661         IF(name STREQUAL ${target})
1662         SET(var ${var} -DNOGDI)
1663         ENDIF(name STREQUAL ${target})
1664         ENDFOREACH(target ${targets})
1665         ENDIF(WINDOWS)
1666         ''')
1667         # --
1668         if self.module in ["medfile", "yacs"]:
1669             newlines.append(r'''
1670             IF(WINDOWS)
1671             SET(var ${var} -DNOGDI)
1672             ENDIF(WINDOWS)
1673             ''')
1674             pass
1675         # --
1676         newlines.append(r'''
1677         IF(WINDOWS)
1678         SET(targets)
1679         SET(targets ${targets} MEFISTO2D)
1680         FOREACH(target ${targets})
1681         IF(name STREQUAL ${target})
1682         SET(dir $ENV{F2CHOME})
1683         STRING(REPLACE "\\\\" "/" dir ${dir})
1684         SET(var ${var} -I${dir})
1685         SET(var ${var} -DF2C_BUILD)
1686         ENDIF(name STREQUAL ${target})
1687         ENDFOREACH(target ${targets})
1688         ENDIF(WINDOWS)
1689         ''')
1690         # --
1691         if self.module in ["geom", "med"]:
1692             newlines.append(r'''
1693             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1694             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1695             ''')
1696             pass
1697         newlines.append(r'''
1698         SET(var ${var} ${AM_CPPFLAGS})
1699         SET(var ${var} ${AM_CXXFLAGS})
1700         ''')
1701         # --
1702         newlines.append(r'''
1703         IF(type STREQUAL STATIC)
1704         SET(var ${var} -fPIC)
1705         ENDIF(type STREQUAL STATIC)
1706         ''')
1707         # --
1708         if self.module == "yacs":
1709             newlines.append(r'''
1710             SET(var ${var} -DYACS_PTHREAD)
1711             SET(var ${var} -DCMAKE_BUILD)
1712             SET(var ${var} -DSALOME_KERNEL)
1713             SET(var ${var} -DDSC_PORTS)
1714             SET(var ${var} -DOMNIORB)
1715             ''')
1716             pass
1717         newlines.append(r'''
1718         SET(var ${var} ${PLATFORM_CPPFLAGS})
1719         SET(var ${var} ${PTHREAD_CFLAGS})
1720         SET(var ${var} ${${amname}_CPPFLAGS})
1721         SET(var ${var} ${${amname}_CXXFLAGS})
1722         SET(var ${var} ${${amname}_CFLAGS})
1723         SET(vars)
1724         IF(WINDOWS)
1725         SET(vars ${vars} -include SALOMEconfig.h)
1726         SET(vars ${vars} -ftemplate-depth-32)
1727         SET(vars ${vars} -fPIC)
1728         SET(vars ${vars} -g)
1729         ENDIF(WINDOWS)
1730         SET(flags)
1731         FOREACH(f ${var})
1732         FOREACH(v ${vars})
1733         IF(f STREQUAL v)
1734         SET(f)
1735         ENDIF(f STREQUAL v)
1736         ENDFOREACH(v ${vars})
1737         IF(f)
1738         string(REGEX MATCH "^-I" test_include ${f})
1739         if(test_include)
1740         string(REGEX REPLACE "^-I" "" include_dir ${f})
1741         if(include_dir)
1742         if(include_dir STREQUAL /usr/include)
1743         else(include_dir STREQUAL /usr/include)
1744         string(REGEX MATCH "^\\." test_dot ${include_dir})
1745         if(test_dot)
1746         set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
1747         endif(test_dot)
1748         include_directories(${include_dir})
1749         endif(include_dir STREQUAL /usr/include)
1750         endif(include_dir)
1751         else(test_include)
1752         SET(flags "${flags} ${f}")
1753         endif(test_include)
1754         ENDIF(f)
1755         ENDFOREACH(f ${var})
1756         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1757         ''')
1758         return
1759
1760     def addLibTarget(self, key, newlines):
1761         newlines.append(r'''
1762         FOREACH(amname ${%s})
1763         '''%(key))
1764         # --
1765         # Replace .la by _la ...
1766         # --
1767         newlines.append(r'''
1768         STRING(REPLACE .la _la amname ${amname})
1769         ''')
1770         # --
1771         # Remove the _la for the cmake name
1772         # --
1773         newlines.append(r'''
1774         STRING(LENGTH ${amname} len)
1775         MATH(EXPR newlen "${len}-3")
1776         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1777         ''')
1778         # --
1779         # Does the target begins with lib ??
1780         # If yes, remove lib at beginning for cmake name
1781         # --
1782         newlines.append(r'''
1783         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1784         IF(BEGIN_WITH_lib)
1785         STRING(LENGTH ${name} len)
1786         MATH(EXPR newlen "${len}-3")
1787         STRING(SUBSTRING ${name} 3 ${newlen} name)
1788         ENDIF(BEGIN_WITH_lib)
1789         ''')
1790         # --
1791         # Does the target is an idl library
1792         # --
1793         newlines.append(r'''
1794         STRING(REGEX MATCH "IDL" ISIDL ${name})
1795         ''')
1796         # --
1797         # Set the type of the library
1798         # --
1799         newlines.append(r'''
1800         IF(ISIDL)
1801         IF(WINDOWS)
1802         SET(type STATIC)
1803         ELSE(WINDOWS)
1804         SET(type SHARED)
1805         ENDIF(WINDOWS)
1806         ELSE(ISIDL)
1807         SET(type SHARED)
1808         ENDIF(ISIDL)
1809         ''')
1810         if key == "noinst_LTLIBRARIES":
1811             newlines.append(r'''
1812             IF(WINDOWS)
1813             SET(type STATIC)
1814             ELSE(WINDOWS)
1815             SET(type STATIC)
1816             ENDIF(WINDOWS)
1817             ''')
1818             pass
1819         # --
1820         # Set sources for the library
1821         # --
1822         newlines.append(r'''
1823         SET(srcs)
1824         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1825         GET_FILENAME_COMPONENT(ext ${src} EXT)
1826         IF(ext STREQUAL .f)
1827         IF(src STREQUAL trte.f)
1828         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1829         STRING(REPLACE ".f" ".c" src ${src})
1830         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1831         SET(output ${src})
1832         SET(cmd f2c)
1833         IF(NOT WINDOWS)
1834         IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
1835         SET(cmd valgrind f2c)  # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
1836         ENDIF()
1837         ENDIF(NOT WINDOWS)
1838         ADD_CUSTOM_COMMAND(
1839         OUTPUT ${output}
1840         COMMAND ${cmd} ${input}
1841         MAIN_DEPENDENCY ${input}
1842         )
1843         ELSE(src STREQUAL trte.f)
1844         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1845         STRING(REPLACE ".f" ".o" src ${src})
1846         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1847         SET(output ${src})
1848         IF(WINDOWS)
1849         SET(F77 g77)
1850         ELSE(WINDOWS)
1851         SET(F77 gfortran)
1852         ENDIF(WINDOWS)
1853         ADD_CUSTOM_COMMAND(
1854         OUTPUT ${output}
1855         COMMAND ${F77} -c -o ${output} ${input}
1856         MAIN_DEPENDENCY ${input}
1857         )
1858         ENDIF(src STREQUAL trte.f)
1859         ENDIF(ext STREQUAL .f)
1860         SET(srcs ${srcs} ${src})
1861         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1862         ''')
1863         newlines.append(r'''
1864         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1865         FOREACH(f ${l})
1866         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1867         SET(srcs ${srcs} ${src})
1868         ENDFOREACH(f ${l})
1869         ''')
1870         newlines.append(r'''
1871         SET(build_srcs)
1872         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1873         FOREACH(f ${l})
1874         GET_FILENAME_COMPONENT(ext ${f} EXT)
1875         IF(ext STREQUAL .py)
1876         SET(fff)
1877         ELSE(ext STREQUAL .py)
1878         SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
1879         ENDIF(ext STREQUAL .py)
1880         IF(fff)
1881         IF(build_srcs)
1882         LIST(FIND build_srcs ${fff} index)
1883         IF(NOT index EQUAL -1)
1884         SET(fff)
1885         ENDIF(NOT index EQUAL -1)
1886         ENDIF(build_srcs)
1887         ENDIF(fff)
1888         IF(fff)
1889         SET(build_srcs ${build_srcs} ${fff})
1890         ENDIF(fff)
1891         ENDFOREACH(f ${l})
1892         ''')
1893         # --
1894         # Add the library to cmake
1895         # --
1896         newlines.append(r'''
1897         ADD_LIBRARY(${name} ${type} ${srcs})
1898         ''')
1899         # --
1900         # The compilation flags
1901         # --
1902         self.setCompilationFlags(key, newlines)
1903         # --
1904         newlines.append(r'''
1905         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1906         ''')
1907         # --
1908         self.setLibAdd(key, newlines)
1909         # --
1910         if 1: # key != "noinst_LTLIBRARIES":
1911             newlines.append(r'''
1912             SET(key %s)
1913             '''%(key))
1914             newlines.append(r'''
1915             SET(test ON)
1916             IF(${key} STREQUAL noinst_LTLIBRARIES)
1917             SET(test OFF)
1918             ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
1919             ''')
1920             if self.module == "netgen" :
1921                 newlines.append(r'''
1922                 IF(${key} STREQUAL noinst_LTLIBRARIES)
1923                 IF(WINDOWS)
1924                 SET(test ON)
1925                 ENDIF(WINDOWS)
1926                 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
1927                 ''')
1928                 pass
1929             newlines.append(r'''
1930             IF(test)
1931             ''')
1932             if self.module in ["medfile", "netgen"]:
1933                 newlines.append(r'''
1934                 SET(DEST lib)
1935                 ''')
1936             else:
1937                 newlines.append(r'''
1938                 SET(DEST lib/salome)
1939                 ''')
1940                 pass
1941             newlines.append(r'''
1942             IF(BEGIN_WITH_lib)
1943             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1944             ''')
1945             if self.module == "gui":
1946                 newlines.append(r'''
1947                 FOREACH(lib SalomePyQt)
1948                 IF(name STREQUAL lib)
1949                 IF(WINDOWS)
1950                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1951                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1952                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1953                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1954                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1955                 ELSE(WINDOWS)
1956                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1957                 ENDIF(WINDOWS)
1958                 ENDIF(name STREQUAL lib)
1959                 ENDFOREACH(lib SalomePyQt)
1960                 FOREACH(lib SalomePy)
1961                 IF(name STREQUAL lib)
1962                 IF(WINDOWS)
1963                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1964                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1965                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1966                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1967                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1968                 ENDIF(WINDOWS)
1969                 ENDIF(name STREQUAL lib)
1970                 ENDFOREACH(lib SalomePy)
1971                 ''')
1972                 pass
1973             if self.module == "geom":
1974                 newlines.append(r'''
1975                 IF(WINDOWS)
1976                 STRING(REGEX MATCH "Export" ISExport ${name})
1977                 IF(ISExport)
1978                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1979                 ENDIF(ISExport)
1980                 STRING(REGEX MATCH "Import" ISImport ${name})
1981                 IF(ISImport)
1982                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1983                 ENDIF(ISImport)
1984                 ENDIF(WINDOWS)
1985                 ''')
1986                 pass
1987             newlines.append(r'''
1988             ELSE(BEGIN_WITH_lib)
1989             ''')
1990             newlines.append(r'''
1991             IF(WINDOWS)
1992             INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
1993             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1994             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
1995             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1996             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
1997             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1998             ELSE(WINDOWS)
1999             GET_TARGET_PROPERTY(version ${name} VERSION)
2000             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2001             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2002             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2003             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2004             ENDIF(WINDOWS)
2005             ''')
2006             newlines.append(r'''
2007             ENDIF(BEGIN_WITH_lib)
2008             ''')
2009             newlines.append(r'''
2010             ENDIF(test)
2011             ''')
2012             pass
2013         # --
2014         newlines.append(r'''
2015         ENDFOREACH(amname ${%s})
2016         '''%(key))
2017         # --
2018         return
2019
2020     def addBinTarget(self, key, newlines):
2021         # --
2022         newlines.append(r'''
2023         FOREACH(amname ${%s})
2024         '''%(key))
2025         # --
2026         newlines.append(r'''
2027         SET(test ON)
2028         ''')
2029         if key == "check_PROGRAMS":
2030             newlines.append(r'''
2031             IF(bin_PROGRAMS)
2032             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2033             IF(is_present)
2034             SET(test OFF)
2035             ENDIF(is_present)
2036             ENDIF(bin_PROGRAMS)
2037             ''')
2038             pass
2039         newlines.append(r'''
2040         IF(test)
2041         ''')
2042         # --
2043         newlines.append(r'''
2044         SET(name "${amname}_exe")
2045         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2046         SET(l ${nodist_${amname}_SOURCES})
2047         FOREACH(f ${l})
2048         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2049         SET(srcs ${srcs} ${src})
2050         ENDFOREACH(f ${l})
2051         LIST(LENGTH srcs nb)
2052         IF(nb)
2053         ADD_EXECUTABLE(${name} ${srcs})
2054         ''')
2055         # --
2056         self.setCompilationFlags(key, newlines)
2057         # --
2058         self.setLibAdd(key, newlines)
2059         # --
2060         if self.module in ["jobmanager", "medfile", "netgen"]:
2061             newlines.append(r'''
2062             SET(DEST bin)
2063             ''')
2064         else:
2065             newlines.append(r'''
2066             SET(DEST bin/salome)
2067             ''')
2068             pass
2069         # --
2070         if key == "bin_PROGRAMS":
2071             newlines.append(r'''
2072             IF(WINDOWS)
2073             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2074             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2075             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2076             ELSE(WINDOWS)
2077             SET(PERMS)
2078             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2079             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2080             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2081             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2082             ENDIF(WINDOWS)
2083             ''')
2084             pass
2085         # --
2086         newlines.append(r'''
2087         ENDIF(nb)
2088         ''')
2089         # --
2090         newlines.append(r'''
2091         ENDIF(test)
2092         ''')
2093         newlines.append(r'''
2094         ENDFOREACH(amname ${%s})
2095         '''%(key))
2096         # --
2097         return
2098
2099     def addInstallTarget(self, key, destination, newlines):
2100         newlines.append(r"FOREACH(f ${%s})"%(key))
2101         newlines.append(r'''
2102         SET(DEST %s)
2103         '''%(destination))
2104         newlines.append(r'''
2105         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2106         IF(test_SALOMEconfig.h.in)
2107         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2108         ELSE(test_SALOMEconfig.h.in)
2109         SET(dummy dummy-NOTFOUND)
2110         MARK_AS_ADVANCED(dummy)
2111         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2112         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2113         IF(dummy)
2114         ''')
2115         if key in ['dist_salomescript_SCRIPTS']:
2116             newlines.append(r'''
2117             SET(PERMS)
2118             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2119             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2120             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2121             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2122             ''')
2123         else:
2124             newlines.append(r'''
2125             GET_FILENAME_COMPONENT(ext ${f} EXT)
2126             IF(ext STREQUAL .py)
2127             IF(DEST STREQUAL bin/salome)
2128             SET(PERMS)
2129             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2130             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2131             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2132             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2133             ELSE(DEST STREQUAL bin/salome)
2134             INSTALL(FILES ${f} DESTINATION ${DEST})
2135             ENDIF(DEST STREQUAL bin/salome)
2136             ELSE(ext STREQUAL .py)
2137             INSTALL(FILES ${f} DESTINATION ${DEST})
2138             ENDIF(ext STREQUAL .py)
2139             ''')
2140             pass
2141         newlines.append(r'''
2142         ELSE(dummy)
2143         GET_FILENAME_COMPONENT(ext ${f} EXT)
2144         IF(ext STREQUAL .qm)
2145         STRING(REGEX REPLACE .qm .ts input ${f})
2146         ''')
2147         if self.module in ["kernel", "gui", "yacs"]:
2148             newlines.append(r'''
2149             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2150             ''')
2151         else:
2152             newlines.append(r'''
2153             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2154             ''')
2155             pass
2156         newlines.append(r'''
2157         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2158         # ADD_CUSTOM_COMMAND(
2159         # OUTPUT ${output}
2160         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2161         # MAIN_DEPENDENCY ${input}
2162         # )
2163         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2164         ENDIF(ext STREQUAL .qm)
2165         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2166         ENDIF(dummy)
2167         ENDIF(test_SALOMEconfig.h.in)
2168         ''')
2169         newlines.append(r'''
2170         GET_FILENAME_COMPONENT(ext ${f} EXT)
2171         IF(ext STREQUAL .py)
2172         INSTALL(CODE "SET(PYTHON_FILE ${f})")
2173         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2174         INSTALL(CODE "SET(DEST ${DEST})")
2175         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2176         ''')
2177         if self.module == "kernel":
2178             newlines.append('''
2179             IF(f STREQUAL SALOME_ContainerPy.py)
2180             ELSE(f STREQUAL SALOME_ContainerPy.py)
2181             IF(f STREQUAL am2cmake.py)
2182             ELSE(f STREQUAL am2cmake.py)
2183             IF(f STREQUAL copytree1.py)
2184             ELSE(f STREQUAL copytree1.py)
2185             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2186             ENDIF(f STREQUAL copytree1.py)
2187             ENDIF(f STREQUAL am2cmake.py)
2188             ENDIF(f STREQUAL SALOME_ContainerPy.py)
2189             ''')
2190         else:
2191             newlines.append('''
2192             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2193             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2194             ''')
2195             pass
2196         newlines.append(r'''
2197         ENDIF(ext STREQUAL .py)
2198         ''')
2199         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2200         return
2201
2202     def writeListsFile(self):
2203         f = open(self.listsFile, "w")
2204         f.write(self.content)
2205         f.close()
2206         return
2207
2208     pass
2209
2210 def convertAmFile(the_root, root, dirs, files, f, module):
2211     cmake = CMakeFile(the_root, root, dirs, files, f, module)
2212     cmake.writeListsFile()
2213     return
2214
2215 def usage(exit_status):
2216     from sys import exit
2217     from sys import argv
2218     print "Usage: %s --module"%(argv[0])
2219     exit(exit_status)
2220     return
2221
2222 if __name__ == "__main__":
2223     #
2224     from sys import argv
2225     if len(argv) != 2:
2226         usage(1)
2227         pass
2228     #
2229     module = argv[1]
2230     if module.find('--') != 0:
2231         usage(1)
2232         pass
2233     module = module[2:]
2234     if len(module) == 0:
2235         usage(1)
2236         pass
2237     #
2238     from os import getcwd
2239     the_root = getcwd()
2240     #
2241     nok = 0
2242     #
2243     from os import walk
2244     for root, dirs, files in walk(the_root):
2245         # --
2246         # E.A. : Remove 'CVS' in dirs
2247         # E.A. : It allows to not recurse in CVS dirs
2248         # E.A. : See os module python documentation
2249         # --
2250         try:
2251             dirs.remove('CVS')
2252         except ValueError:
2253             pass
2254         # --
2255         if "Makefile.am.cmake" in files:
2256             if "Makefile.am" in files:
2257                 files.remove("Makefile.am")
2258                 pass
2259             pass
2260         # --
2261         from sys import stdout
2262         for f in files:
2263             if f in ["Makefile.am", "Makefile.am.cmake"]:
2264                 convertAmFile(the_root, root, dirs, files, f, module)
2265                 nok += 1
2266                 pass
2267             pass
2268         pass
2269     #
2270     if nok:
2271         if nok == 1:
2272             msg = "%s file has been converted to cmake"%(nok)
2273         else:
2274             msg = "%s files have been converted to cmake"%(nok)
2275             pass
2276         stdout.write(msg)
2277         stdout.write("\n")
2278         stdout.flush()
2279         pass
2280     pass