salome_adm/cmake_files/am2cmake.py

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