salome_adm/cmake_files/deprecated/am2cmake.py

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