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', 'yacs']:
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             if mod in ['yacs']:
1151                 self.files.append("sources/header.html.in")
1152             else:
1153                 self.files.append("static/header.html.in")
1154             if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1155               self.files.append("static/header_py.html.in")
1156
1157         if self.module == "yacs":
1158             key = "salomegui"
1159             if self.root[-len(key):] == key:
1160                 self.files.append("resources/YACSCatalog.xml.in")
1161                 self.files.append("resources/SalomeApp.xml.in")
1162                 pass
1163             pass
1164
1165         if self.module == "jobmanager":
1166             key = "salomegui"
1167             if self.root[-len(key):] == key:
1168                 self.files.append("resources/SalomeApp.xml.in")
1169                 pass
1170             pass
1171         for f in self.files:
1172             if f[-3:] == ".in":
1173                 if f == "sstream.in":
1174                     continue
1175                 if f in ["runContainer.in", "stopContainer.in"]:
1176                     if self.module == "med":
1177                         if self.root[-3:] == "csh":
1178                             continue
1179                         pass
1180                     pass
1181                 if f == "SALOMEconfig.ref.in":
1182                     out = "SALOMEconfig.h"
1183                 else:
1184                     out = f[:-3]
1185                     pass
1186                 newlines.append(r'''
1187                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1188                 '''%(f))
1189                 newlines.append(r'''
1190                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1191                 '''%(out))
1192                 newlines.append(r'''
1193                 MESSAGE(STATUS "Creation of ${output}")
1194                 CONFIGURE_FILE(${input} ${output})
1195                 ''')
1196                 pass
1197             pass
1198
1199         # --
1200         # add commands for generating of user's documentation
1201         # --
1202         doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1203         doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1204         doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1205         head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1206         if mod == 'kernel':
1207             prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1208         else:
1209             prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1210         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1211             if mod == 'med':
1212                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1213                 input = "Doxyfile_med_user"
1214             else:
1215                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1216                 input = ""
1217             newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1218             COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1219             VERBATIM
1220             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1221             )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1222         from os import path
1223         if mod in ['geom', 'smesh', 'visu', 'netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin','ghs3dprlplugin','pyhello'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc')  or  mod in ['pyhello'] and operator.contains(self.root, 'doc'):
1224             ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1225             if mod in ['geom']:
1226                 if mod == 'geom':
1227                     tmp = 'geomBuilder'
1228                     input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1229                 newlines.append(r"""
1230                 IF(WINDOWS)
1231                   STRING(REPLACE "/" "\\" f "%s")
1232                 ELSE(WINDOWS)
1233                   SET(f "%s")
1234                 ENDIF(WINDOWS)
1235                 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1236                 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1237                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1238                 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1239                 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''')"
1240                 VERBATIM
1241                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1242                 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, upmod, tmp, input, tmp, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1243                 newlines.append(r"""ADD_DEPENDENCIES(usr_docs html_docs)""")
1244             else:
1245                 config_f = ""
1246                 extra_doc_dir = ""
1247                 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1248                     config_f = "${DOXYGEN_EXECUTABLE} doxyfile_py"
1249                     extra_doc_dir = "%spy_doc"%(mod)
1250                 elif mod not in ['pyhello']:
1251                     config_f = "${DOXYGEN_EXECUTABLE} doxyfile_idl"
1252                     if mod == 'visu':
1253                         extra_doc_dir = "%sgen_doc"%(mod)
1254                 inst_head_command = ""
1255                 if extra_doc_dir != "":
1256                     inst_head_command = "; shutil.copy(r'''%s''', r'''${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s/%s''')"%(head_source, upmod, extra_doc_dir)
1257                 newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs %s
1258                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1259                 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"
1260                 VERBATIM
1261                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1262                 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination, inst_head_command))
1263         elif mod in ['yacs', 'jobmanager'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1264             from sys import platform
1265             params = '';
1266             if platform == "win32":
1267                 params = '-Q';
1268             newlines.append(r"""
1269             ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1270             COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1271             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1272         elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1273             from sys import platform
1274             params = ""
1275             ext = ""
1276             prf = ""
1277             if platform == "win32":
1278                 params = '-Q';
1279                 ext = "bat"
1280                 prf = "call"
1281                 cmd = "STRING(REPLACE \"/\" \"\\\\\" SCR"
1282             else:
1283                 ext = "sh"
1284                 prf = ". "
1285                 cmd = "SET(SCR"
1286             doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1287             scr = self.writeEnvScript(upmod)
1288             newlines.append(r"""
1289             %s "%s")
1290             FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1291             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
1292             COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1293             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(cmd, scr, ext, prf, ext, params, doc_gui_destination, doc_gui_destination))
1294
1295
1296
1297
1298   # --
1299   # add commands for generating of developer's documentation
1300   # --
1301
1302         upmod = self.module.upper()
1303         if ( mod in ['kernel', 'gui', 'med', 'smesh', 'visu', 'blsurfplugin'] and self.root[-len('tui'):] == 'tui' ) or ( mod in ['yacs'] and self.root[-len('doc'):] == 'doc' ):
1304             if mod == 'kernel':
1305                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1306             COMMAND ${DOXYGEN_EXECUTABLE}
1307             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')"  """
1308                 tmp1=""
1309             else:
1310                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1311                 if mod == 'visu':
1312                     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)
1313                 elif mod == 'smesh':
1314                     tmp1= """\n            COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s''')" """%(doc_tui_destination)
1315                 else:
1316                     tmp1=""
1317             if mod == 'yacs':
1318                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/htmldev"
1319             else:
1320                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1321             inst_head_command=""
1322             inst_head_command = "; shutil.copy(r'''%s''', r'''%s''')"%(head_source, doc_tui_destination)
1323             newlines.append(tmp + """
1324             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 + """
1325             VERBATIM
1326             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1327             )""")
1328         if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1329             tmp = 'geomBuilder'
1330             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1331             newlines.append(r"""
1332             IF(WINDOWS)
1333               STRING(REPLACE "/" "\\" f "%s")
1334             ELSE(WINDOWS)
1335               SET(f "%s")
1336             ENDIF(WINDOWS)
1337             ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1338             COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1339             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/%s.py''')"
1340             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''')"
1341             VERBATIM
1342             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1343             )"""%(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))
1344
1345         # --
1346         # convert the SUBDIRS in cmake grammar
1347         # --
1348         if 1: # self.__thedict__.has_key("SUBDIRS"):
1349             newlines.append(r'''
1350             FOREACH(dir ${SUBDIRS})
1351             IF(NOT dir STREQUAL .)
1352             ADD_SUBDIRECTORY(${dir})
1353             ENDIF(NOT dir STREQUAL .)
1354             ENDFOREACH(dir ${SUBDIRS})
1355             ''')
1356             pass
1357
1358         # --
1359         # --
1360         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1361             if self.__thedict__.has_key(key):
1362                 self.addLibTarget(key, newlines)
1363                 pass
1364             pass
1365
1366         # --
1367         # --
1368         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1369             if self.__thedict__.has_key(key):
1370                 self.addBinTarget(key, newlines)
1371                 pass
1372             pass
1373
1374         # --
1375         # --
1376         if self.__thedict__.has_key("BASEIDL_FILES"):
1377             if not self.__thedict__.has_key("IDL_FILES"):
1378                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1379                 newlines.append('''
1380                 SET(IDL_FILES ${BASEIDL_FILES})
1381                 ''')
1382                 pass
1383             pass
1384
1385         # --
1386         # --
1387
1388         key = "IDL_FILES"
1389         if self.__thedict__.has_key(key):
1390             if self.module == "kernel":
1391                 newlines.append('''
1392                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1393                 ''')
1394                 pass
1395             newlines.append('''
1396             FOREACH(input ${IDL_FILES})
1397             STRING(REGEX REPLACE ".idl" "" base ${input})
1398             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1399             SET(outputs ${src})
1400             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1401             SET(outputs ${outputs} ${dynsrc})
1402             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1403             SET(outputs ${outputs} ${inc})
1404             IF(input STREQUAL Calcium_Ports.idl)
1405             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1406             ELSE(input STREQUAL Calcium_Ports.idl)
1407             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1408             ENDIF(input STREQUAL Calcium_Ports.idl)
1409             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1410             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1411             IF(NOT ISBCXX)
1412             SET(flags -bcxx ${flags})
1413             ENDIF(NOT ISBCXX)
1414             ADD_CUSTOM_COMMAND(
1415             OUTPUT ${outputs}
1416             COMMAND ${OMNIORB_IDL} ${flags} ${input}
1417             MAIN_DEPENDENCY ${input}
1418             )
1419             ''')
1420             newlines.append('''
1421             install(FILES ${input} DESTINATION idl/salome)
1422             ''')
1423             if self.module not in ["pyhello"]:
1424                 newlines.append('''
1425                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1426                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1427                 ''')
1428                 pass
1429             newlines.append('''
1430             INSTALL(CODE "SET(IDL_FILE ${input})")
1431             INSTALL(CODE "SET(DIR ${salomepythondir})")
1432             IF(WINDOWS)
1433             INSTALL(CODE "SET(DIR bin/salome)")
1434             ENDIF(WINDOWS)
1435             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1436             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1437             # --
1438             SET(flags)
1439             FOREACH(f ${IDLPYFLAGS})
1440             SET(flags "${flags} ${f}")
1441             ENDFOREACH(f ${IDLPYFLAGS})
1442             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1443             IF(NOT ISBPYTHON)
1444             SET(flags "-bpython ${flags}")
1445             ENDIF(NOT ISBPYTHON)
1446             SET(IDLPYFLAGS ${flags})
1447             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1448             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1449             # --
1450             ''')
1451             if self.module == "kernel":
1452                 newlines.append('''
1453                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1454                 ''')
1455             else:
1456                 newlines.append('''
1457                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1458                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_python_from_idl.cmake)
1459                 ''')
1460                 pass
1461             newlines.append('''
1462             ENDFOREACH(input ${IDL_FILES})
1463             ''')
1464             pass
1465
1466         # --
1467         # --
1468         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1469             if self.__thedict__.has_key(key):
1470                 newlines.append('''
1471                 SET(SWIG_SOURCES ${%s})
1472                 '''%(key))
1473                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1474                 pass
1475             pass
1476
1477         # --
1478         # --
1479         if self.__thedict__.has_key("SWIG_SOURCES"):
1480             newlines.append('''
1481             IF(SWIG_SOURCES MATCHES ";")
1482             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1483             ELSE(SWIG_SOURCES MATCHES ";")
1484             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1485             ENDIF(SWIG_SOURCES MATCHES ";")
1486             SET(flags)
1487             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1488             SET(test ON)
1489             IF(flags)
1490             LIST(FIND flags ${f} index)
1491             IF(NOT index EQUAL -1)
1492             SET(test OFF)
1493             ENDIF(NOT index EQUAL -1)
1494             ENDIF(flags)
1495             IF(test)
1496             SET(flags ${flags} ${f})
1497             ENDIF(test)
1498             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1499             ADD_CUSTOM_COMMAND(
1500             OUTPUT ${build_srcs}
1501             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1502             MAIN_DEPENDENCY ${SWIG_SOURCES}
1503             )
1504             ''')
1505             pass
1506
1507         # --
1508         # --
1509         if self.__thedict__.has_key("BUILT_SOURCES"):
1510             newlines.append('''
1511             FOREACH(f ${BUILT_SOURCES})
1512             IF(f MATCHES "WRAP.cxx$")
1513             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1514             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1515             ADD_CUSTOM_COMMAND(
1516             OUTPUT ${f} # ${inc}
1517             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1518             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1519             )
1520             ENDIF(f MATCHES "WRAP.cxx$")
1521             ENDFOREACH(f ${BUILT_SOURCES})
1522             ''')
1523             pass
1524
1525         # --
1526         # --
1527         key = "MOC_FILES"
1528         if self.__thedict__.has_key(key):
1529             newlines.append('''
1530             FOREACH(output ${MOC_FILES})
1531             ''')
1532             if self.module in ["jobmanager", "yacs"]:
1533                 newlines.append('''
1534                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1535                 ''')
1536             else:
1537                 newlines.append('''
1538                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1539                 ''')
1540                 pass
1541             newlines.append('''
1542             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1543             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1544             ADD_CUSTOM_COMMAND(
1545             OUTPUT ${output}
1546             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1547             MAIN_DEPENDENCY ${input}
1548             )
1549             ENDFOREACH(output ${MOC_FILES})
1550             ''')
1551             pass
1552
1553         # --
1554         # --
1555         key = "MOC_FILES_HXX"
1556         if self.__thedict__.has_key(key):
1557             newlines.append('''
1558             FOREACH(output ${MOC_FILES_HXX})
1559             ''')
1560             newlines.append('''
1561             STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1562             ''')
1563             newlines.append('''
1564             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1565             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1566             ADD_CUSTOM_COMMAND(
1567             OUTPUT ${output}
1568             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1569             MAIN_DEPENDENCY ${input}
1570             )
1571             ENDFOREACH(output ${MOC_FILES_HXX})
1572             ''')
1573             pass
1574
1575         # --
1576         # --
1577         key = "UIC_FILES"
1578         if self.__thedict__.has_key(key):
1579             newlines.append('''
1580             FOREACH(output ${UIC_FILES})
1581             STRING(REPLACE "ui_" "" input ${output})
1582             STRING(REPLACE ".h" ".ui" input ${input})
1583             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1584             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1585             ADD_CUSTOM_COMMAND(
1586             OUTPUT ${output}
1587             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1588             MAIN_DEPENDENCY ${input}
1589             )
1590             ENDFOREACH(output ${UIC_FILES})
1591             ''')
1592             pass
1593
1594         # --
1595         # --
1596         key = "PYUIC_FILES"
1597         if self.__thedict__.has_key(key):
1598             newlines.append('''
1599             FOREACH(output ${PYUIC_FILES})
1600             STRING(REPLACE "_ui.py" ".ui" input ${output})
1601             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1602             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1603             ADD_CUSTOM_COMMAND(
1604             OUTPUT ${output}
1605             COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1606             MAIN_DEPENDENCY ${input}
1607             )
1608             ENDFOREACH(output ${PYUIC_FILES})
1609             ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1610             ''')
1611             pass
1612
1613         # --
1614         # --
1615         key = "QRC_FILES"
1616         if self.__thedict__.has_key(key):
1617             newlines.append('''
1618             FOREACH(output ${QRC_FILES})
1619             STRING(REGEX REPLACE "qrc_" "" input ${output})
1620             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1621             STRING(REGEX REPLACE ".qrc" "" name ${input})
1622             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1623             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1624             ADD_CUSTOM_COMMAND(
1625             OUTPUT ${output}
1626             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1627             MAIN_DEPENDENCY ${input}
1628             )
1629             ENDFOREACH(output ${QRC_FILES})
1630             ''')
1631             pass
1632
1633         # --
1634         # --
1635         key = "SIP_FILES"
1636         if self.__thedict__.has_key(key):
1637             newlines.append('''
1638             FOREACH(input ${SIP_FILES})
1639             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1640             SET(output)
1641             FOREACH(out ${SIP_SRC})
1642             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1643             ENDFOREACH(out ${SIP_SRC})
1644             ADD_CUSTOM_COMMAND(
1645             OUTPUT ${output}
1646             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1647             MAIN_DEPENDENCY ${input}
1648             )
1649             ENDFOREACH(input ${SIP_FILES})
1650             ''')
1651             pass
1652
1653         # --
1654         # For GUI/tools/dlgfactory
1655         # --
1656         key = "UIC_FILES_QDIALOG"
1657         if self.__thedict__.has_key(key):
1658             newlines.append('''
1659             FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1660             STRING(REPLACE "ui_" "" input ${output})
1661             STRING(REPLACE ".hxx" ".ui" input ${input})
1662             SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1663             IF (NOT EXISTS ${input_path})
1664               SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1665             ENDIF (NOT EXISTS ${input_path})
1666             ADD_CUSTOM_COMMAND(
1667             OUTPUT ${output}
1668             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1669             MAIN_DEPENDENCY ${input}
1670             )
1671             ENDFOREACH(output ${UIC_FILES})
1672
1673             FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1674             STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1675             SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1676             IF (NOT EXISTS ${input_path})
1677               SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1678             ENDIF (NOT EXISTS ${input_path})
1679             ADD_CUSTOM_COMMAND(
1680             OUTPUT ${output}
1681             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1682             MAIN_DEPENDENCY ${input}
1683             )
1684             ENDFOREACH(output ${MOC_FILES})
1685
1686             ADD_CUSTOM_COMMAND(
1687             OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1688             COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1689             DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1690             )
1691
1692             ADD_CUSTOM_COMMAND(
1693             OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1694             COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1695             DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1696             )
1697             ''')
1698             pass
1699
1700         # --
1701         # For make check
1702         # --
1703         for key in ["TESTS"]:
1704             if self.__thedict__.has_key(key):
1705                 newlines.append('''
1706                 SET(UNIT_TEST_PROG ${%s})
1707                 '''%(key))
1708                 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1709                 pass
1710             pass
1711         key = "UNIT_TEST_PROG"
1712         if self.__thedict__.has_key(key):
1713             newlines.append('''
1714             FOREACH(input ${UNIT_TEST_PROG})
1715             GET_FILENAME_COMPONENT(ext ${input} EXT)
1716             IF(ext STREQUAL .py)
1717             SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1718             ELSE(ext STREQUAL .py)
1719             IF(WINDOWS)
1720             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1721             ELSE()
1722             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1723             ENDIF()
1724             ENDIF(ext STREQUAL .py)
1725             ADD_TEST(${input} ${test})
1726             SET(fail_regex "KO")
1727             SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1728             # IF(NOT WINDOWS)
1729             # ADD_TEST(${input}_valgrind valgrind ${test})
1730             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1731             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1732             # ENDIF()
1733             ENDFOREACH(input ${UNIT_TEST_PROG})
1734             ''')
1735             pass
1736
1737         # --
1738         # Treat the install targets
1739         # --
1740         resdir = self.module
1741         if resdir == "hxx2salome":
1742             resdir = self.hxxmodule
1743             pass
1744         d = {
1745             "salomeadmux_DATA"                 :  "salome_adm/unix",
1746             "dist_salomeadmux_DATA"            :  "salome_adm/unix",
1747             "dist_salome_cmake_DATA"           :  "salome_adm/cmake_files",
1748             "dist_salomem4_DATA"               :  "salome_adm/unix/config_files",
1749             "dist_salome4depr_DATA"            :  "salome_adm/unix/config_files/DEPRECATED",
1750             "dist_admlocalm4_DATA"             :  "adm_local/unix/config_files",
1751             "dist_admlocal_cmake_DATA"         :  "adm_local/cmake_files",
1752             "salomeinclude_DATA"               :  "include/salome",
1753             "salomeinclude_HEADERS"            :  "include/salome",
1754             "nodist_salomeinclude_HEADERS"     :  "include/salome",
1755             "dist_salomeres_DATA"              :  "share/salome/resources/%s"%(resdir),
1756             "nodist_salomeres_DATA"            :  "share/salome/resources/%s"%(resdir),
1757             "nodist_salomeres_SCRIPTS"         :  "share/salome/resources/%s"%(resdir),
1758             "dist_salomescript_SCRIPTS"        :  "bin/salome",
1759             "dist_salomescript_DATA"           :  "bin/salome",
1760             "dist_salomescript_PYTHON"         :  "bin/salome",
1761             "dist_appliskel_SCRIPTS"           :  "bin/salome/appliskel",
1762             "dist_appliskel_PYTHON"            :  "bin/salome/appliskel",
1763             "nodist_salomescript_DATA"         :  "bin/salome",
1764             "salomepython_PYTHON"              :  "${salomepythondir}",
1765             "nodist_salomepython_PYTHON"       :  "${salomepythondir}",
1766             "dist_salomepython_DATA"           :  "${salomepythondir}",
1767             "sharedpkgpython_PYTHON"           :  "${salomepythondir}/shared_modules",
1768             "salomepypkg_PYTHON"               :  "${salomepypkgdir}",
1769             "mypkgpython_PYTHON"               :  "${mypkgpythondir}",
1770             "stdpkgpython_PYTHON"              :  "${stdpkgpythondir}",
1771             "nodist_mypkgpython_PYTHON"        :  "${mypkgpythondir}",
1772             }
1773         if self.module == "jobmanager":
1774             d["bin_SCRIPTS"] = "bin"
1775             pass
1776         if self.module == "medfile":
1777             d = {
1778                 "include_HEADERS"        :  "include",
1779                 "nodist_include_HEADERS" :  "include",
1780                 "bin_SCRIPTS"            :  "bin",
1781                 "doc_DATA"               :  "${docdir}",
1782                 }
1783             pass
1784         if self.module == "netgen":
1785             d = {
1786                 "include_HEADERS"        :  "include",
1787                 "noinst_HEADERS"         :  "share/netgen/include",
1788                 "dist_pkgdata_DATA"      :  "share/netgen",
1789                 "dist_doc_DATA"          :  "share/doc/netgen",
1790                 }
1791             pass
1792         for key, value in d.items():
1793             if self.__thedict__.has_key(key):
1794                 self.addInstallTarget(key, value, newlines)
1795                 pass
1796             pass
1797
1798         # --
1799         return
1800
1801     def setLibAdd(self, key, newlines):
1802         # --
1803         newlines.append(r'''
1804         SET(libadd)
1805         ''')
1806         # --
1807         newlines.append(r'''
1808         IF(WINDOWS)
1809         SET(targets)
1810         SET(targets ${targets} MEFISTO2D)
1811         FOREACH(target ${targets})
1812         IF(name STREQUAL ${target})
1813         SET(dir $ENV{F2CHOME})
1814         STRING(REPLACE "\\\\" "/" dir ${dir})
1815         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1816         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1817         ENDIF(name STREQUAL ${target})
1818         ENDFOREACH(target ${targets})
1819         ELSE(WINDOWS)
1820         SET(targets)
1821         SET(targets ${targets} MEFISTO2D)
1822         FOREACH(target ${targets})
1823         IF(name STREQUAL ${target})
1824         SET(libadd ${libadd} -lf2c)
1825         ENDIF(name STREQUAL ${target})
1826         ENDFOREACH(target ${targets})
1827         ENDIF(WINDOWS)
1828         ''')
1829         # --
1830         newlines.append(r'''
1831         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1832         FOREACH(lib SALOMEBasics SalomeBatch)
1833         IF(name STREQUAL lib)
1834         SET(libs ${libs} ${PTHREAD_LIBS})
1835         ENDIF(name STREQUAL lib)
1836         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1837         ''')
1838         # --
1839         newlines.append(r'''
1840         FOREACH(lib ${libs})
1841         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1842         IF(ext STREQUAL .la)
1843         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1844         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1845         ENDIF(ext STREQUAL .la)
1846         SET(vars)
1847         SET(vars ${vars} -no-undefined)
1848         SET(vars ${vars} -lvtkWidgets)
1849         IF(WINDOWS)
1850         SET(vars ${vars} -module)
1851         SET(vars ${vars} -Wl,-E)
1852         SET(vars ${vars} -Xlinker)
1853         SET(vars ${vars} -export-dynamic)
1854         SET(vars ${vars} -lm)
1855         SET(vars ${vars} -lboost_thread)
1856         SET(vars ${vars} -lboost_signals)
1857         SET(vars ${vars} -pthread -lpthread -ldl)
1858         ENDIF(WINDOWS)
1859         FOREACH(v ${vars})
1860         IF(lib STREQUAL v)
1861         SET(lib)
1862         ENDIF(lib STREQUAL v)
1863         ENDFOREACH(v ${vars})
1864         SET(test OFF)
1865         IF(lib)
1866         STRING(REGEX MATCH "^-lQt" test ${lib})
1867         ENDIF(lib)
1868         IF(NOT test)
1869         SET(libadd ${libadd} ${lib})
1870         ENDIF(NOT test)
1871         ENDFOREACH(lib ${libs})
1872         TARGET_LINK_LIBRARIES(${name} ${libadd})
1873         ''')
1874         # --
1875         newlines.append(r'''
1876         IF(WINDOWS)
1877         SET(targets)
1878         SET(targets ${targets} MEFISTO2D)
1879         FOREACH(target ${targets})
1880         IF(name STREQUAL ${target})
1881         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1882         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1883         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1884         ENDIF(name STREQUAL ${target})
1885         ENDFOREACH(target ${targets})
1886         ENDIF(WINDOWS)
1887         ''')
1888         # --
1889         return
1890
1891     def setCompilationFlags(self, key, newlines):
1892         newlines.append(r'''
1893         SET(var)
1894         IF(WINDOWS)
1895         SET(targets)
1896         SET(targets ${targets} SalomeIDLKernel)
1897         SET(targets ${targets} SalomeDS)
1898         SET(targets ${targets} SALOMEDSTest)
1899         SET(targets ${targets} SALOMEDS_Client_exe)
1900         SET(targets ${targets} SalomeIDLGEOM)
1901         SET(targets ${targets} GEOMEngine)
1902         SET(targets ${targets} MEDEngine)
1903         SET(targets ${targets} SMESHEngine)
1904         SET(targets ${targets} SMESH)
1905         SET(targets ${targets} SalomeIDLSPADDER)
1906         SET(targets ${targets} MeshJobManagerEngine)
1907         SET(targets ${targets} StdMeshersEngine)
1908         SET(targets ${targets} VISUEngineImpl)
1909         FOREACH(target ${targets})
1910         IF(name STREQUAL ${target})
1911         SET(var ${var} -DNOGDI)
1912         ENDIF(name STREQUAL ${target})
1913         ENDFOREACH(target ${targets})
1914         ENDIF(WINDOWS)
1915         ''')
1916         # --
1917         if self.module in ["medfile", "yacs"]:
1918             newlines.append(r'''
1919             IF(WINDOWS)
1920             SET(var ${var} -DNOGDI)
1921             ENDIF(WINDOWS)
1922             ''')
1923             pass
1924         # --
1925         newlines.append(r'''
1926         IF(WINDOWS)
1927         SET(targets)
1928         SET(targets ${targets} MEFISTO2D)
1929         FOREACH(target ${targets})
1930         IF(name STREQUAL ${target})
1931         SET(dir $ENV{F2CHOME})
1932         STRING(REPLACE "\\\\" "/" dir ${dir})
1933         SET(var ${var} -I${dir})
1934         SET(var ${var} -DF2C_BUILD)
1935         ENDIF(name STREQUAL ${target})
1936         ENDFOREACH(target ${targets})
1937         ENDIF(WINDOWS)
1938         ''')
1939         # --
1940         if self.module in ["geom", "med", "hexoticplugin", "blsurfplugin"]:
1941             newlines.append(r'''
1942             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1943             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1944             ''')
1945             pass
1946         newlines.append(r'''
1947         SET(var ${var} ${AM_CPPFLAGS})
1948         SET(var ${var} ${AM_CXXFLAGS})
1949         ''')
1950         # --
1951         newlines.append(r'''
1952         IF(type STREQUAL STATIC)
1953         SET(var ${var} -fPIC)
1954         ENDIF(type STREQUAL STATIC)
1955         ''')
1956         # --
1957         if self.module == "yacs":
1958             newlines.append(r'''
1959             SET(var ${var} -DYACS_PTHREAD)
1960             SET(var ${var} -DCMAKE_BUILD)
1961             SET(var ${var} -DSALOME_KERNEL)
1962             SET(var ${var} -DDSC_PORTS)
1963             SET(var ${var} -DOMNIORB)
1964             ''')
1965             pass
1966         newlines.append(r'''
1967   SET(var ${var} ${PLATFORM_CPPFLAGS})
1968   SET(var ${var} ${PTHREAD_CFLAGS})
1969   SET(var ${var} ${${amname}_CPPFLAGS})
1970   SET(var ${var} ${${amname}_CXXFLAGS})
1971   SET(var ${var} ${${amname}_CFLAGS})
1972         SET(vars)
1973         IF(WINDOWS)
1974         SET(vars ${vars} -include SALOMEconfig.h)
1975         SET(vars ${vars} -ftemplate-depth-32)
1976         SET(vars ${vars} -fPIC)
1977         SET(vars ${vars} -g)
1978         IF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")          # if platform is Windows 64 bit
1979         IF(name STREQUAL _pilot)
1980         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")    # to avoid error C1128
1981         ENDIF(name STREQUAL _pilot)
1982         ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
1983         ENDIF(WINDOWS)
1984         SET(flags)
1985         FOREACH(f ${var})
1986         FOREACH(v ${vars})
1987         IF(f STREQUAL v)
1988         SET(f)
1989         ENDIF(f STREQUAL v)
1990         ENDFOREACH(v ${vars})
1991         IF(f)
1992         string(REGEX MATCH "^-I" test_include ${f})
1993         if(test_include)
1994         string(REGEX REPLACE "^-I" "" include_dir ${f})
1995         if(include_dir)
1996         if(include_dir STREQUAL /usr/include)
1997         else(include_dir STREQUAL /usr/include)
1998         string(REGEX MATCH "^\\." test_dot ${include_dir})
1999         if(test_dot)
2000         set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
2001         endif(test_dot)
2002         include_directories(${include_dir})
2003         endif(include_dir STREQUAL /usr/include)
2004         endif(include_dir)
2005         else(test_include)
2006         SET(flags "${flags} ${f}")
2007         endif(test_include)
2008         ENDIF(f)
2009         ENDFOREACH(f ${var})
2010         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2011         ''')
2012         return
2013
2014     def addLibTarget(self, key, newlines):
2015         newlines.append(r'''
2016         FOREACH(amname ${%s})
2017         '''%(key))
2018         # --
2019         # Replace .la by _la ...
2020         # --
2021         newlines.append(r'''
2022         STRING(REPLACE .la _la amname ${amname})
2023         ''')
2024         # --
2025         # Remove the _la for the cmake name
2026         # --
2027         newlines.append(r'''
2028         STRING(LENGTH ${amname} len)
2029         MATH(EXPR newlen "${len}-3")
2030         STRING(SUBSTRING ${amname} 0 ${newlen} name)
2031         ''')
2032         # --
2033         # Does the target begins with lib ??
2034         # If yes, remove lib at beginning for cmake name
2035         # --
2036         newlines.append(r'''
2037         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2038         IF(BEGIN_WITH_lib)
2039         STRING(LENGTH ${name} len)
2040         MATH(EXPR newlen "${len}-3")
2041         STRING(SUBSTRING ${name} 3 ${newlen} name)
2042         ENDIF(BEGIN_WITH_lib)
2043         ''')
2044         # --
2045         # Does the target is an idl library
2046         # --
2047         newlines.append(r'''
2048         STRING(REGEX MATCH "IDL" ISIDL ${name})
2049         ''')
2050         # --
2051         # Set the type of the library
2052         # --
2053         newlines.append(r'''
2054         IF(ISIDL)
2055         IF(WINDOWS)
2056         SET(type STATIC)
2057         ELSE(WINDOWS)
2058         SET(type SHARED)
2059         ENDIF(WINDOWS)
2060         ELSE(ISIDL)
2061         SET(type SHARED)
2062         ENDIF(ISIDL)
2063         ''')
2064         if key == "noinst_LTLIBRARIES":
2065             newlines.append(r'''
2066             IF(WINDOWS)
2067             SET(type STATIC)
2068             ELSE(WINDOWS)
2069             SET(type STATIC)
2070             ENDIF(WINDOWS)
2071             ''')
2072             pass
2073         # --
2074         # Set sources for the library
2075         # --
2076         newlines.append(r'''
2077         SET(srcs)
2078         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2079         GET_FILENAME_COMPONENT(ext ${src} EXT)
2080         IF(ext STREQUAL .f)
2081         IF(src STREQUAL trte.f)
2082         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2083         STRING(REPLACE ".f" ".c" src ${src})
2084         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2085         SET(output ${src})
2086         SET(cmd f2c)
2087         IF(NOT WINDOWS)
2088         IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2089         SET(cmd valgrind f2c)  # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2090         ENDIF()
2091         ENDIF(NOT WINDOWS)
2092         ADD_CUSTOM_COMMAND(
2093         OUTPUT ${output}
2094         COMMAND ${cmd} ${input}
2095         MAIN_DEPENDENCY ${input}
2096         )
2097         ELSE(src STREQUAL trte.f)
2098         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2099         STRING(REPLACE ".f" ".o" src ${src})
2100         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2101         SET(output ${src})
2102         IF(WINDOWS)
2103         SET(F77 g77)
2104         ELSE(WINDOWS)
2105         SET(F77 gfortran)
2106         ENDIF(WINDOWS)
2107         ADD_CUSTOM_COMMAND(
2108         OUTPUT ${output}
2109         COMMAND ${F77} -c -o ${output} ${input}
2110         MAIN_DEPENDENCY ${input}
2111         )
2112         ENDIF(src STREQUAL trte.f)
2113         ENDIF(ext STREQUAL .f)
2114         SET(srcs ${srcs} ${src})
2115         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2116         ''')
2117         newlines.append(r'''
2118         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2119         FOREACH(f ${l})
2120         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2121         SET(srcs ${srcs} ${src})
2122         ENDFOREACH(f ${l})
2123         ''')
2124         newlines.append(r'''
2125         SET(build_srcs)
2126         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2127         FOREACH(f ${l})
2128         GET_FILENAME_COMPONENT(ext ${f} EXT)
2129         IF(ext STREQUAL .py)
2130         SET(fff)
2131         ELSE(ext STREQUAL .py)
2132         SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2133         ENDIF(ext STREQUAL .py)
2134         IF(fff)
2135         IF(build_srcs)
2136         LIST(FIND build_srcs ${fff} index)
2137         IF(NOT index EQUAL -1)
2138         SET(fff)
2139         ENDIF(NOT index EQUAL -1)
2140         ENDIF(build_srcs)
2141         ENDIF(fff)
2142         IF(fff)
2143         SET(build_srcs ${build_srcs} ${fff})
2144         ENDIF(fff)
2145         ENDFOREACH(f ${l})
2146         ''')
2147         # --
2148         # Add the library to cmake
2149         # --
2150         newlines.append(r'''
2151         ADD_LIBRARY(${name} ${type} ${srcs})
2152         ''')
2153         # --
2154         # The compilation flags
2155         # --
2156         self.setCompilationFlags(key, newlines)
2157         # --
2158         newlines.append(r'''
2159         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2160         ''')
2161         # --
2162         self.setLibAdd(key, newlines)
2163         # --
2164         if 1: # key != "noinst_LTLIBRARIES":
2165             newlines.append(r'''
2166             SET(key %s)
2167             '''%(key))
2168             newlines.append(r'''
2169             SET(test ON)
2170             IF(${key} STREQUAL noinst_LTLIBRARIES)
2171             SET(test OFF)
2172             ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2173             ''')
2174             if self.module == "netgen" :
2175                 newlines.append(r'''
2176                 IF(${key} STREQUAL noinst_LTLIBRARIES)
2177                 IF(WINDOWS)
2178                 SET(test ON)
2179                 ENDIF(WINDOWS)
2180                 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2181                 ''')
2182                 pass
2183             newlines.append(r'''
2184             IF(test)
2185             ''')
2186             if self.module in ["medfile", "netgen"]:
2187                 newlines.append(r'''
2188                 SET(DEST lib)
2189                 ''')
2190             elif key == "libparaview_LTLIBRARIES":
2191                 newlines.append(r'''
2192                 SET(DEST lib/paraview)
2193                 ''')
2194             else:
2195                 newlines.append(r'''
2196                 SET(DEST lib/salome)
2197                 ''')
2198                 pass
2199             newlines.append(r'''
2200             IF(BEGIN_WITH_lib)
2201             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2202             ''')
2203             if self.module == "gui":
2204                 newlines.append(r'''
2205                 FOREACH(lib SalomePyQt)
2206                 IF(name STREQUAL lib)
2207                 IF(WINDOWS)
2208                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2209                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2210                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2211                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2212                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2213                 ELSE(WINDOWS)
2214                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2215                 ENDIF(WINDOWS)
2216                 ENDIF(name STREQUAL lib)
2217                 ENDFOREACH(lib SalomePyQt)
2218                 FOREACH(lib SalomePy)
2219                 IF(name STREQUAL lib)
2220                 IF(WINDOWS)
2221                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2222                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2223                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2224                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2225                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2226                 ENDIF(WINDOWS)
2227                 ENDIF(name STREQUAL lib)
2228                 ENDFOREACH(lib SalomePy)
2229                 ''')
2230                 pass
2231             if self.module == "geom":
2232                 newlines.append(r'''
2233                 IF(WINDOWS)
2234                 STRING(REGEX MATCH "Export" ISExport ${name})
2235                 IF(ISExport)
2236                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2237                 ENDIF(ISExport)
2238                 STRING(REGEX MATCH "Import" ISImport ${name})
2239                 IF(ISImport)
2240                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2241                 ENDIF(ISImport)
2242                 ENDIF(WINDOWS)
2243                 ''')
2244                 pass
2245             newlines.append(r'''
2246             ELSE(BEGIN_WITH_lib)
2247             ''')
2248             newlines.append(r'''
2249             IF(WINDOWS)
2250             INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2251             IF(CMAKE_BUILD_TYPE STREQUAL Release)
2252             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2253             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2254             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2255             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2256             ELSE(WINDOWS)
2257             GET_TARGET_PROPERTY(version ${name} VERSION)
2258             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2259             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2260             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2261             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2262             ENDIF(WINDOWS)
2263             ''')
2264             newlines.append(r'''
2265             ENDIF(BEGIN_WITH_lib)
2266             ''')
2267             newlines.append(r'''
2268             ENDIF(test)
2269             ''')
2270             pass
2271         # --
2272         newlines.append(r'''
2273         ENDFOREACH(amname ${%s})
2274         '''%(key))
2275         # --
2276         return
2277
2278     def addBinTarget(self, key, newlines):
2279         # --
2280         newlines.append(r'''
2281         FOREACH(amname ${%s})
2282         '''%(key))
2283         # --
2284         newlines.append(r'''
2285         SET(test ON)
2286         ''')
2287         if key == "check_PROGRAMS":
2288             newlines.append(r'''
2289             IF(bin_PROGRAMS)
2290             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2291             IF(is_present)
2292             SET(test OFF)
2293             ENDIF(is_present)
2294             ENDIF(bin_PROGRAMS)
2295             ''')
2296             pass
2297         newlines.append(r'''
2298         IF(test)
2299         ''')
2300         # --
2301         newlines.append(r'''
2302         SET(name "${amname}_exe")
2303         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2304         SET(l ${nodist_${amname}_SOURCES})
2305         FOREACH(f ${l})
2306         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2307         SET(srcs ${srcs} ${src})
2308         ENDFOREACH(f ${l})
2309         LIST(LENGTH srcs nb)
2310         IF(nb)
2311         ADD_EXECUTABLE(${name} ${srcs})
2312         ''')
2313         # --
2314         self.setCompilationFlags(key, newlines)
2315         # --
2316         self.setLibAdd(key, newlines)
2317         # --
2318         if self.module in ["jobmanager", "medfile", "netgen"]:
2319             newlines.append(r'''
2320             SET(DEST bin)
2321             ''')
2322         else:
2323             newlines.append(r'''
2324             SET(DEST bin/salome)
2325             ''')
2326             pass
2327         # --
2328         if key == "bin_PROGRAMS":
2329             newlines.append(r'''
2330             IF(WINDOWS)
2331             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2332             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2333             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2334             ELSE(WINDOWS)
2335             SET(PERMS)
2336             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2337             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2338             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2339             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2340             ENDIF(WINDOWS)
2341             ''')
2342             pass
2343         # --
2344         newlines.append(r'''
2345         ENDIF(nb)
2346         ''')
2347         # --
2348         newlines.append(r'''
2349         ENDIF(test)
2350         ''')
2351         newlines.append(r'''
2352         ENDFOREACH(amname ${%s})
2353         '''%(key))
2354         # --
2355         return
2356
2357     def addInstallTarget(self, key, destination, newlines):
2358         newlines.append(r"FOREACH(f ${%s})"%(key))
2359         newlines.append(r'''
2360         SET(DEST %s)
2361         '''%(destination))
2362         newlines.append(r'''
2363         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2364         IF(test_SALOMEconfig.h.in)
2365         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2366         ELSE(test_SALOMEconfig.h.in)
2367         SET(dummy dummy-NOTFOUND)
2368         MARK_AS_ADVANCED(dummy)
2369         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2370         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2371         IF(dummy)
2372         ''')
2373         if key in ['dist_salomescript_SCRIPTS',
2374                    'dist_appliskel_SCRIPTS',
2375                    'dist_appliskel_PYTHON']:
2376             newlines.append(r'''
2377             SET(PERMS)
2378             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2379             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2380             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2381             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2382             ''')
2383         else:
2384             newlines.append(r'''
2385             GET_FILENAME_COMPONENT(ext ${f} EXT)
2386             IF(ext STREQUAL .py)
2387             IF(DEST STREQUAL bin/salome)
2388             SET(PERMS)
2389             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2390             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2391             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2392             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2393             ELSE(DEST STREQUAL bin/salome)
2394             INSTALL(FILES ${f} DESTINATION ${DEST})
2395             ENDIF(DEST STREQUAL bin/salome)
2396             ELSE(ext STREQUAL .py)
2397             INSTALL(FILES ${f} DESTINATION ${DEST})
2398             ENDIF(ext STREQUAL .py)
2399             ''')
2400             pass
2401         newlines.append(r'''
2402         ELSE(dummy)
2403         GET_FILENAME_COMPONENT(ext ${f} EXT)
2404         IF(ext STREQUAL .qm)
2405         STRING(REGEX REPLACE .qm .ts input ${f})
2406         ''')
2407         if self.module in ["kernel", "gui", "yacs"]:
2408             newlines.append(r'''
2409             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2410             ''')
2411         else:
2412             newlines.append(r'''
2413             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2414             ''')
2415             pass
2416         newlines.append(r'''
2417         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2418         # ADD_CUSTOM_COMMAND(
2419         # OUTPUT ${output}
2420         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2421         # MAIN_DEPENDENCY ${input}
2422         # )
2423         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2424         ENDIF(ext STREQUAL .qm)
2425         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2426         ENDIF(dummy)
2427         ENDIF(test_SALOMEconfig.h.in)
2428         ''')
2429         newlines.append(r'''
2430         GET_FILENAME_COMPONENT(ext ${f} EXT)
2431         IF(ext STREQUAL .py)
2432         INSTALL(CODE "SET(PYTHON_FILE ${f})")
2433         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2434         INSTALL(CODE "SET(DEST ${DEST})")
2435         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2436         ''')
2437         if self.module == "kernel":
2438             newlines.append('''
2439             IF(f STREQUAL SALOME_ContainerPy.py)
2440             ELSE(f STREQUAL SALOME_ContainerPy.py)
2441             IF(f STREQUAL am2cmake.py)
2442             ELSE(f STREQUAL am2cmake.py)
2443             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2444             ENDIF(f STREQUAL am2cmake.py)
2445             ENDIF(f STREQUAL SALOME_ContainerPy.py)
2446             ''')
2447         else:
2448             newlines.append('''
2449             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2450             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_and_compile_python_file.cmake)
2451             ''')
2452             pass
2453         newlines.append(r'''
2454         ENDIF(ext STREQUAL .py)
2455         ''')
2456         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2457         return
2458
2459     def writeListsFile(self):
2460         f = open(self.listsFile, "w")
2461         f.write(self.content)
2462         f.close()
2463         return
2464
2465     def writeEnvScript(self, upmod, buildmod=True):
2466         import os, sys
2467         p_version = sys.version[:3]
2468         python_path = "PYTHONPATH"
2469         root_dir    = "%s_ROOT_DIR" % upmod
2470         if sys.platform == "win32":
2471             script_line = '@SET %(var)s=%(val)s;%%%(var)s%%\n'
2472             var_line    = '%%%s%%'
2473             lib_path = "PATH"
2474             omni = "x86_win32"
2475             omni_py = "python"
2476             pass
2477         else:
2478             script_line = 'export %(var)s=%(val)s:\$%(var)s\n'
2479             var_line    = '\${%s}'
2480             lib_path = "LD_LIBRARY_PATH"
2481             omni = ""
2482             omni_py = "/".join( ["python%s"%p_version , "site-packages"] )
2483             pass
2484         #
2485         script = ""
2486         #
2487         if buildmod:
2488             script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2489             script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "bin", "salome"] ) }
2490             script += script_line % { 'var':lib_path,    'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "salome"] ) }
2491             pass
2492         else:
2493             script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2494             script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "bin", "salome"] ) }
2495             script += script_line % { 'var':lib_path,    'val':"/".join( [var_line % root_dir, "lib", "salome"] ) }
2496             pass
2497         #
2498         if upmod == "KERNEL" :
2499             script += "\n"
2500             if omni:
2501                 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2502                 script += script_line % { 'var':lib_path,    'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2503                 pass
2504             else:
2505                 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2506                 script += script_line % { 'var':lib_path,    'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2507                 pass
2508             script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni_py] ) }
2509             pass
2510         #
2511         if upmod == "GEOM" :
2512             script = self.writeEnvScript("KERNEL", False) + "\n" + script
2513             script = self.writeEnvScript("GUI",    False) + "\n" + script
2514             pass
2515         #
2516         if upmod == "SMESH" :
2517             script = self.writeEnvScript("GEOM", False) + "\n" + script
2518             pass
2519
2520         return script
2521     pass
2522
2523 def convertAmFile(the_root, root, dirs, files, f, module):
2524     cmake = CMakeFile(the_root, root, dirs, files, f, module)
2525     cmake.writeListsFile()
2526     return
2527
2528 def usage(exit_status):
2529     from sys import exit
2530     from sys import argv
2531     print "Usage: %s --module"%(argv[0])
2532     exit(exit_status)
2533     return
2534
2535 if __name__ == "__main__":
2536     #
2537     from sys import argv
2538     if len(argv) != 2:
2539         usage(1)
2540         pass
2541     #
2542     module = argv[1]
2543     if module.find('--') != 0:
2544         usage(1)
2545         pass
2546     module = module[2:]
2547     if len(module) == 0:
2548         usage(1)
2549         pass
2550     #
2551     from os import getcwd
2552     the_root = getcwd()
2553     #
2554     nok = 0
2555     #
2556     from os import getenv
2557     from os import walk
2558     for root, dirs, files in walk(the_root):
2559         # --
2560         # E.A. : Remove 'CVS' in dirs
2561         # E.A. : It allows to not recurse in CVS dirs
2562         # E.A. : See os module python documentation
2563         # --
2564         try:
2565             dirs.remove('CVS')
2566         except ValueError:
2567             pass
2568         # --
2569         if "Makefile.am.cmake" in files:
2570             if "Makefile.am" in files:
2571                 files.remove("Makefile.am")
2572                 pass
2573             pass
2574         # --
2575         for f in files:
2576             if f in ["Makefile.am", "Makefile.am.cmake"]:
2577                 convert = True # convert files by default
2578                 forced = getenv("AM2CMAKE_FORCE_GENERATION", "0")=="1" or \
2579                          getenv("AM2CMAKE_FORCE_%s_GENERATION"%module.upper(), "0")=="1"
2580                 if not forced:
2581                     # detect if conversion should be done
2582                     if "CMakeLists.txt" in files:
2583                         from os.path import join
2584                         ff = open(join(root, "CMakeLists.txt"))
2585                         content = ff.read()
2586                         ff.close()
2587                         if content.find("generated by am2cmake") == -1:
2588                             convert = False
2589                             pass
2590                         pass
2591                     pass
2592                 if convert:
2593                     convertAmFile(the_root, root, dirs, files, f, module)
2594                     nok += 1
2595                 pass
2596             pass
2597         pass
2598     #
2599     from sys import stdout
2600     if nok:
2601         if nok == 1:
2602             msg = "%s file has been converted to cmake"%(nok)
2603         else:
2604             msg = "%s files have been converted to cmake"%(nok)
2605             pass
2606         stdout.write(msg)
2607         stdout.write("\n")
2608         stdout.flush()
2609         pass
2610     pass