salome_adm/cmake_files/am2cmake.py

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