salome_adm/cmake_files/am2cmake.py

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