salome_adm/cmake_files/deprecated/am2cmake.py

   1 #  -*- coding: iso-8859-1 -*-
   2 # Copyright (C) 2007-2014  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, or (at your option) any later version.
   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/SalomeMacros.cmake)
 554                         INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
 555                         INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindKERNEL.cmake)
 556                         """)
 557                         pass
 558                     if self.module == "gui":
 559                         newlines.append("""
 560                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 561                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 562                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 563                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 564                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 565                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 566                         """)
 567                     else:
 568                         newlines.append("""
 569                         SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 570                         IF(GUI_ROOT_DIR)
 571                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindCAS.cmake)
 572                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQT4.cmake)
 573                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindOPENGL.cmake)
 574                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindVTK.cmake)
 575                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQWT.cmake)
 576                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindSIPPYQT.cmake)
 577                         INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindGUI.cmake)
 578                         ENDIF(GUI_ROOT_DIR)
 579                         """)
 580                         if self.module == "med":
 581                             #METIS must be after PARMETIS to prevent to activate METIS if PARMETIS already exists
 582                             newlines.append("""
 583                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindPARMETIS.cmake)
 584                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMETIS.cmake)
 585                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSCOTCH.cmake)
 586                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSPLITTER.cmake)
 587                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindRENUMBER.cmake)
 588                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 589                             IF(WINDOWS)
 590                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
 591                             ENDIF(WINDOWS)
 592                             """)
 593                             pass
 594                         if self.module == "smesh":
 595                             newlines.append("""
 596                             SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 597                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 598                             INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQWT.cmake)
 599                             INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 600                             INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/SalomeMacros.cmake)
 601
 602                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindSalomeMED.cmake)
 603                             INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
 604                             """)
 605                             pass
 606                         if self.module == "geom":
 607                             newlines.append("""
 608                             INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
 609                             """)
 610                             pass
 611
 612                         if self.module == "netgenplugin":
 613                             newlines.append("""
 614                             SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 615                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 616                             SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 617                             INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 618                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 619                             INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 620                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 621                             """)
 622                             pass
 623                         if self.module == "blsurfplugin":
 624                             newlines.append("""
 625                             SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 626                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 627                             SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 628                             INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 629                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 630                             INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 631                             INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCADSURF.cmake)
 632                             """)
 633                             pass
 634                         if self.module in ["ghs3dplugin", "hexoticplugin"]:
 635                             newlines.append("""
 636                             SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 637                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 638                             SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 639                             INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 640                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 641                             INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 642                             """)
 643                             pass
 644                         if self.module == "ghs3dprlplugin":
 645                             newlines.append("""
 646                             SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 647                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 648                             SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 649                             INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 650                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 651                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 652                             INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 653                             """)
 654                             pass
 655                         if self.module == "visu":
 656                             newlines.append("""
 657                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 658                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 659                             """)
 660                             pass
 661                         if self.module == "yacs":
 662                             newlines.append("""
 663                             INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 664                             INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 665                             INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
 666
 667                             SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SECURE_SCL=0)
 668                             SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SECURE_SCL_THROWS=0)
 669                             SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_HAS_ITERATOR_DEBUGGING=0) # To avoid runtime error during checking iterators
 670                             """)
 671                             pass
 672                         if self.module == "jobmanager":
 673                             newlines.append("""
 674                             INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
 675                             """)
 676                             pass
 677                         if self.module == "hxx2salome":
 678                             newlines.append("""
 679                             SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 680                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 681                             INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 682                             """)
 683                             pass
 684                         pass
 685                     pass
 686                 pass
 687             # --
 688             newlines.append("""
 689             SET(DOXYGEN_IS_OK 0)
 690             """)
 691             if self.module not in ['med']:
 692                 newlines.append("""
 693                 IF(WINDOWS)
 694                 SET(CPPUNIT_IS_OK 0)
 695                 MESSAGE(STATUS "cppunit is disabled.")
 696                 ENDIF(WINDOWS)
 697                 """)
 698                 pass
 699             # --
 700             if self.module == "kernel":
 701                 newlines.append("""
 702                 SET(WITH_LOCAL 1)
 703                 SET(WITH_BATCH 1)
 704                 SET(CALCIUM_IDL_INT_F77 long)
 705                 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 706                 SET(LONG_OR_INT int)
 707                 """)
 708             elif self.module == "gui":
 709                 newlines.append("""
 710                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 711                 SET(ENABLE_VTKVIEWER ON)
 712                 SET(ENABLE_SALOMEOBJECT ON)
 713                 SET(ENABLE_OCCVIEWER ON)
 714                 SET(ENABLE_GLVIEWER ON)
 715                 SET(ENABLE_PLOT2DVIEWER ON)
 716                 SET(ENABLE_PYCONSOLE ON)
 717                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 718                 SET(ENABLE_QXGRAPHVIEWER ON)
 719                 """)
 720                 pass
 721             elif self.module == "jobmanager":
 722                 newlines.append("""
 723                 IF(GUI_ROOT_DIR)
 724                 SET(HAS_GUI ON)
 725                 ENDIF(GUI_ROOT_DIR)
 726                 """)
 727                 pass
 728             elif self.module == "geom":
 729                 newlines.append("""
 730                 IF(GUI_ROOT_DIR)
 731                 SET(GEOM_ENABLE_GUI ON)
 732                 ENDIF(GUI_ROOT_DIR)
 733                 """)
 734                 pass
 735             elif self.module == "medfile":
 736                 newlines.append("""
 737                 SET(MED_NUM_MAJEUR 3)
 738                 SET(MED_NUM_MINEUR 0)
 739                 SET(MED_NUM_RELEASE 3)
 740                 SET(LONG_OR_INT int)
 741                 IF(NOT WINDOWS)
 742                 SET(FLIBS -lgfortranbegin -lgfortran)
 743                 ENDIF(NOT WINDOWS)
 744                 """)
 745                 pass
 746             elif self.module == "med":
 747                 newlines.append("""
 748                 IF(KERNEL_ROOT_DIR)
 749                 SET(MED_ENABLE_KERNEL ON)
 750                 IF(NOT WINDOWS)
 751                 SET(MED_ENABLE_SPLITTER ON)
 752                 ENDIF(NOT WINDOWS)
 753                 ENDIF(KERNEL_ROOT_DIR)
 754                 IF(GUI_ROOT_DIR)
 755                 SET(MED_ENABLE_GUI ON)
 756                 ENDIF(GUI_ROOT_DIR)
 757                 """)
 758                 pass
 759             elif self.module == "smesh":
 760                 newlines.append("""
 761                 IF(GUI_ROOT_DIR)
 762                 SET(SMESH_ENABLE_GUI ON)
 763                 ENDIF(GUI_ROOT_DIR)
 764                 """)
 765                 pass
 766             elif self.module == "netgen":
 767                 newlines.append("""
 768                 SET(OCCFLAGS ${CAS_CPPFLAGS})
 769                 SET(OCCLIBS ${CAS_LDPATH})
 770                 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
 771                 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
 772                 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
 773                 """)
 774                 pass
 775             elif self.module == "netgenplugin":
 776                 newlines.append("""
 777                 IF(GUI_ROOT_DIR)
 778                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 779                 ENDIF(GUI_ROOT_DIR)
 780                 """)
 781                 pass
 782             elif self.module == "blsurfplugin":
 783                 newlines.append("""
 784                 IF(GUI_ROOT_DIR)
 785                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 786                 ENDIF(GUI_ROOT_DIR)
 787                 """)
 788                 pass
 789             elif self.module == "ghs3dplugin":
 790                 newlines.append("""
 791                 IF(GUI_ROOT_DIR)
 792                 SET(GHS3DPLUGIN_ENABLE_GUI ON)
 793                 ENDIF(GUI_ROOT_DIR)
 794                 """)
 795                 pass
 796             elif self.module == "hexoticplugin":
 797                 newlines.append("""
 798                 IF(GUI_ROOT_DIR)
 799                 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
 800                 ENDIF(GUI_ROOT_DIR)
 801                 """)
 802                 pass
 803             elif self.module == "ghs3dprlplugin":
 804                 newlines.append("""
 805                 IF(GUI_ROOT_DIR)
 806                 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
 807                 ENDIF(GUI_ROOT_DIR)
 808                 """)
 809                 pass
 810             elif self.module == "yacs":
 811                 newlines.append("""
 812                 SET(SALOME_KERNEL ON)
 813                 SET(HAS_GUI ON)
 814                 SET(WITH_QT4 ON)
 815                 """)
 816                 pass
 817             # --
 818             newlines.append("""
 819             set(VERSION 7.4.0)
 820             set(SHORT_VERSION 7.4)
 821             set(XVERSION 0x070400)
 822             set(VERSION_DEV 0)
 823             """)
 824             pass
 825         # --
 826         newlines.append("""
 827         SET(VERSION_INFO 0.0.0)
 828         SET(SOVERSION_INFO 0)
 829         SET(SUBDIRS)
 830         SET(bin_PROGRAMS)
 831         SET(AM_CPPFLAGS -I${CMAKE_BINARY_DIR} )
 832         SET(AM_CXXFLAGS -I${CMAKE_BINARY_DIR})
 833         SET(LDADD)
 834         SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
 835         SET(salomepythondir ${pythondir}/salome)
 836         SET(salomepypkgdir ${salomepythondir}/salome)
 837         """)
 838
 839         if self.module == "smesh" and self.root[-len('SMESH_PY'):] == 'SMESH_PY':
 840            newlines.append("""
 841            SET(smeshpypkgdir ${salomepythondir}/salome/smesh)
 842            """)
 843            pass
 844         if self.module == "netgen":
 845             newlines.append(r'''
 846             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_CURRENT_SOURCE_DIR})
 847             ''')
 848         elif self.module == "kernel":
 849             newlines.append(r'''
 850             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
 851             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
 852             ''')
 853         else:
 854             if self.module not in ["yacs"]:
 855                 newlines.append(r'''
 856                 IF(KERNEL_ROOT_DIR)
 857                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 858                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 859                 ENDIF(KERNEL_ROOT_DIR)
 860                 ''')
 861                 pass
 862             if self.module == "gui":
 863                 newlines.append(r'''
 864                 IF(KERNEL_ROOT_DIR)
 865                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
 866                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
 867                 ENDIF(KERNEL_ROOT_DIR)
 868                 ''')
 869                 pass
 870             if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin", "hexoticplugin"]:
 871                 newlines.append(r'''
 872                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
 873                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
 874                 ''')
 875                 pass
 876             if self.module == "ghs3dplugin":
 877     # TODO: Auto-detect TetGen-GHS3D version automatically
 878                 newlines.append(r'''
 879                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DGHS3D_VERSION=42)
 880                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DGHS3D_VERSION=42)
 881                 ''')
 882                 pass
 883             if self.module == "hxx2salome":
 884                 key = "_SRC"
 885                 if self.the_root[-len(key):] != key:
 886                     msg = "Source dir must finished with %s !"%(key)
 887                     raise Exception(msg)
 888                 hxxmodule = self.the_root[:-len(key)]
 889                 from os.path import basename
 890                 hxxmodule = basename(hxxmodule)
 891                 hxxmodule = hxxmodule.lower()
 892                 self.hxxmodule = hxxmodule
 893                 newlines.append(r'''
 894                 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
 895                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 896                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 897                 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
 898                 '''%(hxxmodule.upper()))
 899                 pass
 900             pass
 901         # --
 902         return
 903
 904     def treatLine(self, line, newlines, opened_ifs):
 905
 906         # --
 907         # Print the comment above the line itself
 908         # --
 909         if line.find('#') >= 0:
 910             fields = line.split('#')
 911             line = fields[0]
 912             comment = '#'.join([''] + fields[1:])
 913             newlines.append(comment)
 914             if len(line) == 0:
 915                 return
 916             pass
 917
 918         # --
 919         # If the line begins with 'include ', just comment it
 920         # --
 921         if line.find("include ") == 0:
 922             if line.find("include $(top_srcdir)/config/automake.common") == 0:
 923                 for l in [
 924                     "MAINTAINERCLEANFILES = Makefile.in",
 925                     "AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
 926                     "AM_FFLAGS=-I$(top_srcdir)/include  -I$(top_builddir)/include",
 927                     "AM_FCFLAGS=-I$(top_srcdir)/include  -I$(top_builddir)/include",
 928                     "AM_CPPFLAGS+=@HDF5_CPPFLAGS@",
 929                     "AM_LDFLAGS=@HDF5_LDFLAGS@",
 930                     ]:
 931                     self.treatLine(l, newlines, opened_ifs)
 932                     pass
 933                 pass
 934             else:
 935                 newlines.append("# " + line)
 936                 pass
 937             return
 938
 939         # --
 940         # If the line begins with '-include', just comment it
 941         # --
 942         if line.find("-include") == 0:
 943             newlines.append("# " + line)
 944             return
 945
 946         # --
 947         # If the line is a definition of a make rule, just comment it
 948         # --
 949         if line.count(':') == 1:
 950             newlines.append("# " + line)
 951             return
 952
 953         # --
 954         # A particuliar case where there are two ":" on the same line
 955         # --
 956         if line.find('install-exec-local:') == 0:
 957             newlines.append("# " + line)
 958             return
 959
 960         # --
 961         # If the line begin by a tabulation, consider it's a makefile command and comment it
 962         # --
 963         if line.find("\t") == 0:
 964             newlines.append("# " + line)
 965             return
 966
 967         # --
 968         # --
 969         key = "-version-info"
 970         if line.find(key) >= 0:
 971             # --
 972             before = line.split(key)[0]
 973             after = line[len(before)+len(key):]
 974             sep = after[0]
 975             after = after[1:]
 976             version_info = after.split()[0]
 977             line = line.replace(key+sep+version_info, "")
 978             # --
 979             version_info = version_info.replace(':', '.')
 980             soversion_info = version_info.split('.')[0]
 981             newlines.append("SET(VERSION_INFO " + version_info + ")")
 982             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 983             # --
 984             pass
 985
 986         # --
 987         # Replace the $(TOTO) by ${TOTO}
 988         # Replace the @TOTO@  by ${TOTO}
 989         # --
 990         # VSR 15.04.2013 - process nesting substitutions properly, e.g. $(aaa$(bbb))
 991         #line = p_dollar.sub(r"${\1}", line)
 992         m_dollar = p_dollar.search(line)
 993         while m_dollar:
 994             line = p_dollar.sub(r"${\1}", line)
 995             m_dollar = p_dollar.search(line)
 996             pass
 997         line = p_arobas.sub(r"${\1}", line)
 998
 999         # --
1000         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
1001         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
1002         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
1003         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
1004         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
1005
1006         # --
1007         # Check if the line is a 'if' condition
1008         # If yes, replace it by a cmake grammar
1009         # --
1010         match = p_if.match(line)
1011         if match:
1012             theif = match.group("val")
1013             if theif[0] == "!":
1014                 theif = "NOT " + theif[1:]
1015                 pass
1016             line = p_if.sub(r"IF(%s)"%(theif), line)
1017             opened_ifs.append(theif)
1018             newlines.append(line)
1019             return
1020
1021         # --
1022         # Check if the line is a 'else' condition
1023         # If yes, replace it by a cmake grammar
1024         # --
1025         match = p_else.match(line)
1026         if match:
1027             line = "ELSE(%s)"%(opened_ifs[-1])
1028             newlines.append(line)
1029             return
1030
1031         # --
1032         # Check if the line is a 'endif' condition
1033         # If yes, replace it by a cmake grammar
1034         # --
1035         match = p_endif.match(line)
1036         if match:
1037             line = "ENDIF(%s)"%(opened_ifs[-1])
1038             opened_ifs[-1:] = []
1039             newlines.append(line)
1040             return
1041
1042         # --
1043         # Check if the line is an attribution '=' or '+='
1044         # --
1045         match = p_attribution.match(line)
1046         if match:
1047             self.treatAttribution(match, newlines)
1048             return
1049
1050         # --
1051         newlines.append(line)
1052
1053         # --
1054         return
1055
1056     def treatAttribution(self, match, newlines):
1057
1058         spaces = match.group("spaces")
1059         key = match.group("key")
1060         method = match.group("method")
1061         value = match.group("value")
1062         # print [spaces, key, method, value]
1063
1064         # --
1065         # Open cmake SET command
1066         # --
1067         newlines.append(spaces + "SET(" + key)
1068
1069         # --
1070         # If method is '+=', put the previous definition as first value
1071         # --
1072         if method == "+=":
1073             newlines.append("%s    ${%s}"%(spaces, key))
1074             pass
1075
1076         # --
1077         fields = value.split()
1078
1079         for i in range(len(fields)):
1080             newlines.append("%s    %s"%(spaces, fields[i]))
1081             pass
1082
1083         # --
1084         if method == "+=":
1085             # --
1086             # The try: except KeyError is here if the +=
1087             # is an error which occurs in salome ...
1088             # --
1089             try:
1090                 self.__thedict__[key] += fields[:]
1091             except KeyError:
1092                 self.__thedict__[key] = fields[:]
1093                 pass
1094             pass
1095         else:
1096             self.__thedict__[key]  = fields[:]
1097             pass
1098
1099         # --
1100         # Close cmake SET command
1101         # --
1102
1103         newlines.append("%s)"%(spaces))
1104
1105         return
1106
1107     def finalize(self, newlines):
1108
1109         # --
1110         # Convert the .in files in build dir
1111         # --
1112         upmod = ""
1113         if self.module == "hexoticplugin" :
1114           upmod = "HexoticPLUGIN"
1115         else :
1116           upmod = self.module.upper()
1117
1118         import operator
1119         mod = self.module
1120         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1121             newlines.append(r'''
1122             SET(top_builddir
1123                 ${CMAKE_BINARY_DIR}
1124             )
1125             SET(top_srcdir
1126                 ${CMAKE_SOURCE_DIR}
1127             )
1128             SET(srcdir
1129                 ${CMAKE_CURRENT_SOURCE_DIR}
1130             )
1131             SET(builddir
1132                 ${CMAKE_CURRENT_BINARY_DIR}
1133             )
1134             SET(datadir
1135                 ${CMAKE_INSTALL_PREFIX}/share
1136             )
1137             SET(docdir
1138                 ${datadir}/doc/salome
1139             )
1140             ''')
1141             self.files.append("static/header.html.in")
1142         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']:
1143             newlines.append(r'''
1144             SET(top_builddir
1145                 ${CMAKE_BINARY_DIR}
1146             )
1147             SET(top_srcdir
1148                 ${CMAKE_SOURCE_DIR}
1149             )
1150             SET(srcdir
1151                 ${CMAKE_CURRENT_SOURCE_DIR}
1152             )
1153             SET(builddir
1154                 ${CMAKE_CURRENT_BINARY_DIR}
1155             )
1156             SET(datadir
1157                 ${CMAKE_INSTALL_PREFIX}/share
1158             )
1159             SET(docdir
1160                 ${datadir}/doc/salome
1161             )
1162             ''')
1163             if mod in ['yacs']:
1164                 self.files.append("sources/header.html.in")
1165             else:
1166                 self.files.append("static/header.html.in")
1167             if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1168               self.files.append("static/header_py.html.in")
1169
1170         if self.module == "yacs":
1171             key = "salomegui"
1172             if self.root[-len(key):] == key:
1173                 self.files.append("resources/YACSCatalog.xml.in")
1174                 self.files.append("resources/SalomeApp.xml.in")
1175                 pass
1176             pass
1177
1178         if self.module == "jobmanager":
1179             key = "salomegui"
1180             if self.root[-len(key):] == key:
1181                 self.files.append("resources/SalomeApp.xml.in")
1182                 pass
1183             pass
1184         for f in self.files:
1185             if f[-3:] == ".in":
1186                 if f == "sstream.in":
1187                     continue
1188                 if f in ["runContainer.in", "stopContainer.in"]:
1189                     if self.module == "med":
1190                         if self.root[-3:] == "csh":
1191                             continue
1192                         pass
1193                     pass
1194                 if f == "SALOMEconfig.ref.in":
1195                     out = "SALOMEconfig.h"
1196                 else:
1197                     out = f[:-3]
1198                     pass
1199                 newlines.append(r'''
1200                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1201                 '''%(f))
1202                 newlines.append(r'''
1203                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1204                 '''%(out))
1205                 newlines.append(r'''
1206                 MESSAGE(STATUS "Creation of ${output}")
1207                 CONFIGURE_FILE(${input} ${output})
1208                 ''')
1209                 pass
1210             pass
1211
1212         # --
1213         # add commands for generating of user's documentation
1214         # --
1215         doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1216         doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1217         doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1218         head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1219         if mod == 'kernel':
1220             prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1221         else:
1222             prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1223         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1224             if mod == 'med':
1225                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1226                 input = "Doxyfile_med_user"
1227             else:
1228                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1229                 input = ""
1230             newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1231             COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1232             VERBATIM
1233             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1234             )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1235         from os import path
1236         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'):
1237             ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1238             if mod in ['geom']:
1239                 if mod == 'geom':
1240                     tmp = 'geomBuilder'
1241                     input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1242                 newlines.append(r"""
1243                 IF(WINDOWS)
1244                   STRING(REPLACE "/" "\\" f "%s")
1245                 ELSE(WINDOWS)
1246                   SET(f "%s")
1247                 ENDIF(WINDOWS)
1248                 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1249                 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1250                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1251                 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1252                 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''')"
1253                 VERBATIM
1254                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1255                 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, upmod, tmp, input, tmp, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1256                 newlines.append(r"""ADD_DEPENDENCIES(usr_docs html_docs)""")
1257             else:
1258                 config_f = ""
1259                 extra_doc_dir = ""
1260                 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1261                     config_f = "${DOXYGEN_EXECUTABLE} doxyfile_py"
1262                     extra_doc_dir = "%spy_doc"%(mod)
1263                 elif mod not in ['pyhello']:
1264                     config_f = "${DOXYGEN_EXECUTABLE} doxyfile_idl"
1265                     if mod == 'visu':
1266                         extra_doc_dir = "%sgen_doc"%(mod)
1267                 inst_head_command = ""
1268                 if extra_doc_dir != "":
1269                     inst_head_command = "; shutil.copy(r'''%s''', r'''${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s/%s''')"%(head_source, upmod, extra_doc_dir)
1270                 newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs %s
1271                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1272                 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"
1273                 VERBATIM
1274                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1275                 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination, inst_head_command))
1276         elif mod in ['yacs', 'jobmanager'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1277             from sys import platform
1278             params = '';
1279             if platform == "win32":
1280                 params = '-Q';
1281             newlines.append(r"""
1282             ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1283             COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1284             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1285         elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1286             from sys import platform
1287             params = ""
1288             ext = ""
1289             prf = ""
1290             if platform == "win32":
1291                 params = '-Q';
1292                 ext = "bat"
1293                 prf = "call"
1294                 cmd = "STRING(REPLACE \"/\" \"\\\\\" SCR"
1295             else:
1296                 ext = "sh"
1297                 prf = ". "
1298                 cmd = "SET(SCR"
1299             doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1300             scr = self.writeEnvScript(upmod)
1301             newlines.append(r"""
1302             %s "%s")
1303             FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1304             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
1305             COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1306             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(cmd, scr, ext, prf, ext, params, doc_gui_destination, doc_gui_destination))
1307
1308
1309
1310
1311   # --
1312   # add commands for generating of developer's documentation
1313   # --
1314
1315         upmod = self.module.upper()
1316         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' ):
1317             if mod == 'kernel':
1318                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1319             COMMAND ${DOXYGEN_EXECUTABLE}
1320             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')"  """
1321                 tmp1=""
1322             else:
1323                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1324                 if mod == 'visu':
1325                     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)
1326                 elif mod == 'smesh':
1327                     tmp1= """\n            COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s''')" """%(doc_tui_destination)
1328                 else:
1329                     tmp1=""
1330             if mod == 'yacs':
1331                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/htmldev"
1332             else:
1333                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1334             inst_head_command=""
1335             inst_head_command = "; shutil.copy(r'''%s''', r'''%s''')"%(head_source, doc_tui_destination)
1336             newlines.append(tmp + """
1337             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 + """
1338             VERBATIM
1339             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1340             )""")
1341         if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1342             tmp = 'geomBuilder'
1343             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1344             newlines.append(r"""
1345             IF(WINDOWS)
1346               STRING(REPLACE "/" "\\" f "%s")
1347             ELSE(WINDOWS)
1348               SET(f "%s")
1349             ENDIF(WINDOWS)
1350             ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1351             COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1352             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/%s.py''')"
1353             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''')"
1354             VERBATIM
1355             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1356             )"""%(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))
1357
1358         # --
1359         # convert the SUBDIRS in cmake grammar
1360         # --
1361         if 1: # self.__thedict__.has_key("SUBDIRS"):
1362             newlines.append(r'''
1363             FOREACH(dir ${SUBDIRS})
1364             IF(NOT dir STREQUAL .)
1365             ADD_SUBDIRECTORY(${dir})
1366             ENDIF(NOT dir STREQUAL .)
1367             ENDFOREACH(dir ${SUBDIRS})
1368             ''')
1369             pass
1370
1371         # --
1372         # --
1373         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1374             if self.__thedict__.has_key(key):
1375                 self.addLibTarget(key, newlines)
1376                 pass
1377             pass
1378
1379         # --
1380         # --
1381         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1382             if self.__thedict__.has_key(key):
1383                 self.addBinTarget(key, newlines)
1384                 pass
1385             pass
1386
1387         # --
1388         # --
1389         if self.__thedict__.has_key("BASEIDL_FILES"):
1390             if not self.__thedict__.has_key("IDL_FILES"):
1391                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1392                 newlines.append('''
1393                 SET(IDL_FILES ${BASEIDL_FILES})
1394                 ''')
1395                 pass
1396             pass
1397
1398         # --
1399         # --
1400
1401         key = "IDL_FILES"
1402         if self.__thedict__.has_key(key):
1403             if self.module == "kernel":
1404                 newlines.append('''
1405                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1406                 ''')
1407                 pass
1408             newlines.append('''
1409             FOREACH(input ${IDL_FILES})
1410             STRING(REGEX REPLACE ".idl" "" base ${input})
1411             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1412             SET(outputs ${src})
1413             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1414             SET(outputs ${outputs} ${dynsrc})
1415             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1416             SET(outputs ${outputs} ${inc})
1417             IF(input STREQUAL Calcium_Ports.idl)
1418             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1419             ELSE(input STREQUAL Calcium_Ports.idl)
1420             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1421             ENDIF(input STREQUAL Calcium_Ports.idl)
1422             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1423             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1424             IF(NOT ISBCXX)
1425             SET(flags -bcxx ${flags})
1426             ENDIF(NOT ISBCXX)
1427             ADD_CUSTOM_COMMAND(
1428             OUTPUT ${outputs}
1429             COMMAND ${OMNIORB_IDL} ${flags} ${input}
1430             MAIN_DEPENDENCY ${input}
1431             )
1432             ''')
1433             newlines.append('''
1434             install(FILES ${input} DESTINATION idl/salome)
1435             ''')
1436             if self.module not in ["pyhello"]:
1437                 newlines.append('''
1438                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1439                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1440                 ''')
1441                 pass
1442             newlines.append('''
1443             INSTALL(CODE "SET(IDL_FILE ${input})")
1444             INSTALL(CODE "SET(DIR ${salomepythondir})")
1445             IF(WINDOWS)
1446             INSTALL(CODE "SET(DIR bin/salome)")
1447             ENDIF(WINDOWS)
1448             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1449             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1450             # --
1451             SET(flags)
1452             FOREACH(f ${IDLPYFLAGS})
1453             SET(flags "${flags} ${f}")
1454             ENDFOREACH(f ${IDLPYFLAGS})
1455             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1456             IF(NOT ISBPYTHON)
1457             SET(flags "-bpython ${flags}")
1458             ENDIF(NOT ISBPYTHON)
1459             SET(IDLPYFLAGS ${flags})
1460             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1461             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1462             # --
1463             ''')
1464             if self.module == "kernel":
1465                 newlines.append('''
1466                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1467                 ''')
1468             else:
1469                 newlines.append('''
1470                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1471                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_python_from_idl.cmake)
1472                 ''')
1473                 pass
1474             newlines.append('''
1475             ENDFOREACH(input ${IDL_FILES})
1476             ''')
1477             pass
1478
1479         # --
1480         # --
1481         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1482             if self.__thedict__.has_key(key):
1483                 newlines.append('''
1484                 SET(SWIG_SOURCES ${%s})
1485                 '''%(key))
1486                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1487                 pass
1488             pass
1489
1490         # --
1491         # --
1492         if self.__thedict__.has_key("SWIG_SOURCES"):
1493             newlines.append('''
1494             IF(SWIG_SOURCES MATCHES ";")
1495             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1496             ELSE(SWIG_SOURCES MATCHES ";")
1497             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1498             ENDIF(SWIG_SOURCES MATCHES ";")
1499             SET(flags)
1500             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1501             SET(test ON)
1502             IF(flags)
1503             LIST(FIND flags ${f} index)
1504             IF(NOT index EQUAL -1)
1505             SET(test OFF)
1506             ENDIF(NOT index EQUAL -1)
1507             ENDIF(flags)
1508             IF(test)
1509             SET(flags ${flags} ${f})
1510             ENDIF(test)
1511             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1512             ADD_CUSTOM_COMMAND(
1513             OUTPUT ${build_srcs}
1514             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1515             MAIN_DEPENDENCY ${SWIG_SOURCES}
1516             )
1517             ''')
1518             pass
1519
1520         # --
1521         # --
1522         if self.__thedict__.has_key("BUILT_SOURCES"):
1523             newlines.append('''
1524             FOREACH(f ${BUILT_SOURCES})
1525             IF(f MATCHES "WRAP.cxx$")
1526             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1527             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1528             ADD_CUSTOM_COMMAND(
1529             OUTPUT ${f} # ${inc}
1530             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1531             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1532             )
1533             ENDIF(f MATCHES "WRAP.cxx$")
1534             ENDFOREACH(f ${BUILT_SOURCES})
1535             ''')
1536             pass
1537
1538         # --
1539         # --
1540         key = "MOC_FILES"
1541         if self.__thedict__.has_key(key):
1542             newlines.append('''
1543             FOREACH(output ${MOC_FILES})
1544             ''')
1545             if self.module in ["jobmanager", "yacs"]:
1546                 newlines.append('''
1547                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1548                 ''')
1549             else:
1550                 newlines.append('''
1551                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1552                 ''')
1553                 pass
1554             newlines.append('''
1555             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1556             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1557             ADD_CUSTOM_COMMAND(
1558             OUTPUT ${output}
1559             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1560             MAIN_DEPENDENCY ${input}
1561             )
1562             ENDFOREACH(output ${MOC_FILES})
1563             ''')
1564             pass
1565
1566         # --
1567         # --
1568         key = "MOC_FILES_HXX"
1569         if self.__thedict__.has_key(key):
1570             newlines.append('''
1571             FOREACH(output ${MOC_FILES_HXX})
1572             ''')
1573             newlines.append('''
1574             STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1575             ''')
1576             newlines.append('''
1577             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1578             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1579             ADD_CUSTOM_COMMAND(
1580             OUTPUT ${output}
1581             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1582             MAIN_DEPENDENCY ${input}
1583             )
1584             ENDFOREACH(output ${MOC_FILES_HXX})
1585             ''')
1586             pass
1587
1588         # --
1589         # --
1590         key = "UIC_FILES"
1591         if self.__thedict__.has_key(key):
1592             newlines.append('''
1593             FOREACH(output ${UIC_FILES})
1594             STRING(REPLACE "ui_" "" input ${output})
1595             STRING(REPLACE ".h" ".ui" input ${input})
1596             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1597             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1598             ADD_CUSTOM_COMMAND(
1599             OUTPUT ${output}
1600             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1601             MAIN_DEPENDENCY ${input}
1602             )
1603             ENDFOREACH(output ${UIC_FILES})
1604             ''')
1605             pass
1606
1607         # --
1608         # --
1609         key = "PYUIC_FILES"
1610         if self.__thedict__.has_key(key):
1611             newlines.append('''
1612             FOREACH(output ${PYUIC_FILES})
1613             STRING(REPLACE "_ui.py" ".ui" input ${output})
1614             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1615             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1616             ADD_CUSTOM_COMMAND(
1617             OUTPUT ${output}
1618             COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1619             MAIN_DEPENDENCY ${input}
1620             )
1621             ENDFOREACH(output ${PYUIC_FILES})
1622             ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1623             ''')
1624             pass
1625
1626         # --
1627         # --
1628         key = "QRC_FILES"
1629         if self.__thedict__.has_key(key):
1630             newlines.append('''
1631             FOREACH(output ${QRC_FILES})
1632             STRING(REGEX REPLACE "qrc_" "" input ${output})
1633             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1634             STRING(REGEX REPLACE ".qrc" "" name ${input})
1635             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1636             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1637             ADD_CUSTOM_COMMAND(
1638             OUTPUT ${output}
1639             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1640             MAIN_DEPENDENCY ${input}
1641             )
1642             ENDFOREACH(output ${QRC_FILES})
1643             ''')
1644             pass
1645
1646         # --
1647         # --
1648         key = "SIP_FILES"
1649         if self.__thedict__.has_key(key):
1650             newlines.append('''
1651             FOREACH(input ${SIP_FILES})
1652             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1653             SET(output)
1654             FOREACH(out ${SIP_SRC})
1655             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1656             ENDFOREACH(out ${SIP_SRC})
1657             ADD_CUSTOM_COMMAND(
1658             OUTPUT ${output}
1659             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1660             MAIN_DEPENDENCY ${input}
1661             )
1662             ENDFOREACH(input ${SIP_FILES})
1663             ''')
1664             pass
1665
1666         # --
1667         # For GUI/tools/dlgfactory
1668         # --
1669         key = "UIC_FILES_QDIALOG"
1670         if self.__thedict__.has_key(key):
1671             newlines.append('''
1672             FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1673             STRING(REPLACE "ui_" "" input ${output})
1674             STRING(REPLACE ".hxx" ".ui" input ${input})
1675             SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1676             IF (NOT EXISTS ${input_path})
1677               SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1678             ENDIF (NOT EXISTS ${input_path})
1679             ADD_CUSTOM_COMMAND(
1680             OUTPUT ${output}
1681             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1682             MAIN_DEPENDENCY ${input}
1683             )
1684             ENDFOREACH(output ${UIC_FILES})
1685
1686             FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1687             STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1688             SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1689             IF (NOT EXISTS ${input_path})
1690               SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1691             ENDIF (NOT EXISTS ${input_path})
1692             ADD_CUSTOM_COMMAND(
1693             OUTPUT ${output}
1694             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1695             MAIN_DEPENDENCY ${input}
1696             )
1697             ENDFOREACH(output ${MOC_FILES})
1698
1699             ADD_CUSTOM_COMMAND(
1700             OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1701             COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1702             DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1703             )
1704
1705             ADD_CUSTOM_COMMAND(
1706             OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1707             COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1708             DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1709             )
1710             ''')
1711             pass
1712
1713         # --
1714         # For make check
1715         # --
1716         for key in ["TESTS"]:
1717             if self.__thedict__.has_key(key):
1718                 newlines.append('''
1719                 SET(UNIT_TEST_PROG ${%s})
1720                 '''%(key))
1721                 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1722                 pass
1723             pass
1724         key = "UNIT_TEST_PROG"
1725         if self.__thedict__.has_key(key):
1726             newlines.append('''
1727             FOREACH(input ${UNIT_TEST_PROG})
1728             GET_FILENAME_COMPONENT(ext ${input} EXT)
1729             IF(ext STREQUAL .py)
1730             SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1731             ELSE(ext STREQUAL .py)
1732             IF(WINDOWS)
1733             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1734             ELSE()
1735             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1736             ENDIF()
1737             ENDIF(ext STREQUAL .py)
1738             ADD_TEST(${input} ${test})
1739             SET(fail_regex "KO")
1740             SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1741             # IF(NOT WINDOWS)
1742             # ADD_TEST(${input}_valgrind valgrind ${test})
1743             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1744             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1745             # ENDIF()
1746             ENDFOREACH(input ${UNIT_TEST_PROG})
1747             ''')
1748             pass
1749
1750         # --
1751         # Treat the install targets
1752         # --
1753         resdir = self.module
1754         if resdir == "hxx2salome":
1755             resdir = self.hxxmodule
1756             pass
1757         d = {
1758             "salomeadmux_DATA"                 :  "salome_adm/unix",
1759             "dist_salomeadmux_DATA"            :  "salome_adm/unix",
1760             "dist_salome_cmake_DATA"           :  "salome_adm/cmake_files",
1761             "dist_salomem4_DATA"               :  "salome_adm/unix/config_files",
1762             "dist_salome4depr_DATA"            :  "salome_adm/unix/config_files/DEPRECATED",
1763             "dist_admlocalm4_DATA"             :  "adm_local/unix/config_files",
1764             "dist_admlocal_cmake_DATA"         :  "adm_local/cmake_files",
1765             "salomeinclude_DATA"               :  "include/salome",
1766             "salomeinclude_HEADERS"            :  "include/salome",
1767             "nodist_salomeinclude_HEADERS"     :  "include/salome",
1768             "dist_salomeres_DATA"              :  "share/salome/resources/%s"%(resdir),
1769             "nodist_salomeres_DATA"            :  "share/salome/resources/%s"%(resdir),
1770             "nodist_salomeres_SCRIPTS"         :  "share/salome/resources/%s"%(resdir),
1771             "dist_salomescript_SCRIPTS"        :  "bin/salome",
1772             "dist_salomescript_DATA"           :  "bin/salome",
1773             "dist_salomescript_PYTHON"         :  "bin/salome",
1774             "dist_appliskel_SCRIPTS"           :  "bin/salome/appliskel",
1775             "dist_appliskel_PYTHON"            :  "bin/salome/appliskel",
1776             "nodist_salomescript_DATA"         :  "bin/salome",
1777             "salomepython_PYTHON"              :  "${salomepythondir}",
1778             "nodist_salomepython_PYTHON"       :  "${salomepythondir}",
1779             "dist_salomepython_DATA"           :  "${salomepythondir}",
1780             "sharedpkgpython_PYTHON"           :  "${salomepythondir}/shared_modules",
1781             "salomepypkg_PYTHON"               :  "${salomepypkgdir}",
1782             "mypkgpython_PYTHON"               :  "${mypkgpythondir}",
1783             "stdpkgpython_PYTHON"              :  "${stdpkgpythondir}",
1784             "nodist_mypkgpython_PYTHON"        :  "${mypkgpythondir}",
1785             }
1786         if self.module == "jobmanager":
1787             d["bin_SCRIPTS"] = "bin"
1788             pass
1789         if self.module == "medfile":
1790             d = {
1791                 "include_HEADERS"        :  "include",
1792                 "nodist_include_HEADERS" :  "include",
1793                 "bin_SCRIPTS"            :  "bin",
1794                 "doc_DATA"               :  "${docdir}",
1795                 }
1796             pass
1797         if self.module == "netgen":
1798             d = {
1799                 "include_HEADERS"        :  "include",
1800                 "noinst_HEADERS"         :  "share/netgen/include",
1801                 "dist_pkgdata_DATA"      :  "share/netgen",
1802                 "dist_doc_DATA"          :  "share/doc/netgen",
1803                 }
1804             pass
1805         for key, value in d.items():
1806             if self.__thedict__.has_key(key):
1807                 self.addInstallTarget(key, value, newlines)
1808                 pass
1809             pass
1810
1811         # --
1812         return
1813
1814     def setLibAdd(self, key, newlines):
1815         # --
1816         newlines.append(r'''
1817         SET(libadd)
1818         ''')
1819         # --
1820         newlines.append(r'''
1821         IF(WINDOWS)
1822         SET(targets)
1823         SET(targets ${targets} MEFISTO2D)
1824         FOREACH(target ${targets})
1825         IF(name STREQUAL ${target})
1826         SET(dir $ENV{F2CHOME})
1827         STRING(REPLACE "\\\\" "/" dir ${dir})
1828         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1829         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1830         ENDIF(name STREQUAL ${target})
1831         ENDFOREACH(target ${targets})
1832         ELSE(WINDOWS)
1833         SET(targets)
1834         SET(targets ${targets} MEFISTO2D)
1835         FOREACH(target ${targets})
1836         IF(name STREQUAL ${target})
1837         SET(libadd ${libadd} -lf2c)
1838         ENDIF(name STREQUAL ${target})
1839         ENDFOREACH(target ${targets})
1840         ENDIF(WINDOWS)
1841         ''')
1842         # --
1843         newlines.append(r'''
1844         STRING(REPLACE "-module" "" ${amname}_LDFLAGS "${${amname}_LDFLAGS}")
1845         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1846         FOREACH(lib SALOMEBasics SalomeBatch)
1847         IF(name STREQUAL lib)
1848         SET(libs ${libs} ${PTHREAD_LIBS})
1849         ENDIF(name STREQUAL lib)
1850         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1851         ''')
1852         # --
1853         newlines.append(r'''
1854         FOREACH(lib ${libs})
1855         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1856         IF(ext STREQUAL .la)
1857         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1858         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1859         ENDIF(ext STREQUAL .la)
1860         SET(vars)
1861         SET(vars ${vars} -no-undefined)
1862         SET(vars ${vars} -lvtkWidgets)
1863         IF(WINDOWS)
1864         SET(vars ${vars} -module)
1865         SET(vars ${vars} -Wl,-E)
1866         SET(vars ${vars} -Xlinker)
1867         SET(vars ${vars} -export-dynamic)
1868         SET(vars ${vars} -lm)
1869         SET(vars ${vars} -lboost_thread)
1870         SET(vars ${vars} -lboost_signals)
1871         SET(vars ${vars} -pthread -lpthread -ldl)
1872         ENDIF(WINDOWS)
1873         FOREACH(v ${vars})
1874         IF(lib STREQUAL v)
1875         SET(lib)
1876         ENDIF(lib STREQUAL v)
1877         ENDFOREACH(v ${vars})
1878         SET(test OFF)
1879         IF(lib)
1880         STRING(REGEX MATCH "^-lQt" test ${lib})
1881         ENDIF(lib)
1882         IF(NOT test)
1883         SET(libadd ${libadd} ${lib})
1884         ENDIF(NOT test)
1885         ENDFOREACH(lib ${libs})
1886         TARGET_LINK_LIBRARIES(${name} ${libadd})
1887         ''')
1888         # --
1889         newlines.append(r'''
1890         IF(WINDOWS)
1891         SET(targets)
1892         SET(targets ${targets} MEFISTO2D)
1893         FOREACH(target ${targets})
1894         IF(name STREQUAL ${target})
1895         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1896         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1897         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1898         ENDIF(name STREQUAL ${target})
1899         ENDFOREACH(target ${targets})
1900         ENDIF(WINDOWS)
1901         ''')
1902         # --
1903         return
1904
1905     def setCompilationFlags(self, key, newlines):
1906         newlines.append(r'''
1907         SET(var)
1908         IF(WINDOWS)
1909         SET(targets)
1910         SET(targets ${targets} SalomeIDLKernel)
1911         SET(targets ${targets} SalomeDS)
1912         SET(targets ${targets} SALOMEDSTest)
1913         SET(targets ${targets} SALOMEDS_Client_exe)
1914         SET(targets ${targets} SalomeIDLGEOM)
1915         SET(targets ${targets} GEOMEngine)
1916         SET(targets ${targets} MEDEngine)
1917         SET(targets ${targets} SMESHEngine)
1918         SET(targets ${targets} SMESH)
1919         SET(targets ${targets} SalomeIDLSPADDER)
1920         SET(targets ${targets} MeshJobManagerEngine)
1921         SET(targets ${targets} StdMeshersEngine)
1922         SET(targets ${targets} VISUEngineImpl)
1923         FOREACH(target ${targets})
1924         IF(name STREQUAL ${target})
1925         SET(var ${var} -DNOGDI)
1926         ENDIF(name STREQUAL ${target})
1927         ENDFOREACH(target ${targets})
1928         ENDIF(WINDOWS)
1929         ''')
1930         # --
1931         if self.module in ["medfile", "yacs"]:
1932             newlines.append(r'''
1933             IF(WINDOWS)
1934             SET(var ${var} -DNOGDI)
1935             ENDIF(WINDOWS)
1936             ''')
1937             pass
1938         # --
1939         newlines.append(r'''
1940         IF(WINDOWS)
1941         SET(targets)
1942         SET(targets ${targets} MEFISTO2D)
1943         FOREACH(target ${targets})
1944         IF(name STREQUAL ${target})
1945         SET(dir $ENV{F2CHOME})
1946         STRING(REPLACE "\\\\" "/" dir ${dir})
1947         SET(var ${var} -I${dir})
1948         SET(var ${var} -DF2C_BUILD)
1949         ENDIF(name STREQUAL ${target})
1950         ENDFOREACH(target ${targets})
1951         ENDIF(WINDOWS)
1952         ''')
1953         # --
1954         if self.module in ["geom", "med", "hexoticplugin", "blsurfplugin"]:
1955             newlines.append(r'''
1956             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1957             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1958             ''')
1959             pass
1960         newlines.append(r'''
1961         SET(var ${var} ${AM_CPPFLAGS})
1962         SET(var ${var} ${AM_CXXFLAGS})
1963         ''')
1964         # --
1965         newlines.append(r'''
1966         IF(type STREQUAL STATIC)
1967         SET(var ${var} -fPIC)
1968         ENDIF(type STREQUAL STATIC)
1969         ''')
1970         # --
1971         if self.module == "yacs":
1972             newlines.append(r'''
1973             SET(var ${var} -DYACS_PTHREAD)
1974             SET(var ${var} -DCMAKE_BUILD)
1975             SET(var ${var} -DSALOME_KERNEL)
1976             SET(var ${var} -DDSC_PORTS)
1977             SET(var ${var} -DOMNIORB)
1978             ''')
1979             pass
1980         newlines.append(r'''
1981   SET(var ${var} ${PLATFORM_CPPFLAGS})
1982   SET(var ${var} ${PTHREAD_CFLAGS})
1983   SET(var ${var} ${${amname}_CPPFLAGS})
1984   SET(var ${var} ${${amname}_CXXFLAGS})
1985   SET(var ${var} ${${amname}_CFLAGS})
1986         SET(vars)
1987         IF(WINDOWS)
1988         SET(vars ${vars} -include SALOMEconfig.h)
1989         SET(vars ${vars} -ftemplate-depth-32)
1990         SET(vars ${vars} -fPIC)
1991         SET(vars ${vars} -g)
1992         IF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")          # if platform is Windows 64 bit
1993         IF(name STREQUAL _pilot)
1994         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")    # to avoid error C1128
1995         ENDIF(name STREQUAL _pilot)
1996         ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
1997         ENDIF(WINDOWS)
1998         SET(flags)
1999         FOREACH(f ${var})
2000         FOREACH(v ${vars})
2001         IF(f STREQUAL v)
2002         SET(f)
2003         ENDIF(f STREQUAL v)
2004         ENDFOREACH(v ${vars})
2005         IF(f)
2006         string(REGEX MATCH "^-I" test_include ${f})
2007         if(test_include)
2008         string(REGEX REPLACE "^-I" "" include_dir ${f})
2009         if(include_dir)
2010         if(include_dir STREQUAL /usr/include)
2011         else(include_dir STREQUAL /usr/include)
2012         string(REGEX MATCH "^\\." test_dot ${include_dir})
2013         if(test_dot)
2014         set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
2015         endif(test_dot)
2016         include_directories(${include_dir})
2017         endif(include_dir STREQUAL /usr/include)
2018         endif(include_dir)
2019         else(test_include)
2020         SET(flags "${flags} ${f}")
2021         endif(test_include)
2022         ENDIF(f)
2023         ENDFOREACH(f ${var})
2024         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2025         ''')
2026         return
2027
2028     def addLibTarget(self, key, newlines):
2029         newlines.append(r'''
2030         FOREACH(amname ${%s})
2031         '''%(key))
2032         # --
2033         # Replace .la by _la ...
2034         # --
2035         newlines.append(r'''
2036         STRING(REPLACE .la _la amname ${amname})
2037         ''')
2038         # --
2039         # Remove the _la for the cmake name
2040         # --
2041         newlines.append(r'''
2042         STRING(LENGTH ${amname} len)
2043         MATH(EXPR newlen "${len}-3")
2044         STRING(SUBSTRING ${amname} 0 ${newlen} name)
2045         ''')
2046         # --
2047         # Does the target begins with lib ??
2048         # If yes, remove lib at beginning for cmake name
2049         # --
2050         newlines.append(r'''
2051         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2052         IF(BEGIN_WITH_lib)
2053         STRING(LENGTH ${name} len)
2054         MATH(EXPR newlen "${len}-3")
2055         STRING(SUBSTRING ${name} 3 ${newlen} name)
2056         ENDIF(BEGIN_WITH_lib)
2057         ''')
2058         # --
2059         # Does the target is an idl library
2060         # --
2061         newlines.append(r'''
2062         STRING(REGEX MATCH "IDL" ISIDL ${name})
2063         ''')
2064         # --
2065         # Set the type of the library
2066         # --
2067         newlines.append(r'''
2068         IF(ISIDL)
2069         IF(WINDOWS)
2070         SET(type STATIC)
2071         ELSE(WINDOWS)
2072         SET(type SHARED)
2073         ENDIF(WINDOWS)
2074         ELSE(ISIDL)
2075         SET(type SHARED)
2076         ENDIF(ISIDL)
2077         ''')
2078         if key == "noinst_LTLIBRARIES":
2079             newlines.append(r'''
2080             IF(WINDOWS)
2081             SET(type STATIC)
2082             ELSE(WINDOWS)
2083             SET(type STATIC)
2084             ENDIF(WINDOWS)
2085             ''')
2086             pass
2087         # --
2088         # Set sources for the library
2089         # --
2090         newlines.append(r'''
2091         SET(srcs)
2092         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2093         GET_FILENAME_COMPONENT(ext ${src} EXT)
2094         IF(ext STREQUAL .f)
2095         IF(src STREQUAL trte.f)
2096         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2097         STRING(REPLACE ".f" ".c" src ${src})
2098         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2099         SET(output ${src})
2100         SET(cmd f2c)
2101         IF(NOT WINDOWS)
2102         IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2103         SET(cmd valgrind f2c)  # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2104         ENDIF()
2105         ENDIF(NOT WINDOWS)
2106         ADD_CUSTOM_COMMAND(
2107         OUTPUT ${output}
2108         COMMAND ${cmd} ${input}
2109         MAIN_DEPENDENCY ${input}
2110         )
2111         ELSE(src STREQUAL trte.f)
2112         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2113         STRING(REPLACE ".f" ".o" src ${src})
2114         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2115         SET(output ${src})
2116         IF(WINDOWS)
2117         SET(F77 g77)
2118         ELSE(WINDOWS)
2119         SET(F77 gfortran)
2120         ENDIF(WINDOWS)
2121         ADD_CUSTOM_COMMAND(
2122         OUTPUT ${output}
2123         COMMAND ${F77} -c -o ${output} ${input}
2124         MAIN_DEPENDENCY ${input}
2125         )
2126         ENDIF(src STREQUAL trte.f)
2127         ENDIF(ext STREQUAL .f)
2128         SET(srcs ${srcs} ${src})
2129         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2130         ''')
2131         newlines.append(r'''
2132         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2133         FOREACH(f ${l})
2134         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2135         SET(srcs ${srcs} ${src})
2136         ENDFOREACH(f ${l})
2137         ''')
2138         newlines.append(r'''
2139         SET(build_srcs)
2140         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2141         FOREACH(f ${l})
2142         GET_FILENAME_COMPONENT(ext ${f} EXT)
2143         IF(ext STREQUAL .py)
2144         SET(fff)
2145         ELSE(ext STREQUAL .py)
2146         SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2147         ENDIF(ext STREQUAL .py)
2148         IF(fff)
2149         IF(build_srcs)
2150         LIST(FIND build_srcs ${fff} index)
2151         IF(NOT index EQUAL -1)
2152         SET(fff)
2153         ENDIF(NOT index EQUAL -1)
2154         ENDIF(build_srcs)
2155         ENDIF(fff)
2156         IF(fff)
2157         SET(build_srcs ${build_srcs} ${fff})
2158         ENDIF(fff)
2159         ENDFOREACH(f ${l})
2160         ''')
2161         # --
2162         # Add the library to cmake
2163         # --
2164         newlines.append(r'''
2165         ADD_LIBRARY(${name} ${type} ${srcs})
2166         ''')
2167         # --
2168         # The compilation flags
2169         # --
2170         self.setCompilationFlags(key, newlines)
2171         # --
2172         newlines.append(r'''
2173         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2174         ''')
2175         # --
2176         self.setLibAdd(key, newlines)
2177         # --
2178         if 1: # key != "noinst_LTLIBRARIES":
2179             newlines.append(r'''
2180             SET(key %s)
2181             '''%(key))
2182             newlines.append(r'''
2183             SET(test ON)
2184             IF(${key} STREQUAL noinst_LTLIBRARIES)
2185             SET(test OFF)
2186             ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2187             ''')
2188             if self.module == "netgen" :
2189                 newlines.append(r'''
2190                 IF(${key} STREQUAL noinst_LTLIBRARIES)
2191                 IF(WINDOWS)
2192                 SET(test ON)
2193                 ENDIF(WINDOWS)
2194                 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2195                 ''')
2196                 pass
2197             newlines.append(r'''
2198             IF(test)
2199             ''')
2200             if self.module in ["medfile", "netgen"]:
2201                 newlines.append(r'''
2202                 SET(DEST lib)
2203                 ''')
2204             elif key == "libparaview_LTLIBRARIES":
2205                 newlines.append(r'''
2206                 SET(DEST lib/paraview)
2207                 ''')
2208             else:
2209                 newlines.append(r'''
2210                 SET(DEST lib/salome)
2211                 ''')
2212                 pass
2213             newlines.append(r'''
2214             IF(BEGIN_WITH_lib)
2215             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2216             ''')
2217             if self.module == "gui":
2218                 newlines.append(r'''
2219                 FOREACH(lib SalomePyQt)
2220                 IF(name STREQUAL lib)
2221                 IF(WINDOWS)
2222                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2223                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2224                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2225                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2226                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2227                 ELSE(WINDOWS)
2228                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2229                 ENDIF(WINDOWS)
2230                 ENDIF(name STREQUAL lib)
2231                 ENDFOREACH(lib SalomePyQt)
2232                 FOREACH(lib SalomePy)
2233                 IF(name STREQUAL lib)
2234                 IF(WINDOWS)
2235                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2236                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2237                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2238                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2239                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2240                 ENDIF(WINDOWS)
2241                 ENDIF(name STREQUAL lib)
2242                 ENDFOREACH(lib SalomePy)
2243                 ''')
2244                 pass
2245             if self.module == "geom":
2246                 newlines.append(r'''
2247                 IF(WINDOWS)
2248                 STRING(REGEX MATCH "Export" ISExport ${name})
2249                 IF(ISExport)
2250                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2251                 ENDIF(ISExport)
2252                 STRING(REGEX MATCH "Import" ISImport ${name})
2253                 IF(ISImport)
2254                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2255                 ENDIF(ISImport)
2256                 ENDIF(WINDOWS)
2257                 ''')
2258                 pass
2259             newlines.append(r'''
2260             ELSE(BEGIN_WITH_lib)
2261             ''')
2262             newlines.append(r'''
2263             IF(WINDOWS)
2264             INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2265             IF(CMAKE_BUILD_TYPE STREQUAL Release)
2266             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2267             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2268             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2269             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2270             ELSE(WINDOWS)
2271             GET_TARGET_PROPERTY(version ${name} VERSION)
2272             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2273             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2274             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2275             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2276             ENDIF(WINDOWS)
2277             ''')
2278             newlines.append(r'''
2279             ENDIF(BEGIN_WITH_lib)
2280             ''')
2281             newlines.append(r'''
2282             ENDIF(test)
2283             ''')
2284             pass
2285         # --
2286         newlines.append(r'''
2287         ENDFOREACH(amname ${%s})
2288         '''%(key))
2289         # --
2290         return
2291
2292     def addBinTarget(self, key, newlines):
2293         # --
2294         newlines.append(r'''
2295         FOREACH(amname ${%s})
2296         '''%(key))
2297         # --
2298         newlines.append(r'''
2299         SET(test ON)
2300         ''')
2301         if key == "check_PROGRAMS":
2302             newlines.append(r'''
2303             IF(bin_PROGRAMS)
2304             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2305             IF(is_present)
2306             SET(test OFF)
2307             ENDIF(is_present)
2308             ENDIF(bin_PROGRAMS)
2309             ''')
2310             pass
2311         newlines.append(r'''
2312         IF(test)
2313         ''')
2314         # --
2315         newlines.append(r'''
2316         SET(name "${amname}_exe")
2317         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2318         SET(l ${nodist_${amname}_SOURCES})
2319         FOREACH(f ${l})
2320         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2321         SET(srcs ${srcs} ${src})
2322         ENDFOREACH(f ${l})
2323         LIST(LENGTH srcs nb)
2324         IF(nb)
2325         ADD_EXECUTABLE(${name} ${srcs})
2326         ''')
2327         # --
2328         self.setCompilationFlags(key, newlines)
2329         # --
2330         self.setLibAdd(key, newlines)
2331         # --
2332         if self.module in ["jobmanager", "medfile", "netgen"]:
2333             newlines.append(r'''
2334             SET(DEST bin)
2335             ''')
2336         else:
2337             newlines.append(r'''
2338             SET(DEST bin/salome)
2339             ''')
2340             pass
2341         # --
2342         if key == "bin_PROGRAMS":
2343             newlines.append(r'''
2344             IF(WINDOWS)
2345             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2346             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2347             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2348             ELSE(WINDOWS)
2349             SET(PERMS)
2350             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2351             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2352             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2353             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2354             ENDIF(WINDOWS)
2355             ''')
2356             pass
2357         # --
2358         newlines.append(r'''
2359         ENDIF(nb)
2360         ''')
2361         # --
2362         newlines.append(r'''
2363         ENDIF(test)
2364         ''')
2365         newlines.append(r'''
2366         ENDFOREACH(amname ${%s})
2367         '''%(key))
2368         # --
2369         return
2370
2371     def addInstallTarget(self, key, destination, newlines):
2372         newlines.append(r"FOREACH(f ${%s})"%(key))
2373         newlines.append(r'''
2374         SET(DEST %s)
2375         '''%(destination))
2376         newlines.append(r'''
2377         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2378         IF(test_SALOMEconfig.h.in)
2379         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2380         ELSE(test_SALOMEconfig.h.in)
2381         SET(dummy dummy-NOTFOUND)
2382         MARK_AS_ADVANCED(dummy)
2383         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2384         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2385         IF(dummy)
2386         ''')
2387         if key in ['dist_salomescript_SCRIPTS',
2388                    'dist_appliskel_SCRIPTS',
2389                    'dist_appliskel_PYTHON']:
2390             newlines.append(r'''
2391             SET(PERMS)
2392             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2393             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2394             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2395             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2396             ''')
2397         else:
2398             newlines.append(r'''
2399             GET_FILENAME_COMPONENT(ext ${f} EXT)
2400             IF(ext STREQUAL .py)
2401             IF(DEST STREQUAL bin/salome)
2402             SET(PERMS)
2403             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2404             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2405             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2406             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2407             ELSE(DEST STREQUAL bin/salome)
2408             INSTALL(FILES ${f} DESTINATION ${DEST})
2409             ENDIF(DEST STREQUAL bin/salome)
2410             ELSE(ext STREQUAL .py)
2411             INSTALL(FILES ${f} DESTINATION ${DEST})
2412             ENDIF(ext STREQUAL .py)
2413             ''')
2414             pass
2415         newlines.append(r'''
2416         ELSE(dummy)
2417         GET_FILENAME_COMPONENT(ext ${f} EXT)
2418         IF(ext STREQUAL .qm)
2419         STRING(REGEX REPLACE .qm .ts input ${f})
2420         ''')
2421         if self.module in ["kernel", "gui", "yacs"]:
2422             newlines.append(r'''
2423             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2424             ''')
2425         else:
2426             newlines.append(r'''
2427             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2428             ''')
2429             pass
2430         newlines.append(r'''
2431         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2432         # ADD_CUSTOM_COMMAND(
2433         # OUTPUT ${output}
2434         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2435         # MAIN_DEPENDENCY ${input}
2436         # )
2437         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2438         ENDIF(ext STREQUAL .qm)
2439         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2440         ENDIF(dummy)
2441         ENDIF(test_SALOMEconfig.h.in)
2442         ''')
2443         newlines.append(r'''
2444         GET_FILENAME_COMPONENT(ext ${f} EXT)
2445         IF(ext STREQUAL .py)
2446         INSTALL(CODE "SET(PYTHON_FILE ${f})")
2447         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2448         INSTALL(CODE "SET(DEST ${DEST})")
2449         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2450         ''')
2451         if self.module == "kernel":
2452             newlines.append('''
2453             IF(f STREQUAL SALOME_ContainerPy.py)
2454             ELSE(f STREQUAL SALOME_ContainerPy.py)
2455             IF(f STREQUAL am2cmake.py)
2456             ELSE(f STREQUAL am2cmake.py)
2457             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2458             ENDIF(f STREQUAL am2cmake.py)
2459             ENDIF(f STREQUAL SALOME_ContainerPy.py)
2460             ''')
2461         else:
2462             newlines.append('''
2463             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2464             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_and_compile_python_file.cmake)
2465             ''')
2466             pass
2467         newlines.append(r'''
2468         ENDIF(ext STREQUAL .py)
2469         ''')
2470         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2471         return
2472
2473     def writeListsFile(self):
2474         f = open(self.listsFile, "w")
2475         f.write(self.content)
2476         f.close()
2477         return
2478
2479     def writeEnvScript(self, upmod, buildmod=True):
2480         import os, sys
2481         p_version = sys.version[:3]
2482         python_path = "PYTHONPATH"
2483         root_dir    = "%s_ROOT_DIR" % upmod
2484         if sys.platform == "win32":
2485             script_line = '@SET %(var)s=%(val)s;%%%(var)s%%\n'
2486             var_line    = '%%%s%%'
2487             lib_path = "PATH"
2488             omni = "x86_win32"
2489             omni_py = "python"
2490             pass
2491         else:
2492             script_line = 'export %(var)s=%(val)s:\$%(var)s\n'
2493             var_line    = '\${%s}'
2494             lib_path = "LD_LIBRARY_PATH"
2495             omni = ""
2496             omni_py = "/".join( ["python%s"%p_version , "site-packages"] )
2497             pass
2498         #
2499         script = ""
2500         #
2501         if buildmod:
2502             script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2503             script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "bin", "salome"] ) }
2504             script += script_line % { 'var':lib_path,    'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "salome"] ) }
2505             pass
2506         else:
2507             script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2508             script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "bin", "salome"] ) }
2509             script += script_line % { 'var':lib_path,    'val':"/".join( [var_line % root_dir, "lib", "salome"] ) }
2510             pass
2511         #
2512         if upmod == "KERNEL" :
2513             script += "\n"
2514             if omni:
2515                 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2516                 script += script_line % { 'var':lib_path,    'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2517                 pass
2518             else:
2519                 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2520                 script += script_line % { 'var':lib_path,    'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2521                 pass
2522             script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni_py] ) }
2523             pass
2524         #
2525         if upmod == "GEOM" :
2526             script = self.writeEnvScript("KERNEL", False) + "\n" + script
2527             script = self.writeEnvScript("GUI",    False) + "\n" + script
2528             pass
2529         #
2530         if upmod == "SMESH" :
2531             script = self.writeEnvScript("GEOM", False) + "\n" + script
2532             pass
2533
2534         return script
2535     pass
2536
2537 def convertAmFile(the_root, root, dirs, files, f, module):
2538     cmake = CMakeFile(the_root, root, dirs, files, f, module)
2539     cmake.writeListsFile()
2540     return
2541
2542 def usage(exit_status):
2543     from sys import exit
2544     from sys import argv
2545     print "Usage: %s --module"%(argv[0])
2546     exit(exit_status)
2547     return
2548
2549 if __name__ == "__main__":
2550     #
2551     from sys import argv
2552     if len(argv) != 2:
2553         usage(1)
2554         pass
2555     #
2556     module = argv[1]
2557     if module.find('--') != 0:
2558         usage(1)
2559         pass
2560     module = module[2:]
2561     if len(module) == 0:
2562         usage(1)
2563         pass
2564     #
2565     from os import getcwd
2566     the_root = getcwd()
2567     #
2568     nok = 0
2569     #
2570     from os import getenv
2571     from os import walk
2572     for root, dirs, files in walk(the_root):
2573         # --
2574         # E.A. : Remove 'CVS' in dirs
2575         # E.A. : It allows to not recurse in CVS dirs
2576         # E.A. : See os module python documentation
2577         # --
2578         try:
2579             dirs.remove('CVS')
2580         except ValueError:
2581             pass
2582         # --
2583         if "Makefile.am.cmake" in files:
2584             if "Makefile.am" in files:
2585                 files.remove("Makefile.am")
2586                 pass
2587             pass
2588         # --
2589         for f in files:
2590             if f in ["Makefile.am", "Makefile.am.cmake"]:
2591                 convert = True # convert files by default
2592                 forced = getenv("AM2CMAKE_FORCE_GENERATION", "0")=="1" or \
2593                          getenv("AM2CMAKE_FORCE_%s_GENERATION"%module.upper(), "0")=="1"
2594                 if not forced:
2595                     # detect if conversion should be done
2596                     if "CMakeLists.txt" in files:
2597                         from os.path import join
2598                         ff = open(join(root, "CMakeLists.txt"))
2599                         content = ff.read()
2600                         ff.close()
2601                         if content.find("generated by am2cmake") == -1:
2602                             convert = False
2603                             pass
2604                         pass
2605                     pass
2606                 if convert:
2607                     convertAmFile(the_root, root, dirs, files, f, module)
2608                     nok += 1
2609                 pass
2610             pass
2611         pass
2612     #
2613     from sys import stdout
2614     if nok:
2615         if nok == 1:
2616             msg = "%s file has been converted to cmake"%(nok)
2617         else:
2618             msg = "%s files have been converted to cmake"%(nok)
2619             pass
2620         stdout.write(msg)
2621         stdout.write("\n")
2622         stdout.flush()
2623         pass
2624     pass