salome_adm/cmake_files/am2cmake.py

   1 #  -*- coding: iso-8859-1 -*-
   2 #  Copyright (C) 2007-2010  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
  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 .+         # 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             "GeomSelectionTools",
 330             "MEFISTO2D",
 331             "MeshDriverDAT",
 332             "MeshDriverMED",
 333             "MeshDriver",
 334             "MeshDriverSTL",
 335             "MeshDriverUNV",
 336             "SalomeIDLSMESH",
 337             "SMDS",
 338             "SMESHClient",
 339             "SMESHControls",
 340             "SMESHDS",
 341             "SMESHEngine",
 342             "SMESHFiltersSelection",
 343             "SMESHimpl",
 344             "SMESHObject",
 345             "SMESH",
 346             "StdMeshersEngine",
 347             "StdMeshersGUI",
 348             "StdMeshers",
 349             ]
 350         full_list  = cas_list + vtk_list
 351         full_list += kernel_list + gui_list
 352         full_list += geom_list + med_list + smesh_list
 353         # --
 354         # E.A. : sort by len before substitution ...
 355         # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 356         # And you understand ...
 357         # --
 358         full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 359         # --
 360         for key in full_list:
 361             content = content.replace("-l%s"%(key), "${%s}"%(key))
 362             pass
 363
 364         # --
 365         # Split content in lines to treat each one separately
 366         # --
 367         lines = content.split('\n')
 368
 369         # --
 370         # newlines contains the lines of the future CMakeLists.txt file
 371         # --
 372         newlines = []
 373
 374         # --
 375         # opened_ifs is used to deals with nested conditionnals
 376         # --
 377         opened_ifs = []
 378
 379         # --
 380         # the __thedict__ dictionnary contains key, val
 381         # of the Makefile.am file
 382         # --
 383         self.__thedict__ = {}
 384
 385         # --
 386         # Initialize file ... mainly includes other cmake files
 387         # --
 388         self.initialize(newlines)
 389
 390         # --
 391         # Do the job for each line
 392         # --
 393         for line in lines:
 394             self.treatLine(line, newlines, opened_ifs)
 395             pass
 396
 397         # --
 398         # Finalize file ... it is in here the cmake job is done
 399         # --
 400         self.finalize(newlines)
 401
 402         # --
 403         # Concatenate newlines into content
 404         # --
 405         content = '\n'.join(newlines)
 406
 407         # --
 408         # Add a CR at end if necessary
 409         # --
 410         lines = content.split('\n')
 411         # lines = [ l.strip() for l in lines ]
 412         if len(lines[-1]) != 0:
 413             lines.append('')
 414             pass
 415         content = '\n'.join(lines)
 416
 417         # --
 418         self.content = content
 419
 420         # --
 421         return
 422
 423     def initialize(self, newlines):
 424         if self.root == self.the_root:
 425             # --
 426             newlines.append("""
 427             CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
 428             IF(COMMAND cmake_policy)
 429             cmake_policy(SET CMP0003 NEW)
 430             ENDIF(COMMAND cmake_policy)
 431             """)
 432             # --
 433             if self.module == "kernel":
 434                 newlines.append("""
 435                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 436                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 437                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 438                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 439                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 440                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 441                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 442                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 443                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 444                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 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                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 461                 """)
 462                 if self.module == "gui":
 463                     newlines.append("""
 464                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 465                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 466                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 467                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 468                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 469                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 470                     """)
 471                 else:
 472                     newlines.append("""
 473                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 474                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 475                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 476                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 477                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 478                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 479                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 480                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 481                     """)
 482                     if self.module == "med":
 483                         newlines.append("""
 484                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 485                         IF(WINDOWS)
 486                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
 487                         ENDIF(WINDOWS)
 488                         """)
 489                         pass
 490                     if self.module == "smesh":
 491                         newlines.append("""
 492                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 493                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 494                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 495                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 496                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 497                         """)
 498                         pass
 499                     if self.module == "netgenplugin":
 500                         newlines.append("""
 501                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 502                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 503                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 504                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 505                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 506                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 507                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 508                         """)
 509                         pass
 510                     if self.module == "blsurfplugin":
 511                         newlines.append("""
 512                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 513                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 514                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 515                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 516                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 517                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 518                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 519                         """)
 520                         pass
 521                     if self.module in ["ghs3dplugin", "hexoticplugin"]:
 522                         newlines.append("""
 523                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 524                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 525                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 526                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 527                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 528                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 529                         """)
 530                         pass
 531                     if self.module == "ghs3dprlplugin":
 532                         newlines.append("""
 533                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 534                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 535                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 536                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 537                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 538                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 539                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 540                         """)
 541                         pass
 542                     if self.module == "visu":
 543                         newlines.append("""
 544                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 545                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 546                         """)
 547                         pass
 548                     if self.module == "yacs":
 549                         newlines.append("""
 550                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 551                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 552                         """)
 553                         pass
 554                     pass
 555                 pass
 556             # --
 557             newlines.append("""
 558             SET(DOXYGEN_IS_OK 0)
 559             """)
 560             if self.module not in ['med']:
 561                 newlines.append("""
 562                 IF(WINDOWS)
 563                 SET(CPPUNIT_IS_OK 0)
 564                 ENDIF(WINDOWS)
 565                 """)
 566                 pass
 567             # --
 568             if self.module == "kernel":
 569                 newlines.append("""
 570                 SET(WITH_LOCAL 1)
 571                 SET(WITH_BATCH 1)
 572                 set(VERSION 5.1.4)
 573                 set(XVERSION 0x050104)
 574                 SET(CALCIUM_IDL_INT_F77 long)
 575                 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 576                 SET(LONG_OR_INT int)
 577                 """)
 578             elif self.module == "gui":
 579                 newlines.append("""
 580                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 581                 SET(ENABLE_VTKVIEWER ON)
 582                 SET(ENABLE_SALOMEOBJECT ON)
 583                 SET(ENABLE_OCCVIEWER ON)
 584                 SET(ENABLE_GLVIEWER ON)
 585                 SET(ENABLE_PLOT2DVIEWER ON)
 586                 SET(ENABLE_PYCONSOLE ON)
 587                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 588                 SET(ENABLE_QXGRAPHVIEWER ON)
 589                 set(VERSION 5.1.4)
 590                 set(XVERSION 0x050104)
 591                 """)
 592                 pass
 593             elif self.module == "geom":
 594                 newlines.append("""
 595                 SET(GEOM_ENABLE_GUI ON)
 596                 """)
 597                 pass
 598             elif self.module == "medfile":
 599                 newlines.append("""
 600                 SET(MED_NUM_MAJEUR 2)
 601                 SET(MED_NUM_MINEUR 3)
 602                 SET(MED_NUM_RELEASE 5)
 603                 SET(LONG_OR_INT int)
 604                 IF(NOT WINDOWS)
 605                 SET(FLIBS -lgfortranbegin -lgfortran)
 606                 ENDIF(NOT WINDOWS)
 607                 """)
 608                 pass
 609             elif self.module == "med":
 610                 newlines.append("""
 611                 SET(MED_ENABLE_KERNEL ON)
 612                 IF(NOT WINDOWS)
 613                 SET(MED_ENABLE_SPLITTER ON)
 614                 ENDIF(NOT WINDOWS)
 615                 SET(MED_ENABLE_GUI ON)
 616                 """)
 617                 pass
 618             elif self.module == "smesh":
 619                 newlines.append("""
 620                 SET(SMESH_ENABLE_GUI ON)
 621                 """)
 622                 pass
 623             elif self.module == "netgenplugin":
 624                 newlines.append("""
 625                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 626                 """)
 627                 pass
 628             elif self.module == "blsurfplugin":
 629                 newlines.append("""
 630                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 631                 """)
 632                 pass
 633             elif self.module == "ghs3dplugin":
 634                 newlines.append("""
 635                 SET(GHS3DPLUGIN_ENABLE_GUI ON)
 636                 """)
 637                 pass
 638             elif self.module == "hexoticplugin":
 639                 newlines.append("""
 640                 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
 641                 """)
 642                 pass
 643             elif self.module == "ghs3dprlplugin":
 644                 newlines.append("""
 645                 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
 646                 """)
 647                 pass
 648             elif self.module == "yacs":
 649                 newlines.append("""
 650                 SET(SALOME_KERNEL ON)
 651                 SET(HAS_GUI ON)
 652                 SET(WITH_QT4 ON)
 653                 """)
 654                 pass
 655             # --
 656             pass
 657         # --
 658         newlines.append("""
 659         SET(VERSION_INFO 0.0.0)
 660         SET(SOVERSION_INFO 0)
 661         SET(SUBDIRS)
 662         SET(AM_CPPFLAGS)
 663         SET(AM_CXXFLAGS)
 664         SET(LDADD)
 665         """)
 666         if self.module == "kernel":
 667             newlines.append(r'''
 668             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 669             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 670             ''')
 671         else:
 672             if self.module not in ["yacs"]:
 673                 newlines.append(r'''
 674                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 675                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 676                 ''')
 677                 pass
 678             pass
 679         # --
 680         return
 681
 682     def treatLine(self, line, newlines, opened_ifs):
 683
 684         # --
 685         # Print the comment above the line itself
 686         # --
 687         if line.find('#') >= 0:
 688             fields = line.split('#')
 689             line = fields[0]
 690             comment = '#'.join([''] + fields[1:])
 691             newlines.append(comment)
 692             if len(line) == 0:
 693                 return
 694             pass
 695
 696         # --
 697         # If the line begins with 'include ', just comment it
 698         # --
 699         if line.find("include ") == 0:
 700             newlines.append("# " + line)
 701             return
 702
 703         # --
 704         # If the line begins with '-include', just comment it
 705         # --
 706         if line.find("-include") == 0:
 707             newlines.append("# " + line)
 708             return
 709
 710         # --
 711         # If the line is a definition of a make rule, just comment it
 712         # --
 713         if line.count(':') == 1:
 714             newlines.append("# " + line)
 715             return
 716
 717         # --
 718         # A particuliar case where there are two ":" on the same line
 719         # --
 720         if line.find('install-exec-local:') == 0:
 721             newlines.append("# " + line)
 722             return
 723
 724         # --
 725         # If the line begin by a tabulation, consider it's a makefile command and comment it
 726         # --
 727         if line.find("\t") == 0:
 728             newlines.append("# " + line)
 729             return
 730
 731         # --
 732         # --
 733         key = "-version-info"
 734         if line.find(key) >= 0:
 735             # --
 736             before = line.split(key)[0]
 737             after = line[len(before)+len(key):]
 738             sep = after[0]
 739             after = after[1:]
 740             version_info = after.split()[0]
 741             line = line.replace(key+sep+version_info, "")
 742             # --
 743             version_info = version_info.replace(':', '.')
 744             soversion_info = version_info.split('.')[0]
 745             newlines.append("SET(VERSION_INFO " + version_info + ")")
 746             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 747             # --
 748             pass
 749
 750         # --
 751         # Replace the $(TOTO) by ${TOTO}
 752         # Replace the @TOTO@  by ${TOTO}
 753         # --
 754         line = p_dollar.sub(r"${\1}", line)
 755         line = p_arobas.sub(r"${\1}", line)
 756
 757         # --
 758         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 759         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 760         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 761         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 762         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 763
 764         # --
 765         # Check if the line is a 'if' condition
 766         # If yes, replace it by a cmake grammar
 767         # --
 768         match = p_if.match(line)
 769         if match:
 770             theif = match.group("val")
 771             if theif[0] == "!":
 772                 theif = "NOT " + theif[1:]
 773                 pass
 774             line = p_if.sub(r"IF(%s)"%(theif), line)
 775             opened_ifs.append(theif)
 776             newlines.append(line)
 777             return
 778
 779         # --
 780         # Check if the line is a 'else' condition
 781         # If yes, replace it by a cmake grammar
 782         # --
 783         match = p_else.match(line)
 784         if match:
 785             line = "ELSE(%s)"%(opened_ifs[-1])
 786             newlines.append(line)
 787             return
 788
 789         # --
 790         # Check if the line is a 'endif' condition
 791         # If yes, replace it by a cmake grammar
 792         # --
 793         match = p_endif.match(line)
 794         if match:
 795             line = "ENDIF(%s)"%(opened_ifs[-1])
 796             opened_ifs[-1:] = []
 797             newlines.append(line)
 798             return
 799
 800         # --
 801         # Check if the line is an attribution '=' or '+='
 802         # --
 803         match = p_attribution.match(line)
 804         if match:
 805             self.treatAttribution(match, newlines)
 806             return
 807
 808         # --
 809         newlines.append(line)
 810
 811         # --
 812         return
 813
 814     def treatAttribution(self, match, newlines):
 815
 816         spaces = match.group("spaces")
 817         key = match.group("key")
 818         method = match.group("method")
 819         value = match.group("value")
 820         # print [spaces, key, method, value]
 821
 822         # --
 823         # Open cmake SET command
 824         # --
 825         newlines.append(spaces + "SET(" + key)
 826
 827         # --
 828         # If method is '+=', put the previous definition as first value
 829         # --
 830         if method == "+=":
 831             newlines.append("%s    ${%s}"%(spaces, key))
 832             pass
 833
 834         # --
 835         fields = value.split()
 836         for i in range(len(fields)):
 837             newlines.append("%s    %s"%(spaces, fields[i]))
 838             pass
 839
 840         # --
 841         if method == "+=":
 842             # --
 843             # The try: except KeyError is here if the +=
 844             # is an error which occurs in salome ...
 845             # --
 846             try:
 847                 self.__thedict__[key] += fields[:]
 848             except KeyError:
 849                 self.__thedict__[key] = fields[:]
 850                 pass
 851             pass
 852         else:
 853             self.__thedict__[key]  = fields[:]
 854             pass
 855
 856         # --
 857         # Close cmake SET command
 858         # --
 859
 860         newlines.append("%s)"%(spaces))
 861
 862         return
 863
 864     def finalize(self, newlines):
 865
 866         # --
 867         # Convert the .in files in build dir
 868         # --
 869         if self.module == "yacs":
 870             key = "salomegui"
 871             if self.root[-len(key):] == key:
 872                 self.files.append("resources/YACSCatalog.xml.in")
 873                 pass
 874             pass
 875         for f in self.files:
 876             if f[-3:] == ".in":
 877                 if f == "sstream.in":
 878                     continue
 879                 if f in ["runContainer.in", "stopContainer.in"]:
 880                     if self.module == "med":
 881                         if self.root[-3:] == "csh":
 882                             continue
 883                         pass
 884                     pass
 885                 if f == "SALOMEconfig.ref.in":
 886                     out = "SALOMEconfig.h"
 887                 else:
 888                     out = f[:-3]
 889                     pass
 890                 newlines.append(r'''
 891                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 892                 '''%(f))
 893                 newlines.append(r'''
 894                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 895                 '''%(out))
 896                 newlines.append(r'''
 897                 MESSAGE(STATUS "Creation of ${output}")
 898                 CONFIGURE_FILE(${input} ${output})
 899                 ''')
 900                 pass
 901             pass
 902
 903         # --
 904         # convert the SUBDIRS in cmake grammar
 905         # --
 906         if 1: # self.__thedict__.has_key("SUBDIRS"):
 907             newlines.append(r'''
 908             FOREACH(dir ${SUBDIRS})
 909             IF(NOT dir STREQUAL .)
 910             ADD_SUBDIRECTORY(${dir})
 911             ENDIF(NOT dir STREQUAL .)
 912             ENDFOREACH(dir ${SUBDIRS})
 913             ''')
 914             pass
 915
 916         # --
 917         # --
 918         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 919             if self.__thedict__.has_key(key):
 920                 self.addLibTarget(key, newlines)
 921                 pass
 922             pass
 923
 924         # --
 925         # --
 926         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
 927             if self.__thedict__.has_key(key):
 928                 self.addBinTarget(key, newlines)
 929                 pass
 930             pass
 931
 932         # --
 933         # --
 934         if self.__thedict__.has_key("BASEIDL_FILES"):
 935             if not self.__thedict__.has_key("IDL_FILES"):
 936                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 937                 newlines.append('''
 938                 SET(IDL_FILES ${BASEIDL_FILES})
 939                 ''')
 940                 pass
 941             pass
 942
 943         # --
 944         # --
 945
 946         key = "IDL_FILES"
 947         if self.__thedict__.has_key(key):
 948             if self.module == "kernel":
 949                 newlines.append('''
 950                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
 951                 ''')
 952                 pass
 953             newlines.append('''
 954             FOREACH(input ${IDL_FILES})
 955             STRING(REGEX REPLACE ".idl" "" base ${input})
 956             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 957             SET(outputs ${src})
 958             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 959             SET(outputs ${outputs} ${dynsrc})
 960             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 961             SET(outputs ${outputs} ${inc})
 962             IF(input STREQUAL Calcium_Ports.idl)
 963             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
 964             ELSE(input STREQUAL Calcium_Ports.idl)
 965             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 966             ENDIF(input STREQUAL Calcium_Ports.idl)
 967             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
 968             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
 969             IF(NOT ISBCXX)
 970             SET(flags -bcxx ${flags})
 971             ENDIF(NOT ISBCXX)
 972             ADD_CUSTOM_COMMAND(
 973             OUTPUT ${outputs}
 974             COMMAND ${OMNIORB_IDL} ${flags} ${input}
 975             MAIN_DEPENDENCY ${input}
 976             )
 977             ''')
 978             newlines.append('''
 979             install(FILES ${input} DESTINATION idl/salome)
 980             ''')
 981             if self.module not in ["pyhello"]:
 982                 newlines.append('''
 983                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 984                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
 985                 ''')
 986                 pass
 987             newlines.append('''
 988             INSTALL(CODE "SET(IDL_FILE ${input})")
 989             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 990             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 991             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 992             # --
 993             SET(flags)
 994             FOREACH(f ${IDLPYFLAGS})
 995             SET(flags "${flags} ${f}")
 996             ENDFOREACH(f ${IDLPYFLAGS})
 997             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
 998             IF(NOT ISBPYTHON)
 999             SET(flags "-bpython ${flags}")
1000             ENDIF(NOT ISBPYTHON)
1001             SET(IDLPYFLAGS ${flags})
1002             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1003             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1004             # --
1005             ''')
1006             if self.module == "kernel":
1007                 newlines.append('''
1008                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1009                 ''')
1010             else:
1011                 newlines.append('''
1012                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1013                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1014                 ''')
1015                 pass
1016             newlines.append('''
1017             ENDFOREACH(input ${IDL_FILES})
1018             ''')
1019             pass
1020
1021         # --
1022         # --
1023         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1024             if self.__thedict__.has_key(key):
1025                 newlines.append('''
1026                 SET(SWIG_SOURCES ${%s})
1027                 '''%(key))
1028                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1029                 pass
1030             pass
1031
1032         # --
1033         # --
1034         if self.__thedict__.has_key("SWIG_SOURCES"):
1035             newlines.append('''
1036             IF(SWIG_SOURCES MATCHES ";")
1037             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1038             ELSE(SWIG_SOURCES MATCHES ";")
1039             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1040             ENDIF(SWIG_SOURCES MATCHES ";")
1041             SET(flags)
1042             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1043             SET(test ON)
1044             IF(flags)
1045             LIST(FIND flags ${f} index)
1046             IF(NOT index EQUAL -1)
1047             SET(test OFF)
1048             ENDIF(NOT index EQUAL -1)
1049             ENDIF(flags)
1050             IF(test)
1051             SET(flags ${flags} ${f})
1052             ENDIF(test)
1053             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1054             ADD_CUSTOM_COMMAND(
1055             OUTPUT ${build_srcs}
1056             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1057             MAIN_DEPENDENCY ${SWIG_SOURCES}
1058             )
1059             ''')
1060             pass
1061
1062         # --
1063         # --
1064         if self.__thedict__.has_key("BUILT_SOURCES"):
1065             newlines.append('''
1066             FOREACH(f ${BUILT_SOURCES})
1067             IF(f MATCHES "WRAP.cxx$")
1068             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1069             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1070             ADD_CUSTOM_COMMAND(
1071             OUTPUT ${f} # ${inc}
1072             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1073             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1074             )
1075             ENDIF(f MATCHES "WRAP.cxx$")
1076             ENDFOREACH(f ${BUILT_SOURCES})
1077             ''')
1078             pass
1079
1080         # --
1081         # --
1082         key = "MOC_FILES"
1083         if self.__thedict__.has_key(key):
1084             newlines.append('''
1085             FOREACH(output ${MOC_FILES})
1086             ''')
1087             if self.module == "yacs":
1088                 newlines.append('''
1089                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1090                 ''')
1091             else:
1092                 newlines.append('''
1093                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1094                 ''')
1095                 pass
1096             newlines.append('''
1097             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1098             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1099             ADD_CUSTOM_COMMAND(
1100             OUTPUT ${output}
1101             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1102             MAIN_DEPENDENCY ${input}
1103             )
1104             ENDFOREACH(output ${MOC_FILES})
1105             ''')
1106             pass
1107
1108         # --
1109         # --
1110         key = "UIC_FILES"
1111         if self.__thedict__.has_key(key):
1112             newlines.append('''
1113             FOREACH(output ${UIC_FILES})
1114             STRING(REPLACE "ui_" "" input ${output})
1115             STRING(REPLACE ".h" ".ui" input ${input})
1116             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1117             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1118             ADD_CUSTOM_COMMAND(
1119             OUTPUT ${output}
1120             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1121             MAIN_DEPENDENCY ${input}
1122             )
1123             ENDFOREACH(output ${UIC_FILES})
1124             ''')
1125             pass
1126
1127         # --
1128         # --
1129         key = "QRC_FILES"
1130         if self.__thedict__.has_key(key):
1131             newlines.append('''
1132             FOREACH(output ${QRC_FILES})
1133             STRING(REGEX REPLACE "qrc_" "" input ${output})
1134             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1135             STRING(REGEX REPLACE ".qrc" "" name ${input})
1136             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1137             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1138             ADD_CUSTOM_COMMAND(
1139             OUTPUT ${output}
1140             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1141             MAIN_DEPENDENCY ${input}
1142             )
1143             ENDFOREACH(output ${QRC_FILES})
1144             ''')
1145             pass
1146
1147         # --
1148         # --
1149         key = "SIP_FILES"
1150         if self.__thedict__.has_key(key):
1151             newlines.append('''
1152             FOREACH(input ${SIP_FILES})
1153             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1154             SET(output)
1155             FOREACH(out ${SIP_SRC})
1156             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1157             ENDFOREACH(out ${SIP_SRC})
1158             ADD_CUSTOM_COMMAND(
1159             OUTPUT ${output}
1160             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1161             MAIN_DEPENDENCY ${input}
1162             )
1163             ENDFOREACH(input ${SIP_FILES})
1164             ''')
1165             pass
1166
1167         # --
1168         # Treat the install targets
1169         # --
1170         d = {
1171             "salomeadmux_DATA"            :  "salome_adm/unix",
1172             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1173             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1174             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1175             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1176             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1177             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1178             "salomeinclude_DATA"          :  "include/salome",
1179             "salomeinclude_HEADERS"       :  "include/salome",
1180             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1181             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1182             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1183             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1184             "dist_salomescript_DATA"      :  "bin/salome",
1185             "dist_salomescript_PYTHON"    :  "bin/salome",
1186             "nodist_salomescript_DATA"    :  "bin/salome",
1187             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1188             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1189             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1190             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1191             }
1192         if self.module == "medfile":
1193             d = {
1194                 "include_HEADERS"        :  "include",
1195                 "nodist_include_HEADERS" :  "include",
1196                 "bin_SCRIPTS"            :  "bin",
1197                 "doc_DATA"               :  "${docdir}",
1198                 }
1199             pass
1200         for key, value in d.items():
1201             if self.__thedict__.has_key(key):
1202                 self.addInstallTarget(key, value, newlines)
1203                 pass
1204             pass
1205
1206         # --
1207         return
1208
1209     def setLibAdd(self, key, newlines):
1210         # --
1211         newlines.append(r'''
1212         SET(libadd)
1213         ''')
1214         # --
1215         newlines.append(r'''
1216         IF(WINDOWS)
1217         SET(targets)
1218         SET(targets ${targets} MEFISTO2D)
1219         FOREACH(target ${targets})
1220         IF(name STREQUAL ${target})
1221         SET(dir $ENV{F2CHOME})
1222         STRING(REPLACE "\\\\" "/" dir ${dir})
1223         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1224         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1225         ENDIF(name STREQUAL ${target})
1226         ENDFOREACH(target ${targets})
1227         ENDIF(WINDOWS)
1228         ''')
1229         # --
1230         newlines.append(r'''
1231         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1232         FOREACH(lib SALOMEBasics SalomeBatch)
1233         IF(name STREQUAL lib)
1234         SET(libs ${libs} ${PTHREAD_LIBS})
1235         ENDIF(name STREQUAL lib)
1236         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1237         ''')
1238         if key == "bin_PROGRAMS":
1239             newlines.append(r'''
1240             SET(libs ${libs} ${LDADD})
1241             ''')
1242             pass
1243         # --
1244         newlines.append(r'''
1245         FOREACH(lib ${libs})
1246         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1247         IF(ext STREQUAL .la)
1248         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1249         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1250         ENDIF(ext STREQUAL .la)
1251         SET(vars)
1252         SET(vars ${vars} -no-undefined)
1253         SET(vars ${vars} -lvtkWidgets)
1254         IF(WINDOWS)
1255         SET(vars ${vars} -module)
1256         SET(vars ${vars} -Wl,-E)
1257         SET(vars ${vars} -Xlinker)
1258         SET(vars ${vars} -export-dynamic)
1259         SET(vars ${vars} -lm)
1260         SET(vars ${vars} -lboost_thread)
1261         SET(vars ${vars} -lboost_signals)
1262         SET(vars ${vars} -pthread -lpthread -ldl)
1263         ENDIF(WINDOWS)
1264         FOREACH(v ${vars})
1265         IF(lib STREQUAL v)
1266         SET(lib)
1267         ENDIF(lib STREQUAL v)
1268         ENDFOREACH(v ${vars})
1269         SET(libadd ${libadd} ${lib})
1270         ENDFOREACH(lib ${libs})
1271         TARGET_LINK_LIBRARIES(${name} ${libadd})
1272         ''')
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         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1281         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1282         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1283         ENDIF(name STREQUAL ${target})
1284         ENDFOREACH(target ${targets})
1285         ENDIF(WINDOWS)
1286         ''')
1287         # --
1288         return
1289
1290     def setCompilationFlags(self, key, newlines):
1291         newlines.append(r'''
1292         SET(var)
1293         IF(WINDOWS)
1294         SET(targets)
1295         SET(targets ${targets} SalomeIDLKernel)
1296         SET(targets ${targets} SalomeDS)
1297         SET(targets ${targets} SALOMEDSTest)
1298         SET(targets ${targets} SALOMEDS_Client_exe)
1299         SET(targets ${targets} SalomeIDLGEOM)
1300         SET(targets ${targets} GEOMEngine)
1301         SET(targets ${targets} MEDEngine)
1302         SET(targets ${targets} SMESHEngine)
1303         SET(targets ${targets} SMESH)
1304         FOREACH(target ${targets})
1305         IF(name STREQUAL ${target})
1306         SET(var ${var} -DNOGDI)
1307         ENDIF(name STREQUAL ${target})
1308         ENDFOREACH(target ${targets})
1309         ENDIF(WINDOWS)
1310         ''')
1311         # --
1312         if self.module in ["medfile", "yacs"]:
1313             newlines.append(r'''
1314             IF(WINDOWS)
1315             SET(var ${var} -DNOGDI)
1316             ENDIF(WINDOWS)
1317             ''')
1318             pass
1319         # --
1320         newlines.append(r'''
1321         IF(WINDOWS)
1322         SET(targets)
1323         SET(targets ${targets} MEFISTO2D)
1324         FOREACH(target ${targets})
1325         IF(name STREQUAL ${target})
1326         SET(dir $ENV{F2CHOME})
1327         STRING(REPLACE "\\\\" "/" dir ${dir})
1328         SET(var ${var} -I${dir})
1329         SET(var ${var} -DF2C_BUILD)
1330         ENDIF(name STREQUAL ${target})
1331         ENDFOREACH(target ${targets})
1332         ENDIF(WINDOWS)
1333         ''')
1334         # --
1335         if self.module in ["geom", "med"]:
1336             newlines.append(r'''
1337             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1338             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1339             ''')
1340             pass
1341         newlines.append(r'''
1342         SET(var ${var} ${AM_CPPFLAGS})
1343         SET(var ${var} ${AM_CXXFLAGS})
1344         ''')
1345         if self.module == "yacs":
1346             newlines.append(r'''
1347             SET(var ${var} -DYACS_PTHREAD)
1348             SET(var ${var} -DCMAKE_BUILD)
1349             SET(var ${var} -DSALOME_KERNEL)
1350             SET(var ${var} -DDSC_PORTS)
1351             SET(var ${var} -DOMNIORB)
1352             ''')
1353             pass
1354         newlines.append(r'''
1355         SET(var ${var} ${PLATFORM_CPPFLAGS})
1356         SET(var ${var} ${PTHREAD_CFLAGS})
1357         SET(var ${var} ${${amname}_CPPFLAGS})
1358         SET(var ${var} ${${amname}_CXXFLAGS})
1359         SET(var ${var} ${${amname}_CFLAGS})
1360         SET(vars)
1361         IF(WINDOWS)
1362         SET(vars ${vars} -include SALOMEconfig.h)
1363         SET(vars ${vars} -ftemplate-depth-32)
1364         SET(vars ${vars} -fPIC)
1365         SET(vars ${vars} -g)
1366         ENDIF(WINDOWS)
1367         SET(flags)
1368         FOREACH(f ${var})
1369         FOREACH(v ${vars})
1370         IF(f STREQUAL v)
1371         SET(f)
1372         ENDIF(f STREQUAL v)
1373         ENDFOREACH(v ${vars})
1374         SET(flags "${flags} ${f}")
1375         ENDFOREACH(f ${var})
1376         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1377         ''')
1378         return
1379
1380     def addLibTarget(self, key, newlines):
1381         newlines.append(r'''
1382         FOREACH(amname ${%s})
1383         '''%(key))
1384         # --
1385         # Replace .la by _la ...
1386         # --
1387         newlines.append(r'''
1388         STRING(REPLACE .la _la amname ${amname})
1389         ''')
1390         # --
1391         # Remove the _la for the cmake name
1392         # --
1393         newlines.append(r'''
1394         STRING(LENGTH ${amname} len)
1395         MATH(EXPR newlen "${len}-3")
1396         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1397         ''')
1398         # --
1399         # Does the target begins with lib ??
1400         # If yes, remove lib at beginning for cmake name
1401         # --
1402         newlines.append(r'''
1403         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1404         IF(BEGIN_WITH_lib)
1405         STRING(LENGTH ${name} len)
1406         MATH(EXPR newlen "${len}-3")
1407         STRING(SUBSTRING ${name} 3 ${newlen} name)
1408         ENDIF(BEGIN_WITH_lib)
1409         ''')
1410         # --
1411         # Does the target is an idl library
1412         # --
1413         newlines.append(r'''
1414         STRING(REGEX MATCH "IDL" ISIDL ${name})
1415         ''')
1416         # --
1417         # Set the type of the library
1418         # --
1419         newlines.append(r'''
1420         IF(ISIDL)
1421         IF(WINDOWS)
1422         SET(type STATIC)
1423         ELSE(WINDOWS)
1424         SET(type SHARED)
1425         ENDIF(WINDOWS)
1426         ELSE(ISIDL)
1427         SET(type SHARED)
1428         ENDIF(ISIDL)
1429         ''')
1430         if key == "noinst_LTLIBRARIES":
1431             newlines.append(r'''
1432             IF(WINDOWS)
1433             SET(type STATIC)
1434             ELSE(WINDOWS)
1435             SET(type STATIC)
1436             ENDIF(WINDOWS)
1437             ''')
1438             pass
1439         # --
1440         # Set sources for the library
1441         # --
1442         newlines.append(r'''
1443         SET(srcs)
1444         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1445         GET_FILENAME_COMPONENT(ext ${src} EXT)
1446         IF(ext STREQUAL .f)
1447         IF(src STREQUAL trte.f)
1448         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1449         STRING(REPLACE ".f" ".c" src ${src})
1450         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1451         SET(output ${src})
1452         ADD_CUSTOM_COMMAND(
1453         OUTPUT ${output}
1454         COMMAND f2c ${input}
1455         MAIN_DEPENDENCY ${input}
1456         )
1457         ELSE(src STREQUAL trte.f)
1458         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1459         STRING(REPLACE ".f" ".o" src ${src})
1460         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1461         SET(output ${src})
1462         IF(WINDOWS)
1463         SET(F77 g77)
1464         ELSE(WINDOWS)
1465         SET(F77 gfortran)
1466         ENDIF(WINDOWS)
1467         ADD_CUSTOM_COMMAND(
1468         OUTPUT ${output}
1469         COMMAND ${F77} -c -o ${output} ${input}
1470         MAIN_DEPENDENCY ${input}
1471         )
1472         ENDIF(src STREQUAL trte.f)
1473         ENDIF(ext STREQUAL .f)
1474         SET(srcs ${srcs} ${src})
1475         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1476         ''')
1477         newlines.append(r'''
1478         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1479         FOREACH(f ${l})
1480         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1481         SET(srcs ${srcs} ${src})
1482         ENDFOREACH(f ${l})
1483         ''')
1484         newlines.append(r'''
1485         SET(build_srcs)
1486         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1487         FOREACH(f ${l})
1488         GET_FILENAME_COMPONENT(ext ${f} EXT)
1489         IF(ext STREQUAL .py)
1490         ELSE(ext STREQUAL .py)
1491         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1492         ENDIF(ext STREQUAL .py)
1493         ENDFOREACH(f ${l})
1494         ''')
1495         # --
1496         # Add the library to cmake
1497         # --
1498         newlines.append(r'''
1499         ADD_LIBRARY(${name} ${type} ${srcs})
1500         ''')
1501         # --
1502         # The compilation flags
1503         # --
1504         self.setCompilationFlags(key, newlines)
1505         # --
1506         newlines.append(r'''
1507         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1508         ''')
1509         # --
1510         self.setLibAdd(key, newlines)
1511         # --
1512         if key != "noinst_LTLIBRARIES":
1513             if self.module == "medfile":
1514                 newlines.append(r'''
1515                 SET(DEST lib)
1516                 ''')
1517             else:
1518                 newlines.append(r'''
1519                 SET(DEST lib/salome)
1520                 ''')
1521                 pass
1522             newlines.append(r'''
1523             IF(BEGIN_WITH_lib)
1524             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1525             ''')
1526             if self.module == "gui":
1527                 newlines.append(r'''
1528                 FOREACH(lib SalomePyQt)
1529                 IF(name STREQUAL lib)
1530                 IF(WINDOWS)
1531                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1532                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1533                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1534                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1535                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1536                 ELSE(WINDOWS)
1537                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1538                 ENDIF(WINDOWS)
1539                 ENDIF(name STREQUAL lib)
1540                 ENDFOREACH(lib SalomePyQt)
1541                 FOREACH(lib SalomePy)
1542                 IF(name STREQUAL lib)
1543                 IF(WINDOWS)
1544                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1545                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1546                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1547                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1548                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1549                 ENDIF(WINDOWS)
1550                 ENDIF(name STREQUAL lib)
1551                 ENDFOREACH(lib SalomePy)
1552                 ''')
1553                 pass
1554             if self.module == "geom":
1555                 newlines.append(r'''
1556                 IF(WINDOWS)
1557                 STRING(REGEX MATCH "Export" ISExport ${name})
1558                 IF(ISExport)
1559                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1560                 ENDIF(ISExport)
1561                 STRING(REGEX MATCH "Import" ISImport ${name})
1562                 IF(ISImport)
1563                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1564                 ENDIF(ISImport)
1565                 ENDIF(WINDOWS)
1566                 ''')
1567                 pass
1568             newlines.append(r'''
1569             ELSE(BEGIN_WITH_lib)
1570             ''')
1571             newlines.append(r'''
1572             IF(WINDOWS)
1573             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1574             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1575             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)
1576             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1577             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)
1578             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1579             ELSE(WINDOWS)
1580             GET_TARGET_PROPERTY(version ${name} VERSION)
1581             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1582             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1583             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1584             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1585             ENDIF(WINDOWS)
1586             ''')
1587             newlines.append(r'''
1588             ENDIF(BEGIN_WITH_lib)
1589             ''')
1590             pass
1591         # --
1592         newlines.append(r'''
1593         ENDFOREACH(amname ${%s})
1594         '''%(key))
1595         # --
1596         return
1597
1598     def addBinTarget(self, key, newlines):
1599         # --
1600         newlines.append(r'''
1601         FOREACH(amname ${%s})
1602         '''%(key))
1603         # --
1604         newlines.append(r'''
1605         SET(test ON)
1606         ''')
1607         if key == "check_PROGRAMS":
1608             newlines.append(r'''
1609             IF(bin_PROGRAMS)
1610             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
1611             IF(is_present)
1612             SET(test OFF)
1613             ENDIF(is_present)
1614             ENDIF(bin_PROGRAMS)
1615             ''')
1616             pass
1617         newlines.append(r'''
1618         IF(test)
1619         ''')
1620         # --
1621         newlines.append(r'''
1622         SET(name "${amname}_exe")
1623         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1624         SET(l ${nodist_${amname}_SOURCES})
1625         FOREACH(f ${l})
1626         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1627         SET(srcs ${srcs} ${src})
1628         ENDFOREACH(f ${l})
1629         LIST(LENGTH srcs nb)
1630         IF(nb)
1631         ADD_EXECUTABLE(${name} ${srcs})
1632         ''')
1633         # --
1634         self.setCompilationFlags(key, newlines)
1635         # --
1636         self.setLibAdd(key, newlines)
1637         # --
1638         if self.module == "medfile":
1639             newlines.append(r'''
1640             SET(DEST bin)
1641             ''')
1642         else:
1643             newlines.append(r'''
1644             SET(DEST bin/salome)
1645             ''')
1646             pass
1647         # --
1648         if key == "bin_PROGRAMS":
1649             newlines.append(r'''
1650             IF(WINDOWS)
1651             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1652             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1653             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1654             ELSE(WINDOWS)
1655             SET(PERMS)
1656             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1657             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1658             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1659             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1660             ENDIF(WINDOWS)
1661             ''')
1662             pass
1663         # --
1664         newlines.append(r'''
1665         ENDIF(nb)
1666         ''')
1667         # --
1668         newlines.append(r'''
1669         ENDIF(test)
1670         ''')
1671         newlines.append(r'''
1672         ENDFOREACH(amname ${%s})
1673         '''%(key))
1674         # --
1675         return
1676
1677     def addInstallTarget(self, key, destination, newlines):
1678         newlines.append(r"FOREACH(f ${%s})"%(key))
1679         newlines.append(r'''
1680         SET(DEST %s)
1681         '''%(destination))
1682         newlines.append(r'''
1683         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1684         IF(test_SALOMEconfig.h.in)
1685         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1686         ELSE(test_SALOMEconfig.h.in)
1687         SET(dummy dummy-NOTFOUND)
1688         MARK_AS_ADVANCED(dummy)
1689         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1690         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1691         IF(dummy)
1692         ''')
1693         if key in ['dist_salomescript_SCRIPTS']:
1694             newlines.append(r'''
1695             SET(PERMS)
1696             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1697             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1698             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1699             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1700             ''')
1701         else:
1702             newlines.append(r'''
1703             GET_FILENAME_COMPONENT(ext ${f} EXT)
1704             IF(ext STREQUAL .py)
1705             IF(DEST STREQUAL bin/salome)
1706             SET(PERMS)
1707             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1708             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1709             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1710             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1711             ELSE(DEST STREQUAL bin/salome)
1712             INSTALL(FILES ${f} DESTINATION ${DEST})
1713             ENDIF(DEST STREQUAL bin/salome)
1714             ELSE(ext STREQUAL .py)
1715             INSTALL(FILES ${f} DESTINATION ${DEST})
1716             ENDIF(ext STREQUAL .py)
1717             ''')
1718             pass
1719         newlines.append(r'''
1720         ELSE(dummy)
1721         GET_FILENAME_COMPONENT(ext ${f} EXT)
1722         IF(ext STREQUAL .qm)
1723         STRING(REGEX REPLACE .qm .ts input ${f})
1724         ''')
1725         if self.module in ["kernel", "gui", "yacs"]:
1726             newlines.append(r'''
1727             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1728             ''')
1729         else:
1730             newlines.append(r'''
1731             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1732             ''')
1733             pass
1734         newlines.append(r'''
1735         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1736         # ADD_CUSTOM_COMMAND(
1737         # OUTPUT ${output}
1738         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1739         # MAIN_DEPENDENCY ${input}
1740         # )
1741         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1742         ENDIF(ext STREQUAL .qm)
1743         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1744         ENDIF(dummy)
1745         ENDIF(test_SALOMEconfig.h.in)
1746         ''')
1747         newlines.append(r'''
1748         GET_FILENAME_COMPONENT(ext ${f} EXT)
1749         IF(ext STREQUAL .py)
1750         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1751         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1752         INSTALL(CODE "SET(DEST ${DEST})")
1753         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1754         ''')
1755         if self.module == "kernel":
1756             newlines.append('''
1757             IF(f STREQUAL SALOME_ContainerPy.py)
1758             ELSE(f STREQUAL SALOME_ContainerPy.py)
1759             IF(f STREQUAL am2cmake.py)
1760             ELSE(f STREQUAL am2cmake.py)
1761             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1762             ENDIF(f STREQUAL am2cmake.py)
1763             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1764             ''')
1765         else:
1766             newlines.append('''
1767             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1768             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1769             ''')
1770             pass
1771         newlines.append(r'''
1772         ENDIF(ext STREQUAL .py)
1773         ''')
1774         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1775         return
1776
1777     def writeListsFile(self):
1778         f = open(self.listsFile, "w")
1779         f.write(self.content)
1780         f.close()
1781         return
1782
1783     pass
1784
1785 def convertAmFile(the_root, root, dirs, files, f, module):
1786     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1787     cmake.writeListsFile()
1788     return
1789
1790 def usage(exit_status):
1791     from sys import exit
1792     from sys import argv
1793     print "Usage: %s --module"%(argv[0])
1794     exit(exit_status)
1795     return
1796
1797 if __name__ == "__main__":
1798     #
1799     from sys import argv
1800     if len(argv) != 2:
1801         usage(1)
1802         pass
1803     #
1804     module = argv[1]
1805     if module.find('--') != 0:
1806         usage(1)
1807         pass
1808     module = module[2:]
1809     if len(module) == 0:
1810         usage(1)
1811         pass
1812     #
1813     from os import getcwd
1814     the_root = getcwd()
1815     #
1816     from os import walk
1817     for root, dirs, files in walk(the_root):
1818         # --
1819         # E.A. : Remove 'CVS' in dirs
1820         # E.A. : It allows to not recurse in CVS dirs
1821         # E.A. : See os module python documentation
1822         # --
1823         try:
1824             dirs.remove('CVS')
1825         except ValueError:
1826             pass
1827         # --
1828         if "Makefile.am.cmake" in files:
1829             if "Makefile.am" in files:
1830                 files.remove("Makefile.am")
1831                 pass
1832             pass
1833         # --
1834         for f in files:
1835             if f in ["Makefile.am", "Makefile.am.cmake"]:
1836                 convertAmFile(the_root, root, dirs, files, f, module)
1837                 pass
1838             pass
1839         pass
1840     #
1841     pass