salome_adm/cmake_files/am2cmake.py

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