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             ''')
 962             newlines.append('''
 963             install(FILES ${input} DESTINATION idl/salome)
 964             ''')
 965             if self.module not in ["pyhello"]:
 966                 newlines.append('''
 967                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 968                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
 969                 ''')
 970                 pass
 971             newlines.append('''
 972             INSTALL(CODE "SET(IDL_FILE ${input})")
 973             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 974             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 975             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 976             # --
 977             SET(flags)
 978             FOREACH(f ${IDLPYFLAGS})
 979             SET(flags "${flags} ${f}")
 980             ENDFOREACH(f ${IDLPYFLAGS})
 981             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
 982             IF(NOT ISBPYTHON)
 983             SET(flags "-bpython ${flags}")
 984             ENDIF(NOT ISBPYTHON)
 985             SET(IDLPYFLAGS ${flags})
 986             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 987             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 988             # --
 989             ''')
 990             if self.module == "kernel":
 991                 newlines.append('''
 992                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 993                 ''')
 994             else:
 995                 newlines.append('''
 996                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 997                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 998                 ''')
 999                 pass
1000             newlines.append('''
1001             ENDFOREACH(input ${IDL_FILES})
1002             ''')
1003             pass
1004
1005         # --
1006         # --
1007         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1008             if self.__thedict__.has_key(key):
1009                 newlines.append('''
1010                 SET(SWIG_SOURCES ${%s})
1011                 '''%(key))
1012                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1013                 pass
1014             pass
1015
1016         # --
1017         # --
1018         if self.__thedict__.has_key("SWIG_SOURCES"):
1019             newlines.append('''
1020             IF(SWIG_SOURCES MATCHES ";")
1021             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1022             ELSE(SWIG_SOURCES MATCHES ";")
1023             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1024             ENDIF(SWIG_SOURCES MATCHES ";")
1025             SET(flags)
1026             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1027             SET(test ON)
1028             IF(flags)
1029             LIST(FIND flags ${f} index)
1030             IF(NOT index EQUAL -1)
1031             SET(test OFF)
1032             ENDIF(NOT index EQUAL -1)
1033             ENDIF(flags)
1034             IF(test)
1035             SET(flags ${flags} ${f})
1036             ENDIF(test)
1037             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1038             ADD_CUSTOM_COMMAND(
1039             OUTPUT ${build_srcs}
1040             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1041             MAIN_DEPENDENCY ${SWIG_SOURCES}
1042             )
1043             ''')
1044             pass
1045
1046         # --
1047         # --
1048         if self.__thedict__.has_key("BUILT_SOURCES"):
1049             newlines.append('''
1050             FOREACH(f ${BUILT_SOURCES})
1051             IF(f MATCHES "WRAP.cxx$")
1052             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1053             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1054             ADD_CUSTOM_COMMAND(
1055             OUTPUT ${f} # ${inc}
1056             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1057             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1058             )
1059             ENDIF(f MATCHES "WRAP.cxx$")
1060             ENDFOREACH(f ${BUILT_SOURCES})
1061             ''')
1062             pass
1063
1064         # --
1065         # --
1066         key = "MOC_FILES"
1067         if self.__thedict__.has_key(key):
1068             newlines.append('''
1069             FOREACH(output ${MOC_FILES})
1070             ''')
1071             if self.module == "yacs":
1072                 newlines.append('''
1073                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1074                 ''')
1075             else:
1076                 newlines.append('''
1077                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1078                 ''')
1079                 pass
1080             newlines.append('''
1081             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1082             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1083             ADD_CUSTOM_COMMAND(
1084             OUTPUT ${output}
1085             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1086             MAIN_DEPENDENCY ${input}
1087             )
1088             ENDFOREACH(output ${MOC_FILES})
1089             ''')
1090             pass
1091
1092         # --
1093         # --
1094         key = "UIC_FILES"
1095         if self.__thedict__.has_key(key):
1096             newlines.append('''
1097             FOREACH(output ${UIC_FILES})
1098             STRING(REPLACE "ui_" "" input ${output})
1099             STRING(REPLACE ".h" ".ui" input ${input})
1100             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1101             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1102             ADD_CUSTOM_COMMAND(
1103             OUTPUT ${output}
1104             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1105             MAIN_DEPENDENCY ${input}
1106             )
1107             ENDFOREACH(output ${UIC_FILES})
1108             ''')
1109             pass
1110
1111         # --
1112         # --
1113         key = "QRC_FILES"
1114         if self.__thedict__.has_key(key):
1115             newlines.append('''
1116             FOREACH(output ${QRC_FILES})
1117             STRING(REGEX REPLACE "qrc_" "" input ${output})
1118             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1119             STRING(REGEX REPLACE ".qrc" "" name ${input})
1120             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1121             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1122             ADD_CUSTOM_COMMAND(
1123             OUTPUT ${output}
1124             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1125             MAIN_DEPENDENCY ${input}
1126             )
1127             ENDFOREACH(output ${QRC_FILES})
1128             ''')
1129             pass
1130
1131         # --
1132         # --
1133         key = "SIP_FILES"
1134         if self.__thedict__.has_key(key):
1135             newlines.append('''
1136             FOREACH(input ${SIP_FILES})
1137             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1138             SET(output)
1139             FOREACH(out ${SIP_SRC})
1140             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1141             ENDFOREACH(out ${SIP_SRC})
1142             ADD_CUSTOM_COMMAND(
1143             OUTPUT ${output}
1144             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1145             MAIN_DEPENDENCY ${input}
1146             )
1147             ENDFOREACH(input ${SIP_FILES})
1148             ''')
1149             pass
1150
1151         # --
1152         # Treat the install targets
1153         # --
1154         d = {
1155             "salomeadmux_DATA"            :  "salome_adm/unix",
1156             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1157             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1158             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1159             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1160             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1161             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1162             "salomeinclude_DATA"          :  "include/salome",
1163             "salomeinclude_HEADERS"       :  "include/salome",
1164             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1165             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1166             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1167             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1168             "dist_salomescript_DATA"      :  "bin/salome",
1169             "dist_salomescript_PYTHON"    :  "bin/salome",
1170             "nodist_salomescript_DATA"    :  "bin/salome",
1171             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1172             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1173             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1174             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1175             }
1176         if self.module == "medfile":
1177             d = {
1178                 "include_HEADERS"        :  "include",
1179                 "nodist_include_HEADERS" :  "include",
1180                 "bin_SCRIPTS"            :  "bin",
1181                 "doc_DATA"               :  "${docdir}",
1182                 }
1183             pass
1184         for key, value in d.items():
1185             if self.__thedict__.has_key(key):
1186                 self.addInstallTarget(key, value, newlines)
1187                 pass
1188             pass
1189
1190         # --
1191         return
1192
1193     def setLibAdd(self, key, newlines):
1194         # --
1195         newlines.append(r'''
1196         SET(libadd)
1197         ''')
1198         # --
1199         newlines.append(r'''
1200         IF(WINDOWS)
1201         SET(targets)
1202         SET(targets ${targets} MEFISTO2D)
1203         FOREACH(target ${targets})
1204         IF(name STREQUAL ${target})
1205         SET(dir $ENV{F2CHOME})
1206         STRING(REPLACE "\\\\" "/" dir ${dir})
1207         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1208         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1209         ENDIF(name STREQUAL ${target})
1210         ENDFOREACH(target ${targets})
1211         ENDIF(WINDOWS)
1212         ''')
1213         # --
1214         newlines.append(r'''
1215         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1216         FOREACH(lib SALOMEBasics SalomeBatch)
1217         IF(name STREQUAL lib)
1218         SET(libs ${libs} ${PTHREAD_LIBS})
1219         ENDIF(name STREQUAL lib)
1220         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1221         ''')
1222         if key == "bin_PROGRAMS":
1223             newlines.append(r'''
1224             SET(libs ${libs} ${LDADD})
1225             ''')
1226             pass
1227         # --
1228         newlines.append(r'''
1229         FOREACH(lib ${libs})
1230         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1231         IF(ext STREQUAL .la)
1232         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1233         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1234         ENDIF(ext STREQUAL .la)
1235         SET(vars)
1236         SET(vars ${vars} -no-undefined)
1237         SET(vars ${vars} -lvtkWidgets)
1238         IF(WINDOWS)
1239         SET(vars ${vars} -module)
1240         SET(vars ${vars} -Wl,-E)
1241         SET(vars ${vars} -Xlinker)
1242         SET(vars ${vars} -export-dynamic)
1243         SET(vars ${vars} -lm)
1244         SET(vars ${vars} -lboost_thread)
1245         SET(vars ${vars} -lboost_signals)
1246         SET(vars ${vars} -pthread -lpthread -ldl)
1247         ENDIF(WINDOWS)
1248         FOREACH(v ${vars})
1249         IF(lib STREQUAL v)
1250         SET(lib)
1251         ENDIF(lib STREQUAL v)
1252         ENDFOREACH(v ${vars})
1253         SET(libadd ${libadd} ${lib})
1254         ENDFOREACH(lib ${libs})
1255         TARGET_LINK_LIBRARIES(${name} ${libadd})
1256         ''')
1257         # --
1258         newlines.append(r'''
1259         IF(WINDOWS)
1260         SET(targets)
1261         SET(targets ${targets} MEFISTO2D)
1262         FOREACH(target ${targets})
1263         IF(name STREQUAL ${target})
1264         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1265         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1266         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1267         ENDIF(name STREQUAL ${target})
1268         ENDFOREACH(target ${targets})
1269         ENDIF(WINDOWS)
1270         ''')
1271         # --
1272         return
1273
1274     def setCompilationFlags(self, key, newlines):
1275         newlines.append(r'''
1276         SET(var)
1277         IF(WINDOWS)
1278         SET(targets)
1279         SET(targets ${targets} SalomeIDLKernel)
1280         SET(targets ${targets} SalomeDS)
1281         SET(targets ${targets} SALOMEDSTest)
1282         SET(targets ${targets} SALOMEDS_Client_exe)
1283         SET(targets ${targets} SalomeIDLGEOM)
1284         SET(targets ${targets} GEOMEngine)
1285         SET(targets ${targets} MEDEngine)
1286         SET(targets ${targets} SMESHEngine)
1287         SET(targets ${targets} SMESH)
1288         FOREACH(target ${targets})
1289         IF(name STREQUAL ${target})
1290         SET(var ${var} -DNOGDI)
1291         ENDIF(name STREQUAL ${target})
1292         ENDFOREACH(target ${targets})
1293         ENDIF(WINDOWS)
1294         ''')
1295         # --
1296         if self.module in ["medfile", "yacs"]:
1297             newlines.append(r'''
1298             IF(WINDOWS)
1299             SET(var ${var} -DNOGDI)
1300             ENDIF(WINDOWS)
1301             ''')
1302             pass
1303         # --
1304         newlines.append(r'''
1305         IF(WINDOWS)
1306         SET(targets)
1307         SET(targets ${targets} MEFISTO2D)
1308         FOREACH(target ${targets})
1309         IF(name STREQUAL ${target})
1310         SET(dir $ENV{F2CHOME})
1311         STRING(REPLACE "\\\\" "/" dir ${dir})
1312         SET(var ${var} -I${dir})
1313         SET(var ${var} -DF2C_BUILD)
1314         ENDIF(name STREQUAL ${target})
1315         ENDFOREACH(target ${targets})
1316         ENDIF(WINDOWS)
1317         ''')
1318         # --
1319         if self.module in ["geom", "med"]:
1320             newlines.append(r'''
1321             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1322             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1323             ''')
1324             pass
1325         newlines.append(r'''
1326         SET(var ${var} ${AM_CPPFLAGS})
1327         SET(var ${var} ${AM_CXXFLAGS})
1328         ''')
1329         if self.module == "yacs":
1330             newlines.append(r'''
1331             SET(var ${var} -DYACS_PTHREAD)
1332             SET(var ${var} -DCMAKE_BUILD)
1333             SET(var ${var} -DSALOME_KERNEL)
1334             SET(var ${var} -DDSC_PORTS)
1335             SET(var ${var} -DOMNIORB)
1336             ''')
1337             pass
1338         newlines.append(r'''
1339         SET(var ${var} ${PLATFORM_CPPFLAGS})
1340         SET(var ${var} ${PTHREAD_CFLAGS})
1341         SET(var ${var} ${${amname}_CPPFLAGS})
1342         SET(var ${var} ${${amname}_CXXFLAGS})
1343         SET(var ${var} ${${amname}_CFLAGS})
1344         SET(vars)
1345         IF(WINDOWS)
1346         SET(vars ${vars} -include SALOMEconfig.h)
1347         SET(vars ${vars} -ftemplate-depth-32)
1348         SET(vars ${vars} -fPIC)
1349         SET(vars ${vars} -g)
1350         ENDIF(WINDOWS)
1351         SET(flags)
1352         FOREACH(f ${var})
1353         FOREACH(v ${vars})
1354         IF(f STREQUAL v)
1355         SET(f)
1356         ENDIF(f STREQUAL v)
1357         ENDFOREACH(v ${vars})
1358         SET(flags "${flags} ${f}")
1359         ENDFOREACH(f ${var})
1360         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1361         ''')
1362         return
1363
1364     def addLibTarget(self, key, newlines):
1365         newlines.append(r'''
1366         FOREACH(amname ${%s})
1367         '''%(key))
1368         # --
1369         # Replace .la by _la ...
1370         # --
1371         newlines.append(r'''
1372         STRING(REPLACE .la _la amname ${amname})
1373         ''')
1374         # --
1375         # Remove the _la for the cmake name
1376         # --
1377         newlines.append(r'''
1378         STRING(LENGTH ${amname} len)
1379         MATH(EXPR newlen "${len}-3")
1380         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1381         ''')
1382         # --
1383         # Does the target begins with lib ??
1384         # If yes, remove lib at beginning for cmake name
1385         # --
1386         newlines.append(r'''
1387         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1388         IF(BEGIN_WITH_lib)
1389         STRING(LENGTH ${name} len)
1390         MATH(EXPR newlen "${len}-3")
1391         STRING(SUBSTRING ${name} 3 ${newlen} name)
1392         ENDIF(BEGIN_WITH_lib)
1393         ''')
1394         # --
1395         # Does the target is an idl library
1396         # --
1397         newlines.append(r'''
1398         STRING(REGEX MATCH "IDL" ISIDL ${name})
1399         ''')
1400         # --
1401         # Set the type of the library
1402         # --
1403         newlines.append(r'''
1404         IF(ISIDL)
1405         IF(WINDOWS)
1406         SET(type STATIC)
1407         ELSE(WINDOWS)
1408         SET(type SHARED)
1409         ENDIF(WINDOWS)
1410         ELSE(ISIDL)
1411         SET(type SHARED)
1412         ENDIF(ISIDL)
1413         ''')
1414         # --
1415         # Set sources for the library
1416         # --
1417         newlines.append(r'''
1418         SET(srcs)
1419         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1420         GET_FILENAME_COMPONENT(ext ${src} EXT)
1421         IF(ext STREQUAL .f)
1422         IF(src STREQUAL trte.f)
1423         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1424         STRING(REPLACE ".f" ".c" src ${src})
1425         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1426         SET(output ${src})
1427         ADD_CUSTOM_COMMAND(
1428         OUTPUT ${output}
1429         COMMAND f2c ${input}
1430         MAIN_DEPENDENCY ${input}
1431         )
1432         ELSE(src STREQUAL trte.f)
1433         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1434         STRING(REPLACE ".f" ".o" src ${src})
1435         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1436         SET(output ${src})
1437         IF(WINDOWS)
1438         SET(F77 g77)
1439         ELSE(WINDOWS)
1440         SET(F77 gfortran)
1441         ENDIF(WINDOWS)
1442         ADD_CUSTOM_COMMAND(
1443         OUTPUT ${output}
1444         COMMAND ${F77} -c -o ${output} ${input}
1445         MAIN_DEPENDENCY ${input}
1446         )
1447         ENDIF(src STREQUAL trte.f)
1448         ENDIF(ext STREQUAL .f)
1449         SET(srcs ${srcs} ${src})
1450         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1451         ''')
1452         newlines.append(r'''
1453         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1454         FOREACH(f ${l})
1455         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1456         SET(srcs ${srcs} ${src})
1457         ENDFOREACH(f ${l})
1458         ''')
1459         newlines.append(r'''
1460         SET(build_srcs)
1461         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1462         FOREACH(f ${l})
1463         GET_FILENAME_COMPONENT(ext ${f} EXT)
1464         IF(ext STREQUAL .py)
1465         ELSE(ext STREQUAL .py)
1466         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1467         ENDIF(ext STREQUAL .py)
1468         ENDFOREACH(f ${l})
1469         ''')
1470         # --
1471         # Add the library to cmake
1472         # --
1473         newlines.append(r'''
1474         ADD_LIBRARY(${name} ${type} ${srcs})
1475         ''')
1476         # --
1477         # The compilation flags
1478         # --
1479         self.setCompilationFlags(key, newlines)
1480         # --
1481         newlines.append(r'''
1482         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1483         ''')
1484         # --
1485         self.setLibAdd(key, newlines)
1486         # --
1487         if 1: # key != "noinst_LTLIBRARIES":
1488             if self.module == "medfile":
1489                 newlines.append(r'''
1490                 SET(DEST lib)
1491                 ''')
1492             else:
1493                 newlines.append(r'''
1494                 SET(DEST lib/salome)
1495                 ''')
1496                 pass
1497             newlines.append(r'''
1498             IF(BEGIN_WITH_lib)
1499             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1500             ''')
1501             if self.module == "gui":
1502                 newlines.append(r'''
1503                 FOREACH(lib SalomePyQt)
1504                 IF(name STREQUAL lib)
1505                 IF(WINDOWS)
1506                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1507                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1508                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1509                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1510                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1511                 ELSE(WINDOWS)
1512                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1513                 ENDIF(WINDOWS)
1514                 ENDIF(name STREQUAL lib)
1515                 ENDFOREACH(lib SalomePyQt)
1516                 FOREACH(lib SalomePy)
1517                 IF(name STREQUAL lib)
1518                 IF(WINDOWS)
1519                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1520                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1521                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1522                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1523                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1524                 ENDIF(WINDOWS)
1525                 ENDIF(name STREQUAL lib)
1526                 ENDFOREACH(lib SalomePy)
1527                 ''')
1528                 pass
1529             if self.module == "geom":
1530                 newlines.append(r'''
1531                 IF(WINDOWS)
1532                 STRING(REGEX MATCH "Export" ISExport ${name})
1533                 IF(ISExport)
1534                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1535                 ENDIF(ISExport)
1536                 STRING(REGEX MATCH "Import" ISImport ${name})
1537                 IF(ISImport)
1538                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1539                 ENDIF(ISImport)
1540                 ENDIF(WINDOWS)
1541                 ''')
1542                 pass
1543             newlines.append(r'''
1544             ELSE(BEGIN_WITH_lib)
1545             ''')
1546             newlines.append(r'''
1547             IF(WINDOWS)
1548             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1549             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1550             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)
1551             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1552             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)
1553             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1554             ELSE(WINDOWS)
1555             GET_TARGET_PROPERTY(version ${name} VERSION)
1556             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1557             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1558             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1559             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1560             ENDIF(WINDOWS)
1561             ''')
1562             newlines.append(r'''
1563             ENDIF(BEGIN_WITH_lib)
1564             ''')
1565             pass
1566         # --
1567         newlines.append(r'''
1568         ENDFOREACH(amname ${%s})
1569         '''%(key))
1570         # --
1571         return
1572
1573     def addBinTarget(self, key, newlines):
1574         # --
1575         newlines.append(r'''
1576         FOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1577         ''')
1578         # --
1579         newlines.append(r'''
1580         SET(name "${amname}_exe")
1581         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1582         SET(l ${nodist_${amname}_SOURCES})
1583         FOREACH(f ${l})
1584         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1585         SET(srcs ${srcs} ${src})
1586         ENDFOREACH(f ${l})
1587         LIST(LENGTH srcs nb)
1588         IF(nb)
1589         ADD_EXECUTABLE(${name} ${srcs})
1590         ''')
1591         # --
1592         self.setCompilationFlags(key, newlines)
1593         # --
1594         self.setLibAdd(key, newlines)
1595         # --
1596         if self.module == "medfile":
1597             newlines.append(r'''
1598             SET(DEST bin)
1599             ''')
1600         else:
1601             newlines.append(r'''
1602             SET(DEST bin/salome)
1603             ''')
1604             pass
1605         # --
1606         if key == "bin_PROGRAMS":
1607             newlines.append(r'''
1608             IF(WINDOWS)
1609             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1610             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1611             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1612             ELSE(WINDOWS)
1613             SET(PERMS)
1614             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1615             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1616             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1617             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1618             ENDIF(WINDOWS)
1619             ''')
1620             pass
1621         # --
1622         newlines.append(r'''
1623         ENDIF(nb)
1624         ''')
1625         # --
1626         newlines.append(r'''
1627         ENDFOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1628         ''')
1629         # --
1630         return
1631
1632     def addInstallTarget(self, key, destination, newlines):
1633         newlines.append(r"FOREACH(f ${%s})"%(key))
1634         newlines.append(r'''
1635         SET(DEST %s)
1636         '''%(destination))
1637         newlines.append(r'''
1638         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1639         IF(test_SALOMEconfig.h.in)
1640         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1641         ELSE(test_SALOMEconfig.h.in)
1642         SET(dummy dummy-NOTFOUND)
1643         MARK_AS_ADVANCED(dummy)
1644         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1645         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1646         IF(dummy)
1647         ''')
1648         if key in ['dist_salomescript_SCRIPTS']:
1649             newlines.append(r'''
1650             SET(PERMS)
1651             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1652             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1653             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1654             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1655             ''')
1656         else:
1657             newlines.append(r'''
1658             GET_FILENAME_COMPONENT(ext ${f} EXT)
1659             IF(ext STREQUAL .py)
1660             IF(DEST STREQUAL bin/salome)
1661             SET(PERMS)
1662             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1663             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1664             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1665             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1666             ELSE(DEST STREQUAL bin/salome)
1667             INSTALL(FILES ${f} DESTINATION ${DEST})
1668             ENDIF(DEST STREQUAL bin/salome)
1669             ELSE(ext STREQUAL .py)
1670             INSTALL(FILES ${f} DESTINATION ${DEST})
1671             ENDIF(ext STREQUAL .py)
1672             ''')
1673             pass
1674         newlines.append(r'''
1675         ELSE(dummy)
1676         GET_FILENAME_COMPONENT(ext ${f} EXT)
1677         IF(ext STREQUAL .qm)
1678         STRING(REGEX REPLACE .qm .ts input ${f})
1679         ''')
1680         if self.module in ["kernel", "gui", "yacs"]:
1681             newlines.append(r'''
1682             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1683             ''')
1684         else:
1685             newlines.append(r'''
1686             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1687             ''')
1688             pass
1689         newlines.append(r'''
1690         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1691         # ADD_CUSTOM_COMMAND(
1692         # OUTPUT ${output}
1693         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1694         # MAIN_DEPENDENCY ${input}
1695         # )
1696         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1697         ENDIF(ext STREQUAL .qm)
1698         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1699         ENDIF(dummy)
1700         ENDIF(test_SALOMEconfig.h.in)
1701         ''')
1702         newlines.append(r'''
1703         GET_FILENAME_COMPONENT(ext ${f} EXT)
1704         IF(ext STREQUAL .py)
1705         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1706         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1707         INSTALL(CODE "SET(DEST ${DEST})")
1708         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1709         ''')
1710         if self.module == "kernel":
1711             newlines.append('''
1712             IF(f STREQUAL SALOME_ContainerPy.py)
1713             ELSE(f STREQUAL SALOME_ContainerPy.py)
1714             IF(f STREQUAL am2cmake.py)
1715             ELSE(f STREQUAL am2cmake.py)
1716             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1717             ENDIF(f STREQUAL am2cmake.py)
1718             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1719             ''')
1720         else:
1721             newlines.append('''
1722             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1723             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1724             ''')
1725             pass
1726         newlines.append(r'''
1727         ENDIF(ext STREQUAL .py)
1728         ''')
1729         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1730         return
1731
1732     def writeListsFile(self):
1733         f = open(self.listsFile, "w")
1734         f.write(self.content)
1735         f.close()
1736         return
1737
1738     pass
1739
1740 def convertAmFile(the_root, root, dirs, files, f, module):
1741     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1742     cmake.writeListsFile()
1743     return
1744
1745 def usage(exit_status):
1746     from sys import exit
1747     from sys import argv
1748     print "Usage: %s --module"%(argv[0])
1749     exit(exit_status)
1750     return
1751
1752 if __name__ == "__main__":
1753     #
1754     from sys import argv
1755     if len(argv) != 2:
1756         usage(1)
1757         pass
1758     #
1759     module = argv[1]
1760     if module.find('--') != 0:
1761         usage(1)
1762         pass
1763     module = module[2:]
1764     if len(module) == 0:
1765         usage(1)
1766         pass
1767     #
1768     from os import getcwd
1769     the_root = getcwd()
1770     #
1771     from os import walk
1772     for root, dirs, files in walk(the_root):
1773         # --
1774         # E.A. : Remove 'CVS' in dirs
1775         # E.A. : It allows to not recurse in CVS dirs
1776         # E.A. : See os module python documentation
1777         # --
1778         try:
1779             dirs.remove('CVS')
1780         except ValueError:
1781             pass
1782         # --
1783         if "Makefile.am.cmake" in files:
1784             if "Makefile.am" in files:
1785                 files.remove("Makefile.am")
1786                 pass
1787             pass
1788         # --
1789         for f in files:
1790             if f in ["Makefile.am", "Makefile.am.cmake"]:
1791                 convertAmFile(the_root, root, dirs, files, f, module)
1792                 pass
1793             pass
1794         pass
1795     #
1796     pass