salome_adm/cmake_files/am2cmake.py

   1 #  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 #  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 #
   6 #  This library is free software; you can redistribute it and/or
   7 #  modify it under the terms of the GNU Lesser General Public
   8 #  License as published by the Free Software Foundation; either
   9 #  version 2.1 of the License.
  10 #
  11 #  This library is distributed in the hope that it will be useful,
  12 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 #  Lesser General Public License for more details.
  15 #
  16 #  You should have received a copy of the GNU Lesser General Public
  17 #  License along with this library; if not, write to the Free Software
  18 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 #
  20 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 #
  22 import re
  23
  24 # ----
  25 # A set of regular expressions used ...
  26 # ----
  27
  28 p_multiline = re.compile(r"""
  29 \\           # One backslash
  30 \s*          # 0 or more space
  31 \n           # One CR
  32 """, re.VERBOSE)
  33
  34 p_dollar = re.compile(r"""
  35 \$\(           # a $ then a (
  36 (?P<val>       # open the group val
  37 [^)]*          # the group contain 0 or more non ) characters
  38 )              # close the group
  39 \)             # a ) at the end
  40 """, re.VERBOSE)
  41
  42 p_arobas = re.compile(r"""
  43 @              # a @
  44 (?P<val>       # open the group val
  45 [^@]*            # the group contain 0 or more non @ characters
  46 )              # close the group
  47 @              # a @ at the end
  48 """, re.VERBOSE)
  49
  50 p_if = re.compile(r"""
  51 ^          # beginning of the string
  52 \s*        # 0 or more space
  53 if         # an if
  54 \s+        # 1 or more space
  55 (?P<val>   # open the group val
  56 [^\s]+     # the group contain 1 or more non space characters
  57 )          # close the group
  58 """, re.VERBOSE)
  59
  60 p_else = re.compile(r"""
  61 ^          # beginning of the line
  62 \s*        # 0 or more space
  63 else       #
  64 \s*        # 0 or more space
  65 """, re.VERBOSE)
  66
  67 p_endif = re.compile(r"""
  68 ^          # beginning of the line
  69 \s*        # 0 or more space
  70 endif      # a endif
  71 \s*        # 0 or more space
  72 """, re.VERBOSE)
  73
  74 p_attribution = re.compile(r"""
  75 ^              # beginning of the line
  76 (?P<spaces>    # open the group spaces
  77 \s*            # 0 or more space
  78 )              # close the group
  79 (?P<key>       # open the group key
  80 \w+            # the group contain 1 or more alphanumeric characters
  81 )              # close the group
  82 \s*            # 0 or more space
  83 (?P<method>    # open the group method
  84 \+?            # 0 or 1 +
  85 =              # One =
  86 )              # close the group
  87 (?P<value>     # open the group value
  88 .*             # 0 or more any characters
  89 )              # close the group
  90 """, re.VERBOSE)
  91
  92 # -----
  93
  94 class CMakeFile(object):
  95
  96     def __init__(self, the_root, root, dirs, files, f, module):
  97         #
  98         self.the_root = the_root
  99         self.root = root
 100         self.dirs = dirs
 101         self.files = files
 102         self.module = module
 103         #
 104         from os.path import join
 105         self.amFile = join(root, f)
 106         self.listsFile = join(root, "CMakeLists.txt")
 107         #
 108         self.parseFile()
 109         #
 110         return
 111
 112     def parseFile(self):
 113
 114         # --
 115         # Read the Makefile.am file
 116         # --
 117         amFile = self.amFile
 118         stream = open(amFile)
 119         content = stream.read()
 120         stream.close()
 121
 122         # --
 123         # Replace the composed lines separated by "\\n" by an unique line
 124         # --
 125         content = p_multiline.sub(r' ', content)
 126
 127         # --
 128         # Compatibility netgen plugin
 129         # --
 130         content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
 131
 132         # --
 133         cas_list = [
 134             "BinLPlugin",
 135             "BinPlugin",
 136             "BinTObjPlugin",
 137             "BinXCAFPlugin",
 138             "FWOSPlugin",
 139             "PTKernel",
 140             "StdLPlugin",
 141             "StdPlugin",
 142             "TKAdvTools",
 143             "TKBin",
 144             "TKBinL",
 145             "TKBinTObj",
 146             "TKBinXCAF",
 147             "TKBO",
 148             "TKBool",
 149             "TKBRep",
 150             "TKCAF",
 151             "TKCDF",
 152             "TKernel",
 153             "TKFeat",
 154             "TKFillet",
 155             "TKG2d",
 156             "TKG3d",
 157             "TKGeomAlgo",
 158             "TKGeomBase",
 159             "TKHLR",
 160             "TKIGES",
 161             "TKLCAF",
 162             "TKMath",
 163             "TKMesh",
 164             "TKMeshVS",
 165             "TKNIS",
 166             "TKOffset",
 167             "TKOpenGl",
 168             "TKPCAF",
 169             "TKPLCAF",
 170             "TKPrim",
 171             "TKPShape",
 172             "TKService",
 173             "TKShapeSchema",
 174             "TKShHealing",
 175             "TKStdLSchema",
 176             "TKStdSchema",
 177             "TKSTEP",
 178             "TKSTEP209",
 179             "TKSTEPAttr",
 180             "TKSTEPBase",
 181             "TKSTL",
 182             "TKTObj",
 183             "TKTopAlgo",
 184             "TKV2d",
 185             "TKV3d",
 186             "TKVRML",
 187             "TKXCAF",
 188             "TKXCAFSchema",
 189             "TKXDEIGES",
 190             "TKXDESTEP",
 191             "TKXMesh",
 192             "TKXml",
 193             "TKXmlL",
 194             "TKXmlTObj",
 195             "TKXmlXCAF",
 196             "TKXSBase",
 197             "XCAFPlugin",
 198             "XmlLPlugin",
 199             "XmlPlugin",
 200             "XmlTObjPlugin",
 201             "XmlXCAFPlugin",
 202             ]
 203         vtk_list = [
 204             "vtkCommonPythonD",
 205             "vtkGraphicsPythonD",
 206             "vtkImagingPythonD",
 207             ]
 208         kernel_list  = [
 209             "DF",
 210             "Launcher",
 211             "OpUtil",
 212             "Registry",
 213             "ResourcesManager",
 214             "SALOMEBasics",
 215             "SalomeBatch",
 216             "SalomeCatalog",
 217             "SalomeCommunication",
 218             "SalomeContainer",
 219             "SalomeDSCContainer",
 220             "SalomeDSClient",
 221             "SalomeDSImpl",
 222             "SalomeDS",
 223             "SalomeGenericObj",
 224             "SalomeHDFPersist",
 225             "SalomeIDLKernel",
 226             "SalomeLauncher",
 227             "SalomeLifeCycleCORBA",
 228             "SALOMELocalTrace",
 229             "SalomeLoggerServer",
 230             "SalomeNotification",
 231             "SalomeNS",
 232             "SalomeResourcesManager",
 233             "TOOLSDS",
 234             "with_loggerTraceCollector",
 235             ]
 236         gui_list = [
 237             "caf",
 238             "CAM",
 239             "CASCatch",
 240             "DDS",
 241             "Event",
 242             "GLViewer",
 243             "LightApp",
 244             "LogWindow",
 245             "ObjBrowser",
 246             "OCCViewer",
 247             "Plot2d",
 248             "PyConsole",
 249             "PyInterp",
 250             "QDS",
 251             "qtx",
 252             "QxScene",
 253             "SalomeApp",
 254             "SalomeIDLGUI",
 255             "SalomeObject",
 256             "SalomePrs",
 257             "SalomeSession",
 258             "SalomeStyle",
 259             "SOCC",
 260             "SPlot2d",
 261             "std",
 262             "SUITApp",
 263             "suit",
 264             "SUPERVGraph",
 265             "SVTK",
 266             "ToolsGUI",
 267             "VTKViewer",
 268             ]
 269         geom_list = [
 270             "BasicGUI",
 271             "BlocksGUI",
 272             "BooleanGUI",
 273             "BREPExport",
 274             "BREPImport",
 275             "BuildGUI",
 276             "DisplayGUI",
 277             "DlgRef",
 278             "EntityGUI",
 279             "GenerationGUI",
 280             "GEOMAlgo",
 281             "GEOMArchimede",
 282             "GEOMBase",
 283             "GEOMbasic",
 284             "GEOMClient",
 285             "GEOMEngine",
 286             "GEOMFiltersSelection",
 287             "GEOMimpl",
 288             "GEOMObject",
 289             "GEOMSketcher",
 290             "GEOM",
 291             "GEOM_SupervEngine",
 292             "GEOMToolsGUI",
 293             "GroupGUI",
 294             "IGESExport",
 295             "IGESImport",
 296             "MeasureGUI",
 297             "NMTDS",
 298             "NMTTools",
 299             "OperationGUI",
 300             "PrimitiveGUI",
 301             "RepairGUI",
 302             "SalomeIDLGEOM",
 303             "ShHealOper",
 304             "STEPExport",
 305             "STEPImport",
 306             "STLExport",
 307             "TransformationGUI",
 308             ]
 309         med_list = [
 310             "InterpGeometric2DAlg",
 311             "interpkernelbases",
 312             "interpkernel",
 313             "MEDClientcmodule",
 314             "medcoupling",
 315             "MEDEngine",
 316             "MEDMEMImpl",
 317             "medmem",
 318             "MED",
 319             "med_V2_1",
 320             "MEDWrapperBase",
 321             "MEDWrapper",
 322             "MEDWrapper_V2_1",
 323             "MEDWrapper_V2_2",
 324             "SalomeIDLMED",
 325             ]
 326         smesh_list = [
 327             "MEFISTO2D",
 328             "MeshDriverDAT",
 329             "MeshDriverMED",
 330             "MeshDriver",
 331             "MeshDriverSTL",
 332             "MeshDriverUNV",
 333             "SalomeIDLSMESH",
 334             "SMDS",
 335             "SMESHClient",
 336             "SMESHControls",
 337             "SMESHDS",
 338             "SMESHEngine",
 339             "SMESHFiltersSelection",
 340             "SMESHimpl",
 341             "SMESHObject",
 342             "SMESH",
 343             "StdMeshersEngine",
 344             "StdMeshersGUI",
 345             "StdMeshers",
 346             ]
 347         full_list  = cas_list + vtk_list
 348         full_list += kernel_list + gui_list
 349         full_list += geom_list + med_list + smesh_list
 350         # --
 351         # E.A. : sort by len before substitution ...
 352         # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 353         # And you understand ...
 354         # --
 355         full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 356         # --
 357         for key in full_list:
 358             content = content.replace("-l%s"%(key), "${%s}"%(key))
 359             pass
 360
 361         # --
 362         # Split content in lines to treat each one separately
 363         # --
 364         lines = content.split('\n')
 365
 366         # --
 367         # newlines contains the lines of the future CMakeLists.txt file
 368         # --
 369         newlines = []
 370
 371         # --
 372         # opened_ifs is used to deals with nested conditionnals
 373         # --
 374         opened_ifs = []
 375
 376         # --
 377         # the __thedict__ dictionnary contains key, val
 378         # of the Makefile.am file
 379         # --
 380         self.__thedict__ = {}
 381
 382         # --
 383         # Initialize file ... mainly includes other cmake files
 384         # --
 385         self.initialize(newlines)
 386
 387         # --
 388         # Do the job for each line
 389         # --
 390         for line in lines:
 391             self.treatLine(line, newlines, opened_ifs)
 392             pass
 393
 394         # --
 395         # Finalize file ... it is in here the cmake job is done
 396         # --
 397         self.finalize(newlines)
 398
 399         # --
 400         # Concatenate newlines into content
 401         # --
 402         content = '\n'.join(newlines)
 403
 404         # --
 405         # Add a CR at end if necessary
 406         # --
 407         lines = content.split('\n')
 408         # lines = [ l.strip() for l in lines ]
 409         if len(lines[-1]) != 0:
 410             lines.append('')
 411             pass
 412         content = '\n'.join(lines)
 413
 414         # --
 415         self.content = content
 416
 417         # --
 418         return
 419
 420     def initialize(self, newlines):
 421         if self.root == self.the_root:
 422             # --
 423             newlines.append("""
 424             CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
 425             IF(COMMAND cmake_policy)
 426             cmake_policy(SET CMP0003 NEW)
 427             ENDIF(COMMAND cmake_policy)
 428             """)
 429             # --
 430             if self.module == "kernel":
 431                 newlines.append("""
 432                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 433                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 434                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 435                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 436                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 437                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 438                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 439                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 440                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 441                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 442                 SET(DOXYGEN_IS_OK 0)
 443                 """)
 444                 pass
 445             else:
 446                 newlines.append("""
 447                 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 448                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 449                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 450                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 451                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 452                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 453                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 454                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 455                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 456                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 457                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 458                 SET(DOXYGEN_IS_OK 0)
 459                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 460                 """)
 461                 if self.module == "gui":
 462                     newlines.append("""
 463                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 464                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 465                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 466                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 467                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 468                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 469                     """)
 470                 else:
 471                     newlines.append("""
 472                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 473                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 474                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 475                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 476                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 477                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 478                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 479                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 480                     """)
 481                     if self.module == "med":
 482                         newlines.append("""
 483                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 484                         """)
 485                         pass
 486                     if self.module == "smesh":
 487                         newlines.append("""
 488                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 489                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 490                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 491                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 492                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 493                         """)
 494                         pass
 495                     if self.module == "netgenplugin":
 496                         newlines.append("""
 497                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 498                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 499                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 500                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 501                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 502                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 503                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 504                         """)
 505                         pass
 506                     if self.module == "blsurfplugin":
 507                         newlines.append("""
 508                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 509                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 510                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 511                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 512                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 513                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 514                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 515                         """)
 516                         pass
 517                     if self.module == "hexoticplugin":
 518                         newlines.append("""
 519                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 520                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 521                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 522                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 523                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 524                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 525                         """)
 526                         pass
 527                     if self.module == "ghs3dplugin":
 528                         newlines.append("""
 529                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 530                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 531                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 532                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 533                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 534                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 535                         """)
 536                         pass
 537                     if self.module == "visu":
 538                         newlines.append("""
 539                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 540                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 541                         """)
 542                         pass
 543                     if self.module == "yacs":
 544                         newlines.append("""
 545                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 546                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 547                         """)
 548                         pass
 549                     pass
 550                 pass
 551             # --
 552             if self.module == "kernel":
 553                 newlines.append("""
 554                 SET(WITH_LOCAL 1)
 555                 SET(WITH_BATCH 1)
 556                 set(VERSION 5.1.2)
 557                 set(XVERSION 0x050102)
 558                 SET(CALCIUM_IDL_INT_F77 long)
 559                 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 560                 SET(LONG_OR_INT int)
 561                 """)
 562             elif self.module == "gui":
 563                 newlines.append("""
 564                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 565                 SET(ENABLE_VTKVIEWER ON)
 566                 SET(ENABLE_SALOMEOBJECT ON)
 567                 SET(ENABLE_OCCVIEWER ON)
 568                 SET(ENABLE_GLVIEWER ON)
 569                 SET(ENABLE_PLOT2DVIEWER ON)
 570                 SET(ENABLE_PYCONSOLE ON)
 571                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 572                 SET(ENABLE_QXGRAPHVIEWER ON)
 573                 set(VERSION 5.1.2)
 574                 set(XVERSION 0x050102)
 575                 """)
 576                 pass
 577             elif self.module == "geom":
 578                 newlines.append("""
 579                 SET(GEOM_ENABLE_GUI ON)
 580                 """)
 581                 pass
 582             elif self.module == "medfile":
 583                 newlines.append("""
 584                 SET(MED_NUM_MAJEUR 2)
 585                 SET(MED_NUM_MINEUR 3)
 586                 SET(MED_NUM_RELEASE 5)
 587                 SET(LONG_OR_INT int)
 588                 IF(NOT WINDOWS)
 589                 SET(FLIBS -lgfortranbegin -lgfortran)
 590                 ENDIF(NOT WINDOWS)
 591                 """)
 592                 pass
 593             elif self.module == "med":
 594                 newlines.append("""
 595                 SET(MED_ENABLE_KERNEL ON)
 596                 IF(NOT WINDOWS)
 597                 SET(MED_ENABLE_SPLITTER ON)
 598                 ENDIF(NOT WINDOWS)
 599                 SET(MED_ENABLE_GUI ON)
 600                 """)
 601                 pass
 602             elif self.module == "smesh":
 603                 newlines.append("""
 604                 SET(SMESH_ENABLE_GUI ON)
 605                 """)
 606                 pass
 607             elif self.module == "netgenplugin":
 608                 newlines.append("""
 609                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 610                 """)
 611                 pass
 612             elif self.module == "blsurfplugin":
 613                 newlines.append("""
 614                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 615                 """)
 616                 pass
 617             elif self.module == "ghs3dplugin":
 618                 newlines.append("""
 619                 SET(GHS3DPLUGIN_ENABLE_GUI ON)
 620                 """)
 621                 pass
 622             elif self.module == "yacs":
 623                 newlines.append("""
 624                 SET(SALOME_KERNEL ON)
 625                 SET(HAS_GUI ON)
 626                 """)
 627                 pass
 628             # --
 629             pass
 630         # --
 631         newlines.append("""
 632         SET(VERSION_INFO 0.0.0)
 633         SET(SOVERSION_INFO 0)
 634         SET(SUBDIRS)
 635         SET(AM_CPPFLAGS)
 636         SET(AM_CXXFLAGS)
 637         SET(LDADD)
 638         """)
 639         if self.module == "kernel":
 640             newlines.append(r'''
 641             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 642             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 643             ''')
 644         else:
 645             if self.module not in ["yacs"]:
 646                 newlines.append(r'''
 647                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 648                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 649                 ''')
 650                 pass
 651             pass
 652         # --
 653         return
 654
 655     def treatLine(self, line, newlines, opened_ifs):
 656
 657         # --
 658         # Print the comment above the line itself
 659         # --
 660         if line.find('#') >= 0:
 661             fields = line.split('#')
 662             line = fields[0]
 663             comment = '#'.join([''] + fields[1:])
 664             newlines.append(comment)
 665             if len(line) == 0:
 666                 return
 667             pass
 668
 669         # --
 670         # If the line begins with 'include ', just comment it
 671         # --
 672         if line.find("include ") == 0:
 673             newlines.append("# " + line)
 674             return
 675
 676         # --
 677         # If the line begins with '-include', just comment it
 678         # --
 679         if line.find("-include") == 0:
 680             newlines.append("# " + line)
 681             return
 682
 683         # --
 684         # If the line is a definition of a make rule, just comment it
 685         # --
 686         if line.count(':') == 1:
 687             newlines.append("# " + line)
 688             return
 689
 690         # --
 691         # A particuliar case where there are two ":" on the same line
 692         # --
 693         if line.find('install-exec-local:') == 0:
 694             newlines.append("# " + line)
 695             return
 696
 697         # --
 698         # If the line begin by a tabulation, consider it's a makefile command and comment it
 699         # --
 700         if line.find("\t") == 0:
 701             newlines.append("# " + line)
 702             return
 703
 704         # --
 705         # --
 706         key = "-version-info"
 707         if line.find(key) >= 0:
 708             # --
 709             before = line.split(key)[0]
 710             after = line[len(before)+len(key):]
 711             sep = after[0]
 712             after = after[1:]
 713             version_info = after.split()[0]
 714             line = line.replace(key+sep+version_info, "")
 715             # --
 716             version_info = version_info.replace(':', '.')
 717             soversion_info = version_info.split('.')[0]
 718             newlines.append("SET(VERSION_INFO " + version_info + ")")
 719             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 720             # --
 721             pass
 722
 723         # --
 724         # Replace the $(TOTO) by ${TOTO}
 725         # Replace the @TOTO@  by ${TOTO}
 726         # --
 727         line = p_dollar.sub(r"${\1}", line)
 728         line = p_arobas.sub(r"${\1}", line)
 729
 730         # --
 731         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 732         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 733         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 734         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 735         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 736
 737         # --
 738         # Check if the line is a 'if' condition
 739         # If yes, replace it by a cmake grammar
 740         # --
 741         match = p_if.match(line)
 742         if match:
 743             theif = match.group("val")
 744             if theif[0] == "!":
 745                 theif = "NOT " + theif[1:]
 746                 pass
 747             line = p_if.sub(r"IF(%s)"%(theif), line)
 748             opened_ifs.append(theif)
 749             newlines.append(line)
 750             return
 751
 752         # --
 753         # Check if the line is a 'else' condition
 754         # If yes, replace it by a cmake grammar
 755         # --
 756         match = p_else.match(line)
 757         if match:
 758             line = "ELSE(%s)"%(opened_ifs[-1])
 759             newlines.append(line)
 760             return
 761
 762         # --
 763         # Check if the line is a 'endif' condition
 764         # If yes, replace it by a cmake grammar
 765         # --
 766         match = p_endif.match(line)
 767         if match:
 768             line = "ENDIF(%s)"%(opened_ifs[-1])
 769             opened_ifs[-1:] = []
 770             newlines.append(line)
 771             return
 772
 773         # --
 774         # Check if the line is an attribution '=' or '+='
 775         # --
 776         match = p_attribution.match(line)
 777         if match:
 778             self.treatAttribution(match, newlines)
 779             return
 780
 781         # --
 782         newlines.append(line)
 783
 784         # --
 785         return
 786
 787     def treatAttribution(self, match, newlines):
 788
 789         spaces = match.group("spaces")
 790         key = match.group("key")
 791         method = match.group("method")
 792         value = match.group("value")
 793         # print [spaces, key, method, value]
 794
 795         # --
 796         # Open cmake SET command
 797         # --
 798         newlines.append(spaces + "SET(" + key)
 799
 800         # --
 801         # If method is '+=', put the previous definition as first value
 802         # --
 803         if method == "+=":
 804             newlines.append("%s    ${%s}"%(spaces, key))
 805             pass
 806
 807         # --
 808         fields = value.split()
 809         for i in range(len(fields)):
 810             newlines.append("%s    %s"%(spaces, fields[i]))
 811             pass
 812
 813         # --
 814         if method == "+=":
 815             # --
 816             # The try: except KeyError is here if the +=
 817             # is an error which occurs in salome ...
 818             # --
 819             try:
 820                 self.__thedict__[key] += fields[:]
 821             except KeyError:
 822                 self.__thedict__[key] = fields[:]
 823                 pass
 824             pass
 825         else:
 826             self.__thedict__[key]  = fields[:]
 827             pass
 828
 829         # --
 830         # Close cmake SET command
 831         # --
 832
 833         newlines.append("%s)"%(spaces))
 834
 835         return
 836
 837     def finalize(self, newlines):
 838
 839         # --
 840         # Convert the .in files in build dir
 841         # --
 842         if self.module == "yacs":
 843             key = "salomegui"
 844             if self.root[-len(key):] == key:
 845                 self.files.append("resources/YACSCatalog.xml.in")
 846                 pass
 847             pass
 848         for f in self.files:
 849             if f[-3:] == ".in":
 850                 if f == "sstream.in":
 851                     continue
 852                 if f in ["runContainer.in", "stopContainer.in"]:
 853                     if self.module == "med":
 854                         if self.root[-3:] == "csh":
 855                             continue
 856                         pass
 857                     pass
 858                 if f == "SALOMEconfig.ref.in":
 859                     out = "SALOMEconfig.h"
 860                 else:
 861                     out = f[:-3]
 862                     pass
 863                 newlines.append(r'''
 864                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 865                 '''%(f))
 866                 newlines.append(r'''
 867                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 868                 '''%(out))
 869                 newlines.append(r'''
 870                 MESSAGE(STATUS "Creation of ${output}")
 871                 CONFIGURE_FILE(${input} ${output})
 872                 ''')
 873                 pass
 874             pass
 875
 876         # --
 877         # convert the SUBDIRS in cmake grammar
 878         # --
 879         if 1: # self.__thedict__.has_key("SUBDIRS"):
 880             newlines.append(r'''
 881             FOREACH(dir ${SUBDIRS})
 882             IF(NOT dir STREQUAL .)
 883             ADD_SUBDIRECTORY(${dir})
 884             ENDIF(NOT dir STREQUAL .)
 885             ENDFOREACH(dir ${SUBDIRS})
 886             ''')
 887             pass
 888
 889         # --
 890         # --
 891         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 892             if self.__thedict__.has_key(key):
 893                 self.addLibTarget(key, newlines)
 894                 pass
 895             pass
 896
 897         # --
 898         # --
 899         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
 900             if self.__thedict__.has_key(key):
 901                 self.addBinTarget(key, newlines)
 902                 pass
 903             pass
 904
 905         # --
 906         # --
 907         if self.__thedict__.has_key("BASEIDL_FILES"):
 908             if not self.__thedict__.has_key("IDL_FILES"):
 909                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 910                 newlines.append('''
 911                 SET(IDL_FILES ${BASEIDL_FILES})
 912                 ''')
 913                 pass
 914             pass
 915
 916         # --
 917         # --
 918
 919         key = "IDL_FILES"
 920         if self.__thedict__.has_key(key):
 921             if self.module == "kernel":
 922                 newlines.append('''
 923                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
 924                 ''')
 925                 pass
 926             newlines.append('''
 927             FOREACH(input ${IDL_FILES})
 928             STRING(REGEX REPLACE ".idl" "" base ${input})
 929             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 930             SET(outputs ${src})
 931             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 932             SET(outputs ${outputs} ${dynsrc})
 933             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 934             SET(outputs ${outputs} ${inc})
 935             IF(input STREQUAL Calcium_Ports.idl)
 936             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
 937             ELSE(input STREQUAL Calcium_Ports.idl)
 938             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 939             ENDIF(input STREQUAL Calcium_Ports.idl)
 940             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
 941             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
 942             IF(NOT ISBCXX)
 943             SET(flags -bcxx ${flags})
 944             ENDIF(NOT ISBCXX)
 945             ADD_CUSTOM_COMMAND(
 946             OUTPUT ${outputs}
 947             COMMAND ${OMNIORB_IDL} ${flags} ${input}
 948             MAIN_DEPENDENCY ${input}
 949             )
 950             install(FILES ${input} DESTINATION idl/salome)
 951             SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 952             install(FILES ${IDL_HEADER} DESTINATION include/salome)
 953             INSTALL(CODE "SET(IDL_FILE ${input})")
 954             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 955             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 956             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 957             # --
 958             SET(flags)
 959             FOREACH(f ${IDLPYFLAGS})
 960             SET(flags "${flags} ${f}")
 961             ENDFOREACH(f ${IDLPYFLAGS})
 962             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
 963             IF(NOT ISBPYTHON)
 964             SET(flags "-bpython ${flags}")
 965             ENDIF(NOT ISBPYTHON)
 966             SET(IDLPYFLAGS ${flags})
 967             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 968             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 969             # --
 970             ''')
 971             if self.module == "kernel":
 972                 newlines.append('''
 973                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 974                 ''')
 975             else:
 976                 newlines.append('''
 977                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 978                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 979                 ''')
 980                 pass
 981             newlines.append('''
 982             ENDFOREACH(input ${IDL_FILES})
 983             ''')
 984             pass
 985
 986         # --
 987         # --
 988         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
 989             if self.__thedict__.has_key(key):
 990                 newlines.append('''
 991                 SET(SWIG_SOURCES ${%s})
 992                 '''%(key))
 993                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
 994                 pass
 995             pass
 996
 997         # --
 998         # --
 999         if self.__thedict__.has_key("SWIG_SOURCES"):
1000             newlines.append('''
1001             IF(SWIG_SOURCES MATCHES ";")
1002             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1003             ELSE(SWIG_SOURCES MATCHES ";")
1004             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1005             ENDIF(SWIG_SOURCES MATCHES ";")
1006             ADD_CUSTOM_COMMAND(
1007             OUTPUT ${build_srcs}
1008             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1009             MAIN_DEPENDENCY ${SWIG_SOURCES}
1010             )
1011             ''')
1012             pass
1013
1014         # --
1015         # --
1016         if self.__thedict__.has_key("BUILT_SOURCES"):
1017             newlines.append('''
1018             FOREACH(f ${BUILT_SOURCES})
1019             IF(f MATCHES "WRAP.cxx$")
1020             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1021             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1022             ADD_CUSTOM_COMMAND(
1023             OUTPUT ${f} # ${inc}
1024             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1025             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1026             )
1027             ENDIF(f MATCHES "WRAP.cxx$")
1028             ENDFOREACH(f ${BUILT_SOURCES})
1029             ''')
1030             pass
1031
1032         # --
1033         # --
1034         key = "MOC_FILES"
1035         if self.__thedict__.has_key(key):
1036             newlines.append('''
1037             FOREACH(output ${MOC_FILES})
1038             ''')
1039             if self.module == "yacs":
1040                 newlines.append('''
1041                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1042                 ''')
1043             else:
1044                 newlines.append('''
1045                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1046                 ''')
1047                 pass
1048             newlines.append('''
1049             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1050             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1051             ADD_CUSTOM_COMMAND(
1052             OUTPUT ${output}
1053             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1054             MAIN_DEPENDENCY ${input}
1055             )
1056             ENDFOREACH(output ${MOC_FILES})
1057             ''')
1058             pass
1059
1060         # --
1061         # --
1062         key = "UIC_FILES"
1063         if self.__thedict__.has_key(key):
1064             newlines.append('''
1065             FOREACH(output ${UIC_FILES})
1066             STRING(REPLACE "ui_" "" input ${output})
1067             STRING(REPLACE ".h" ".ui" input ${input})
1068             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1069             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1070             ADD_CUSTOM_COMMAND(
1071             OUTPUT ${output}
1072             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1073             MAIN_DEPENDENCY ${input}
1074             )
1075             ENDFOREACH(output ${UIC_FILES})
1076             ''')
1077             pass
1078
1079         # --
1080         # --
1081         key = "QRC_FILES"
1082         if self.__thedict__.has_key(key):
1083             newlines.append('''
1084             FOREACH(output ${QRC_FILES})
1085             STRING(REGEX REPLACE "qrc_" "" input ${output})
1086             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1087             STRING(REGEX REPLACE ".qrc" "" name ${input})
1088             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1089             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1090             ADD_CUSTOM_COMMAND(
1091             OUTPUT ${output}
1092             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1093             MAIN_DEPENDENCY ${input}
1094             )
1095             ENDFOREACH(output ${QRC_FILES})
1096             ''')
1097             pass
1098
1099         # --
1100         # --
1101         key = "SIP_FILES"
1102         if self.__thedict__.has_key(key):
1103             newlines.append('''
1104             FOREACH(input ${SIP_FILES})
1105             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1106             SET(output)
1107             FOREACH(out ${SIP_SRC})
1108             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1109             ENDFOREACH(out ${SIP_SRC})
1110             ADD_CUSTOM_COMMAND(
1111             OUTPUT ${output}
1112             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1113             MAIN_DEPENDENCY ${input}
1114             )
1115             ENDFOREACH(input ${SIP_FILES})
1116             ''')
1117             pass
1118
1119         # --
1120         # Treat the install targets
1121         # --
1122         d = {
1123             "salomeadmux_DATA"            :  "salome_adm/unix",
1124             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1125             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1126             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1127             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1128             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1129             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1130             "salomeinclude_DATA"          :  "include/salome",
1131             "salomeinclude_HEADERS"       :  "include/salome",
1132             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1133             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1134             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1135             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1136             "dist_salomescript_DATA"      :  "bin/salome",
1137             "dist_salomescript_PYTHON"    :  "bin/salome",
1138             "nodist_salomescript_DATA"    :  "bin/salome",
1139             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1140             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1141             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1142             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1143             }
1144         if self.module == "medfile":
1145             d = {
1146                 "include_HEADERS"        :  "include",
1147                 "nodist_include_HEADERS" :  "include",
1148                 "bin_SCRIPTS"            :  "bin",
1149                 "doc_DATA"               :  "${docdir}",
1150                 }
1151             pass
1152         for key, value in d.items():
1153             if self.__thedict__.has_key(key):
1154                 self.addInstallTarget(key, value, newlines)
1155                 pass
1156             pass
1157
1158         # --
1159         return
1160
1161     def setLibAdd(self, key, newlines):
1162         # --
1163         newlines.append(r'''
1164         SET(libadd)
1165         ''')
1166         # --
1167         newlines.append(r'''
1168         IF(WINDOWS)
1169         SET(targets)
1170         SET(targets ${targets} MEFISTO2D)
1171         FOREACH(target ${targets})
1172         IF(name STREQUAL ${target})
1173         SET(dir $ENV{F2CHOME})
1174         STRING(REPLACE "\\\\" "/" dir ${dir})
1175         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1176         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1177         ENDIF(name STREQUAL ${target})
1178         ENDFOREACH(target ${targets})
1179         ENDIF(WINDOWS)
1180         ''')
1181         # --
1182         newlines.append(r'''
1183         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1184         FOREACH(lib SALOMEBasics SalomeBatch)
1185         IF(name STREQUAL lib)
1186         SET(libs ${libs} ${PTHREAD_LIBS})
1187         ENDIF(name STREQUAL lib)
1188         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1189         ''')
1190         if key == "bin_PROGRAMS":
1191             newlines.append(r'''
1192             SET(libs ${libs} ${LDADD})
1193             ''')
1194             pass
1195         # --
1196         newlines.append(r'''
1197         FOREACH(lib ${libs})
1198         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1199         IF(ext STREQUAL .la)
1200         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1201         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1202         ENDIF(ext STREQUAL .la)
1203         SET(vars)
1204         SET(vars ${vars} -no-undefined)
1205         SET(vars ${vars} -lvtkWidgets)
1206         IF(WINDOWS)
1207         SET(vars ${vars} -module)
1208         SET(vars ${vars} -Wl,-E)
1209         SET(vars ${vars} -Xlinker)
1210         SET(vars ${vars} -export-dynamic)
1211         SET(vars ${vars} -lm)
1212         SET(vars ${vars} -lboost_thread)
1213         SET(vars ${vars} -lboost_signals)
1214         SET(vars ${vars} -pthread -lpthread -ldl)
1215         ENDIF(WINDOWS)
1216         FOREACH(v ${vars})
1217         IF(lib STREQUAL v)
1218         SET(lib)
1219         ENDIF(lib STREQUAL v)
1220         ENDFOREACH(v ${vars})
1221         SET(libadd ${libadd} ${lib})
1222         ENDFOREACH(lib ${libs})
1223         TARGET_LINK_LIBRARIES(${name} ${libadd})
1224         ''')
1225         # --
1226         newlines.append(r'''
1227         IF(WINDOWS)
1228         SET(targets)
1229         SET(targets ${targets} MEFISTO2D)
1230         FOREACH(target ${targets})
1231         IF(name STREQUAL ${target})
1232         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1233         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1234         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1235         ENDIF(name STREQUAL ${target})
1236         ENDFOREACH(target ${targets})
1237         ENDIF(WINDOWS)
1238         ''')
1239         # --
1240         return
1241
1242     def setCompilationFlags(self, key, newlines):
1243         newlines.append(r'''
1244         SET(var)
1245         IF(WINDOWS)
1246         SET(targets)
1247         SET(targets ${targets} SalomeIDLKernel)
1248         SET(targets ${targets} SalomeDS)
1249         SET(targets ${targets} SALOMEDSTest)
1250         SET(targets ${targets} SALOMEDS_Client_exe)
1251         SET(targets ${targets} SalomeIDLGEOM)
1252         SET(targets ${targets} GEOMEngine)
1253         SET(targets ${targets} MEDEngine)
1254         SET(targets ${targets} SMESHEngine)
1255         SET(targets ${targets} SMESH)
1256         FOREACH(target ${targets})
1257         IF(name STREQUAL ${target})
1258         SET(var ${var} -DNOGDI)
1259         ENDIF(name STREQUAL ${target})
1260         ENDFOREACH(target ${targets})
1261         ENDIF(WINDOWS)
1262         ''')
1263         # --
1264         if self.module in ["medfile", "yacs"]:
1265             newlines.append(r'''
1266             IF(WINDOWS)
1267             SET(var ${var} -DNOGDI)
1268             ENDIF(WINDOWS)
1269             ''')
1270             pass
1271         # --
1272         newlines.append(r'''
1273         IF(WINDOWS)
1274         SET(targets)
1275         SET(targets ${targets} MEFISTO2D)
1276         FOREACH(target ${targets})
1277         IF(name STREQUAL ${target})
1278         SET(dir $ENV{F2CHOME})
1279         STRING(REPLACE "\\\\" "/" dir ${dir})
1280         SET(var ${var} -I${dir})
1281         SET(var ${var} -DF2C_BUILD)
1282         ENDIF(name STREQUAL ${target})
1283         ENDFOREACH(target ${targets})
1284         ENDIF(WINDOWS)
1285         ''')
1286         # --
1287         if self.module in ["geom", "med"]:
1288             newlines.append(r'''
1289             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1290             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1291             ''')
1292             pass
1293         newlines.append(r'''
1294         SET(var ${var} ${AM_CPPFLAGS})
1295         SET(var ${var} ${AM_CXXFLAGS})
1296         ''')
1297         if self.module == "yacs":
1298             newlines.append(r'''
1299             SET(var ${var} -DYACS_PTHREAD)
1300             SET(var ${var} -DCMAKE_BUILD)
1301             SET(var ${var} -DSALOME_KERNEL)
1302             SET(var ${var} -DDSC_PORTS)
1303             SET(var ${var} -DOMNIORB)
1304             ''')
1305             pass
1306         newlines.append(r'''
1307         SET(var ${var} ${PLATFORM_CPPFLAGS})
1308         SET(var ${var} ${PTHREAD_CFLAGS})
1309         SET(var ${var} ${${amname}_CPPFLAGS})
1310         SET(var ${var} ${${amname}_CXXFLAGS})
1311         SET(var ${var} ${${amname}_CFLAGS})
1312         SET(vars)
1313         IF(WINDOWS)
1314         SET(vars ${vars} -include SALOMEconfig.h)
1315         SET(vars ${vars} -ftemplate-depth-32)
1316         SET(vars ${vars} -fPIC)
1317         SET(vars ${vars} -g)
1318         ENDIF(WINDOWS)
1319         SET(flags)
1320         FOREACH(f ${var})
1321         FOREACH(v ${vars})
1322         IF(f STREQUAL v)
1323         SET(f)
1324         ENDIF(f STREQUAL v)
1325         ENDFOREACH(v ${vars})
1326         SET(flags "${flags} ${f}")
1327         ENDFOREACH(f ${var})
1328         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1329         ''')
1330         return
1331
1332     def addLibTarget(self, key, newlines):
1333         newlines.append(r'''
1334         FOREACH(amname ${%s})
1335         '''%(key))
1336         # --
1337         # Replace .la by _la ...
1338         # --
1339         newlines.append(r'''
1340         STRING(REPLACE .la _la amname ${amname})
1341         ''')
1342         # --
1343         # Remove the _la for the cmake name
1344         # --
1345         newlines.append(r'''
1346         STRING(LENGTH ${amname} len)
1347         MATH(EXPR newlen "${len}-3")
1348         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1349         ''')
1350         # --
1351         # Does the target begins with lib ??
1352         # If yes, remove lib at beginning for cmake name
1353         # --
1354         newlines.append(r'''
1355         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1356         IF(BEGIN_WITH_lib)
1357         STRING(LENGTH ${name} len)
1358         MATH(EXPR newlen "${len}-3")
1359         STRING(SUBSTRING ${name} 3 ${newlen} name)
1360         ENDIF(BEGIN_WITH_lib)
1361         ''')
1362         # --
1363         # Does the target is an idl library
1364         # --
1365         newlines.append(r'''
1366         STRING(REGEX MATCH "IDL" ISIDL ${name})
1367         ''')
1368         # --
1369         # Set the type of the library
1370         # --
1371         newlines.append(r'''
1372         IF(ISIDL)
1373         IF(WINDOWS)
1374         SET(type STATIC)
1375         ELSE(WINDOWS)
1376         SET(type SHARED)
1377         ENDIF(WINDOWS)
1378         ELSE(ISIDL)
1379         SET(type SHARED)
1380         ENDIF(ISIDL)
1381         ''')
1382         # --
1383         # Set sources for the library
1384         # --
1385         newlines.append(r'''
1386         SET(srcs)
1387         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1388         GET_FILENAME_COMPONENT(ext ${src} EXT)
1389         IF(ext STREQUAL .f)
1390         IF(src STREQUAL trte.f)
1391         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1392         STRING(REPLACE ".f" ".c" src ${src})
1393         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1394         SET(output ${src})
1395         ADD_CUSTOM_COMMAND(
1396         OUTPUT ${output}
1397         COMMAND f2c ${input}
1398         MAIN_DEPENDENCY ${input}
1399         )
1400         ELSE(src STREQUAL trte.f)
1401         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1402         STRING(REPLACE ".f" ".o" src ${src})
1403         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1404         SET(output ${src})
1405         IF(WINDOWS)
1406         SET(F77 g77)
1407         ELSE(WINDOWS)
1408         SET(F77 gfortran)
1409         ENDIF(WINDOWS)
1410         ADD_CUSTOM_COMMAND(
1411         OUTPUT ${output}
1412         COMMAND ${F77} -c -o ${output} ${input}
1413         MAIN_DEPENDENCY ${input}
1414         )
1415         ENDIF(src STREQUAL trte.f)
1416         ENDIF(ext STREQUAL .f)
1417         SET(srcs ${srcs} ${src})
1418         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1419         ''')
1420         newlines.append(r'''
1421         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1422         FOREACH(f ${l})
1423         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1424         SET(srcs ${srcs} ${src})
1425         ENDFOREACH(f ${l})
1426         ''')
1427         newlines.append(r'''
1428         SET(build_srcs)
1429         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1430         FOREACH(f ${l})
1431         GET_FILENAME_COMPONENT(ext ${f} EXT)
1432         IF(ext STREQUAL .py)
1433         ELSE(ext STREQUAL .py)
1434         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1435         ENDIF(ext STREQUAL .py)
1436         ENDFOREACH(f ${l})
1437         ''')
1438         # --
1439         # Add the library to cmake
1440         # --
1441         newlines.append(r'''
1442         ADD_LIBRARY(${name} ${type} ${srcs})
1443         ''')
1444         # --
1445         # The compilation flags
1446         # --
1447         self.setCompilationFlags(key, newlines)
1448         # --
1449         newlines.append(r'''
1450         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1451         ''')
1452         # --
1453         self.setLibAdd(key, newlines)
1454         # --
1455         if 1: # key != "noinst_LTLIBRARIES":
1456             if self.module == "medfile":
1457                 newlines.append(r'''
1458                 SET(DEST lib)
1459                 ''')
1460             else:
1461                 newlines.append(r'''
1462                 SET(DEST lib/salome)
1463                 ''')
1464                 pass
1465             newlines.append(r'''
1466             IF(BEGIN_WITH_lib)
1467             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1468             ''')
1469             if self.module == "gui":
1470                 newlines.append(r'''
1471                 FOREACH(lib SalomePyQt)
1472                 IF(name STREQUAL lib)
1473                 IF(WINDOWS)
1474                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1475                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1476                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1477                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1478                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1479                 ELSE(WINDOWS)
1480                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1481                 ENDIF(WINDOWS)
1482                 ENDIF(name STREQUAL lib)
1483                 ENDFOREACH(lib SalomePyQt)
1484                 FOREACH(lib SalomePy)
1485                 IF(name STREQUAL lib)
1486                 IF(WINDOWS)
1487                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1488                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1489                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1490                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1491                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1492                 ENDIF(WINDOWS)
1493                 ENDIF(name STREQUAL lib)
1494                 ENDFOREACH(lib SalomePy)
1495                 ''')
1496                 pass
1497             if self.module == "geom":
1498                 newlines.append(r'''
1499                 IF(WINDOWS)
1500                 STRING(REGEX MATCH "Export" ISExport ${name})
1501                 IF(ISExport)
1502                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1503                 ENDIF(ISExport)
1504                 STRING(REGEX MATCH "Import" ISImport ${name})
1505                 IF(ISImport)
1506                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1507                 ENDIF(ISImport)
1508                 ENDIF(WINDOWS)
1509                 ''')
1510                 pass
1511             newlines.append(r'''
1512             ELSE(BEGIN_WITH_lib)
1513             ''')
1514             newlines.append(r'''
1515             IF(WINDOWS)
1516             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1517             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1518             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.pyd)
1519             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1520             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}_d.pyd)
1521             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1522             ELSE(WINDOWS)
1523             GET_TARGET_PROPERTY(version ${name} VERSION)
1524             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1525             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1526             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1527             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1528             ENDIF(WINDOWS)
1529             ''')
1530             newlines.append(r'''
1531             ENDIF(BEGIN_WITH_lib)
1532             ''')
1533             pass
1534         # --
1535         newlines.append(r'''
1536         ENDFOREACH(amname ${%s})
1537         '''%(key))
1538         # --
1539         return
1540
1541     def addBinTarget(self, key, newlines):
1542         # --
1543         newlines.append(r'''
1544         FOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1545         ''')
1546         # --
1547         newlines.append(r'''
1548         SET(name "${amname}_exe")
1549         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1550         SET(l ${nodist_${amname}_SOURCES})
1551         FOREACH(f ${l})
1552         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1553         SET(srcs ${srcs} ${src})
1554         ENDFOREACH(f ${l})
1555         LIST(LENGTH srcs nb)
1556         IF(nb)
1557         ADD_EXECUTABLE(${name} ${srcs})
1558         ''')
1559         # --
1560         self.setCompilationFlags(key, newlines)
1561         # --
1562         self.setLibAdd(key, newlines)
1563         # --
1564         if self.module == "medfile":
1565             newlines.append(r'''
1566             SET(DEST bin)
1567             ''')
1568         else:
1569             newlines.append(r'''
1570             SET(DEST bin/salome)
1571             ''')
1572             pass
1573         # --
1574         if key == "bin_PROGRAMS":
1575             newlines.append(r'''
1576             IF(WINDOWS)
1577             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1578             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1579             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1580             ELSE(WINDOWS)
1581             SET(PERMS)
1582             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1583             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1584             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1585             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1586             ENDIF(WINDOWS)
1587             ''')
1588             pass
1589         # --
1590         newlines.append(r'''
1591         ENDIF(nb)
1592         ''')
1593         # --
1594         newlines.append(r'''
1595         ENDFOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1596         ''')
1597         # --
1598         return
1599
1600     def addInstallTarget(self, key, destination, newlines):
1601         newlines.append(r"FOREACH(f ${%s})"%(key))
1602         newlines.append(r'''
1603         SET(DEST %s)
1604         '''%(destination))
1605         newlines.append(r'''
1606         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1607         IF(test_SALOMEconfig.h.in)
1608         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1609         ELSE(test_SALOMEconfig.h.in)
1610         SET(dummy dummy-NOTFOUND)
1611         MARK_AS_ADVANCED(dummy)
1612         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1613         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1614         IF(dummy)
1615         ''')
1616         if key in ['dist_salomescript_SCRIPTS']:
1617             newlines.append(r'''
1618             SET(PERMS)
1619             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1620             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1621             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1622             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1623             ''')
1624         else:
1625             newlines.append(r'''
1626             GET_FILENAME_COMPONENT(ext ${f} EXT)
1627             IF(ext STREQUAL .py)
1628             IF(DEST STREQUAL bin/salome)
1629             SET(PERMS)
1630             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1631             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1632             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1633             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1634             ELSE(DEST STREQUAL bin/salome)
1635             INSTALL(FILES ${f} DESTINATION ${DEST})
1636             ENDIF(DEST STREQUAL bin/salome)
1637             ELSE(ext STREQUAL .py)
1638             INSTALL(FILES ${f} DESTINATION ${DEST})
1639             ENDIF(ext STREQUAL .py)
1640             ''')
1641             pass
1642         newlines.append(r'''
1643         ELSE(dummy)
1644         GET_FILENAME_COMPONENT(ext ${f} EXT)
1645         IF(ext STREQUAL .qm)
1646         STRING(REGEX REPLACE .qm .ts input ${f})
1647         ''')
1648         if self.module in ["kernel", "gui", "yacs"]:
1649             newlines.append(r'''
1650             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1651             ''')
1652         else:
1653             newlines.append(r'''
1654             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1655             ''')
1656             pass
1657         newlines.append(r'''
1658         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1659         # ADD_CUSTOM_COMMAND(
1660         # OUTPUT ${output}
1661         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1662         # MAIN_DEPENDENCY ${input}
1663         # )
1664         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1665         ENDIF(ext STREQUAL .qm)
1666         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1667         ENDIF(dummy)
1668         ENDIF(test_SALOMEconfig.h.in)
1669         ''')
1670         newlines.append(r'''
1671         GET_FILENAME_COMPONENT(ext ${f} EXT)
1672         IF(ext STREQUAL .py)
1673         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1674         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1675         INSTALL(CODE "SET(DEST ${DEST})")
1676         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1677         ''')
1678         if self.module == "kernel":
1679             newlines.append('''
1680             IF(f STREQUAL SALOME_ContainerPy.py)
1681             ELSE(f STREQUAL SALOME_ContainerPy.py)
1682             IF(f STREQUAL am2cmake.py)
1683             ELSE(f STREQUAL am2cmake.py)
1684             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1685             ENDIF(f STREQUAL am2cmake.py)
1686             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1687             ''')
1688         else:
1689             newlines.append('''
1690             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1691             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1692             ''')
1693             pass
1694         newlines.append(r'''
1695         ENDIF(ext STREQUAL .py)
1696         ''')
1697         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1698         return
1699
1700     def writeListsFile(self):
1701         f = open(self.listsFile, "w")
1702         f.write(self.content)
1703         f.close()
1704         return
1705
1706     pass
1707
1708 def convertAmFile(the_root, root, dirs, files, f, module):
1709     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1710     cmake.writeListsFile()
1711     return
1712
1713 def usage(exit_status):
1714     from sys import exit
1715     from sys import argv
1716     print "Usage: %s --module"%(argv[0])
1717     exit(exit_status)
1718     return
1719
1720 if __name__ == "__main__":
1721     #
1722     from sys import argv
1723     if len(argv) != 2:
1724         usage(1)
1725         pass
1726     #
1727     module = argv[1]
1728     if module.find('--') != 0:
1729         usage(1)
1730         pass
1731     module = module[2:]
1732     if len(module) == 0:
1733         usage(1)
1734         pass
1735     #
1736     from os import getcwd
1737     the_root = getcwd()
1738     #
1739     from os import walk
1740     for root, dirs, files in walk(the_root):
1741         # --
1742         # E.A. : Remove 'CVS' in dirs
1743         # E.A. : It allows to not recurse in CVS dirs
1744         # E.A. : See os module python documentation
1745         # --
1746         try:
1747             dirs.remove('CVS')
1748         except ValueError:
1749             pass
1750         # --
1751         if "Makefile.am.cmake" in files:
1752             if "Makefile.am" in files:
1753                 files.remove("Makefile.am")
1754                 pass
1755             pass
1756         # --
1757         for f in files:
1758             if f in ["Makefile.am", "Makefile.am.cmake"]:
1759                 convertAmFile(the_root, root, dirs, files, f, module)
1760                 pass
1761             pass
1762         pass
1763     #
1764     pass