salome_adm/cmake_files/deprecated/am2cmake.py

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