salome_adm/cmake_files/am2cmake.py

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