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