salome_adm/cmake_files/deprecated/am2cmake.py

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