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         if self.module == "yacs":
 839             key = "salomegui"
 840             if self.root[-len(key):] == key:
 841                 self.files.append("resources/YACSCatalog.xml.in")
 842                 pass
 843             pass
 844         for f in self.files:
 845             if f[-3:] == ".in":
 846                 if f == "sstream.in":
 847                     continue
 848                 if f in ["runContainer.in", "stopContainer.in"]:
 849                     if self.module == "med":
 850                         if self.root[-3:] == "csh":
 851                             continue
 852                         pass
 853                     pass
 854                 if f == "SALOMEconfig.ref.in":
 855                     out = "SALOMEconfig.h"
 856                 else:
 857                     out = f[:-3]
 858                     pass
 859                 newlines.append(r'''
 860                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 861                 '''%(f))
 862                 newlines.append(r'''
 863                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 864                 '''%(out))
 865                 newlines.append(r'''
 866                 MESSAGE(STATUS "Creation of ${output}")
 867                 CONFIGURE_FILE(${input} ${output})
 868                 ''')
 869                 pass
 870             pass
 871
 872         # --
 873         # convert the SUBDIRS in cmake grammar
 874         # --
 875         if 1: # self.__thedict__.has_key("SUBDIRS"):
 876             newlines.append(r'''
 877             FOREACH(dir ${SUBDIRS})
 878             IF(NOT dir STREQUAL .)
 879             ADD_SUBDIRECTORY(${dir})
 880             ENDIF(NOT dir STREQUAL .)
 881             ENDFOREACH(dir ${SUBDIRS})
 882             ''')
 883             pass
 884
 885         # --
 886         # --
 887         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 888             if self.__thedict__.has_key(key):
 889                 self.addLibTarget(key, newlines)
 890                 pass
 891             pass
 892
 893         # --
 894         # --
 895         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
 896             if self.__thedict__.has_key(key):
 897                 self.addBinTarget(key, newlines)
 898                 pass
 899             pass
 900
 901         # --
 902         # --
 903         if self.__thedict__.has_key("BASEIDL_FILES"):
 904             if not self.__thedict__.has_key("IDL_FILES"):
 905                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 906                 newlines.append('''
 907                 SET(IDL_FILES ${BASEIDL_FILES})
 908                 ''')
 909                 pass
 910             pass
 911
 912         # --
 913         # --
 914
 915         key = "IDL_FILES"
 916         if self.__thedict__.has_key(key):
 917             if self.module == "kernel":
 918                 newlines.append('''
 919                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
 920                 ''')
 921                 pass
 922             newlines.append('''
 923             FOREACH(input ${IDL_FILES})
 924             STRING(REGEX REPLACE ".idl" "" base ${input})
 925             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 926             SET(outputs ${src})
 927             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 928             SET(outputs ${outputs} ${dynsrc})
 929             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 930             SET(outputs ${outputs} ${inc})
 931             IF(input STREQUAL Calcium_Ports.idl)
 932             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
 933             ELSE(input STREQUAL Calcium_Ports.idl)
 934             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 935             ENDIF(input STREQUAL Calcium_Ports.idl)
 936             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
 937             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
 938             IF(NOT ISBCXX)
 939             SET(flags -bcxx ${flags})
 940             ENDIF(NOT ISBCXX)
 941             ADD_CUSTOM_COMMAND(
 942             OUTPUT ${outputs}
 943             COMMAND ${OMNIORB_IDL} ${flags} ${input}
 944             MAIN_DEPENDENCY ${input}
 945             )
 946             install(FILES ${input} DESTINATION idl/salome)
 947             SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 948             install(FILES ${IDL_HEADER} DESTINATION include/salome)
 949             INSTALL(CODE "SET(IDL_FILE ${input})")
 950             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 951             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 952             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 953             # --
 954             SET(flags)
 955             FOREACH(f ${IDLPYFLAGS})
 956             SET(flags "${flags} ${f}")
 957             ENDFOREACH(f ${IDLPYFLAGS})
 958             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
 959             IF(NOT ISBPYTHON)
 960             SET(flags "-bpython ${flags}")
 961             ENDIF(NOT ISBPYTHON)
 962             SET(IDLPYFLAGS ${flags})
 963             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 964             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 965             # --
 966             ''')
 967             if self.module == "kernel":
 968                 newlines.append('''
 969                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 970                 ''')
 971             else:
 972                 newlines.append('''
 973                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 974                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 975                 ''')
 976                 pass
 977             newlines.append('''
 978             ENDFOREACH(input ${IDL_FILES})
 979             ''')
 980             pass
 981
 982         # --
 983         # --
 984         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
 985             if self.__thedict__.has_key(key):
 986                 newlines.append('''
 987                 SET(SWIG_SOURCES ${%s})
 988                 '''%(key))
 989                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
 990                 pass
 991             pass
 992
 993         # --
 994         # --
 995         if self.__thedict__.has_key("SWIG_SOURCES"):
 996             newlines.append('''
 997             IF(SWIG_SOURCES MATCHES ";")
 998             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 999             ELSE(SWIG_SOURCES MATCHES ";")
1000             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1001             ENDIF(SWIG_SOURCES MATCHES ";")
1002             ADD_CUSTOM_COMMAND(
1003             OUTPUT ${build_srcs}
1004             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1005             MAIN_DEPENDENCY ${SWIG_SOURCES}
1006             )
1007             ''')
1008             pass
1009
1010         # --
1011         # --
1012         if self.__thedict__.has_key("BUILT_SOURCES"):
1013             newlines.append('''
1014             FOREACH(f ${BUILT_SOURCES})
1015             IF(f MATCHES "WRAP.cxx$")
1016             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1017             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1018             ADD_CUSTOM_COMMAND(
1019             OUTPUT ${f} # ${inc}
1020             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1021             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1022             )
1023             ENDIF(f MATCHES "WRAP.cxx$")
1024             ENDFOREACH(f ${BUILT_SOURCES})
1025             ''')
1026             pass
1027
1028         # --
1029         # --
1030         key = "MOC_FILES"
1031         if self.__thedict__.has_key(key):
1032             newlines.append('''
1033             FOREACH(output ${MOC_FILES})
1034             ''')
1035             if self.module == "yacs":
1036                 newlines.append('''
1037                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1038                 ''')
1039             else:
1040                 newlines.append('''
1041                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1042                 ''')
1043                 pass
1044             newlines.append('''
1045             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1046             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1047             ADD_CUSTOM_COMMAND(
1048             OUTPUT ${output}
1049             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1050             MAIN_DEPENDENCY ${input}
1051             )
1052             ENDFOREACH(output ${MOC_FILES})
1053             ''')
1054             pass
1055
1056         # --
1057         # --
1058         key = "UIC_FILES"
1059         if self.__thedict__.has_key(key):
1060             newlines.append('''
1061             FOREACH(output ${UIC_FILES})
1062             STRING(REPLACE "ui_" "" input ${output})
1063             STRING(REPLACE ".h" ".ui" input ${input})
1064             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1065             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1066             ADD_CUSTOM_COMMAND(
1067             OUTPUT ${output}
1068             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1069             MAIN_DEPENDENCY ${input}
1070             )
1071             ENDFOREACH(output ${UIC_FILES})
1072             ''')
1073             pass
1074
1075         # --
1076         # --
1077         key = "QRC_FILES"
1078         if self.__thedict__.has_key(key):
1079             newlines.append('''
1080             FOREACH(output ${QRC_FILES})
1081             STRING(REGEX REPLACE "qrc_" "" input ${output})
1082             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1083             STRING(REGEX REPLACE ".qrc" "" name ${input})
1084             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1085             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1086             ADD_CUSTOM_COMMAND(
1087             OUTPUT ${output}
1088             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1089             MAIN_DEPENDENCY ${input}
1090             )
1091             ENDFOREACH(output ${QRC_FILES})
1092             ''')
1093             pass
1094
1095         # --
1096         # --
1097         key = "SIP_FILES"
1098         if self.__thedict__.has_key(key):
1099             newlines.append('''
1100             FOREACH(input ${SIP_FILES})
1101             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1102             SET(output)
1103             FOREACH(out ${SIP_SRC})
1104             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1105             ENDFOREACH(out ${SIP_SRC})
1106             ADD_CUSTOM_COMMAND(
1107             OUTPUT ${output}
1108             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1109             MAIN_DEPENDENCY ${input}
1110             )
1111             ENDFOREACH(input ${SIP_FILES})
1112             ''')
1113             pass
1114
1115         # --
1116         # Treat the install targets
1117         # --
1118         d = {
1119             "salomeadmux_DATA"            :  "salome_adm/unix",
1120             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1121             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1122             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1123             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1124             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1125             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1126             "salomeinclude_DATA"          :  "include/salome",
1127             "salomeinclude_HEADERS"       :  "include/salome",
1128             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1129             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1130             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1131             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1132             "dist_salomescript_DATA"      :  "bin/salome",
1133             "dist_salomescript_PYTHON"    :  "bin/salome",
1134             "nodist_salomescript_DATA"    :  "bin/salome",
1135             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1136             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1137             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1138             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1139             }
1140         if self.module == "medfile":
1141             d = {
1142                 "include_HEADERS"        :  "include",
1143                 "nodist_include_HEADERS" :  "include",
1144                 "bin_SCRIPTS"            :  "bin",
1145                 "doc_DATA"               :  "${docdir}",
1146                 }
1147             pass
1148         for key, value in d.items():
1149             if self.__thedict__.has_key(key):
1150                 self.addInstallTarget(key, value, newlines)
1151                 pass
1152             pass
1153
1154         # --
1155         return
1156
1157     def setLibAdd(self, key, newlines):
1158         # --
1159         newlines.append(r'''
1160         SET(libadd)
1161         ''')
1162         # --
1163         newlines.append(r'''
1164         IF(WINDOWS)
1165         SET(targets)
1166         SET(targets ${targets} MEFISTO2D)
1167         FOREACH(target ${targets})
1168         IF(name STREQUAL ${target})
1169         SET(dir $ENV{F2CHOME})
1170         STRING(REPLACE "\\\\" "/" dir ${dir})
1171         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1172         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1173         ENDIF(name STREQUAL ${target})
1174         ENDFOREACH(target ${targets})
1175         ENDIF(WINDOWS)
1176         ''')
1177         # --
1178         newlines.append(r'''
1179         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1180         FOREACH(lib SALOMEBasics SalomeBatch)
1181         IF(name STREQUAL lib)
1182         SET(libs ${libs} ${PTHREAD_LIBS})
1183         ENDIF(name STREQUAL lib)
1184         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1185         ''')
1186         if key == "bin_PROGRAMS":
1187             newlines.append(r'''
1188             SET(libs ${libs} ${LDADD})
1189             ''')
1190             pass
1191         # --
1192         newlines.append(r'''
1193         FOREACH(lib ${libs})
1194         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1195         IF(ext STREQUAL .la)
1196         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1197         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1198         ENDIF(ext STREQUAL .la)
1199         SET(vars)
1200         SET(vars ${vars} -no-undefined)
1201         SET(vars ${vars} -lvtkWidgets)
1202         IF(WINDOWS)
1203         SET(vars ${vars} -module)
1204         SET(vars ${vars} -Wl,-E)
1205         SET(vars ${vars} -Xlinker)
1206         SET(vars ${vars} -export-dynamic)
1207         SET(vars ${vars} -lm)
1208         SET(vars ${vars} -lboost_thread)
1209         SET(vars ${vars} -lboost_signals)
1210         SET(vars ${vars} -pthread -lpthread -ldl)
1211         ENDIF(WINDOWS)
1212         FOREACH(v ${vars})
1213         IF(lib STREQUAL v)
1214         SET(lib)
1215         ENDIF(lib STREQUAL v)
1216         ENDFOREACH(v ${vars})
1217         SET(libadd ${libadd} ${lib})
1218         ENDFOREACH(lib ${libs})
1219         TARGET_LINK_LIBRARIES(${name} ${libadd})
1220         ''')
1221         # --
1222         newlines.append(r'''
1223         IF(WINDOWS)
1224         SET(targets)
1225         SET(targets ${targets} MEFISTO2D)
1226         FOREACH(target ${targets})
1227         IF(name STREQUAL ${target})
1228         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1229         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1230         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1231         ENDIF(name STREQUAL ${target})
1232         ENDFOREACH(target ${targets})
1233         ENDIF(WINDOWS)
1234         ''')
1235         # --
1236         return
1237
1238     def setCompilationFlags(self, key, newlines):
1239         newlines.append(r'''
1240         SET(var)
1241         IF(WINDOWS)
1242         SET(targets)
1243         SET(targets ${targets} SalomeIDLKernel)
1244         SET(targets ${targets} SalomeDS)
1245         SET(targets ${targets} SALOMEDSTest)
1246         SET(targets ${targets} SALOMEDS_Client_exe)
1247         SET(targets ${targets} SalomeIDLGEOM)
1248         SET(targets ${targets} GEOMEngine)
1249         SET(targets ${targets} MEDEngine)
1250         SET(targets ${targets} SMESHEngine)
1251         SET(targets ${targets} SMESH)
1252         FOREACH(target ${targets})
1253         IF(name STREQUAL ${target})
1254         SET(var ${var} -DNOGDI)
1255         ENDIF(name STREQUAL ${target})
1256         ENDFOREACH(target ${targets})
1257         ENDIF(WINDOWS)
1258         ''')
1259         # --
1260         if self.module in ["medfile", "yacs"]:
1261             newlines.append(r'''
1262             IF(WINDOWS)
1263             SET(var ${var} -DNOGDI)
1264             ENDIF(WINDOWS)
1265             ''')
1266             pass
1267         # --
1268         newlines.append(r'''
1269         IF(WINDOWS)
1270         SET(targets)
1271         SET(targets ${targets} MEFISTO2D)
1272         FOREACH(target ${targets})
1273         IF(name STREQUAL ${target})
1274         SET(dir $ENV{F2CHOME})
1275         STRING(REPLACE "\\\\" "/" dir ${dir})
1276         SET(var ${var} -I${dir})
1277         SET(var ${var} -DF2C_BUILD)
1278         ENDIF(name STREQUAL ${target})
1279         ENDFOREACH(target ${targets})
1280         ENDIF(WINDOWS)
1281         ''')
1282         # --
1283         if self.module in ["geom", "med"]:
1284             newlines.append(r'''
1285             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1286             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1287             ''')
1288             pass
1289         newlines.append(r'''
1290         SET(var ${var} ${AM_CPPFLAGS})
1291         SET(var ${var} ${AM_CXXFLAGS})
1292         ''')
1293         if self.module == "yacs":
1294             newlines.append(r'''
1295             SET(var ${var} -DYACS_PTHREAD)
1296             SET(var ${var} -DCMAKE_BUILD)
1297             SET(var ${var} -DSALOME_KERNEL)
1298             SET(var ${var} -DDSC_PORTS)
1299             SET(var ${var} -DOMNIORB)
1300             ''')
1301             pass
1302         newlines.append(r'''
1303         SET(var ${var} ${PLATFORM_CPPFLAGS})
1304         SET(var ${var} ${PTHREAD_CFLAGS})
1305         SET(var ${var} ${${amname}_CPPFLAGS})
1306         SET(var ${var} ${${amname}_CXXFLAGS})
1307         SET(var ${var} ${${amname}_CFLAGS})
1308         SET(vars)
1309         IF(WINDOWS)
1310         SET(vars ${vars} -include SALOMEconfig.h)
1311         SET(vars ${vars} -ftemplate-depth-32)
1312         SET(vars ${vars} -fPIC)
1313         SET(vars ${vars} -g)
1314         ENDIF(WINDOWS)
1315         SET(flags)
1316         FOREACH(f ${var})
1317         FOREACH(v ${vars})
1318         IF(f STREQUAL v)
1319         SET(f)
1320         ENDIF(f STREQUAL v)
1321         ENDFOREACH(v ${vars})
1322         SET(flags "${flags} ${f}")
1323         ENDFOREACH(f ${var})
1324         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1325         ''')
1326         return
1327
1328     def addLibTarget(self, key, newlines):
1329         newlines.append(r'''
1330         FOREACH(amname ${%s})
1331         '''%(key))
1332         # --
1333         # Replace .la by _la ...
1334         # --
1335         newlines.append(r'''
1336         STRING(REPLACE .la _la amname ${amname})
1337         ''')
1338         # --
1339         # Remove the _la for the cmake name
1340         # --
1341         newlines.append(r'''
1342         STRING(LENGTH ${amname} len)
1343         MATH(EXPR newlen "${len}-3")
1344         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1345         ''')
1346         # --
1347         # Does the target begins with lib ??
1348         # If yes, remove lib at beginning for cmake name
1349         # --
1350         newlines.append(r'''
1351         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1352         IF(BEGIN_WITH_lib)
1353         STRING(LENGTH ${name} len)
1354         MATH(EXPR newlen "${len}-3")
1355         STRING(SUBSTRING ${name} 3 ${newlen} name)
1356         ENDIF(BEGIN_WITH_lib)
1357         ''')
1358         # --
1359         # Does the target is an idl library
1360         # --
1361         newlines.append(r'''
1362         STRING(REGEX MATCH "IDL" ISIDL ${name})
1363         ''')
1364         # --
1365         # Set the type of the library
1366         # --
1367         newlines.append(r'''
1368         IF(ISIDL)
1369         IF(WINDOWS)
1370         SET(type STATIC)
1371         ELSE(WINDOWS)
1372         SET(type SHARED)
1373         ENDIF(WINDOWS)
1374         ELSE(ISIDL)
1375         SET(type SHARED)
1376         ENDIF(ISIDL)
1377         ''')
1378         # --
1379         # Set sources for the library
1380         # --
1381         newlines.append(r'''
1382         SET(srcs)
1383         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1384         GET_FILENAME_COMPONENT(ext ${src} EXT)
1385         IF(ext STREQUAL .f)
1386         IF(src STREQUAL trte.f)
1387         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1388         STRING(REPLACE ".f" ".c" src ${src})
1389         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1390         SET(output ${src})
1391         ADD_CUSTOM_COMMAND(
1392         OUTPUT ${output}
1393         COMMAND f2c ${input}
1394         MAIN_DEPENDENCY ${input}
1395         )
1396         ELSE(src STREQUAL trte.f)
1397         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1398         STRING(REPLACE ".f" ".o" src ${src})
1399         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1400         SET(output ${src})
1401         IF(WINDOWS)
1402         SET(F77 g77)
1403         ELSE(WINDOWS)
1404         SET(F77 gfortran)
1405         ENDIF(WINDOWS)
1406         ADD_CUSTOM_COMMAND(
1407         OUTPUT ${output}
1408         COMMAND ${F77} -c -o ${output} ${input}
1409         MAIN_DEPENDENCY ${input}
1410         )
1411         ENDIF(src STREQUAL trte.f)
1412         ENDIF(ext STREQUAL .f)
1413         SET(srcs ${srcs} ${src})
1414         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1415         ''')
1416         newlines.append(r'''
1417         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1418         FOREACH(f ${l})
1419         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1420         SET(srcs ${srcs} ${src})
1421         ENDFOREACH(f ${l})
1422         ''')
1423         newlines.append(r'''
1424         SET(build_srcs)
1425         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1426         FOREACH(f ${l})
1427         GET_FILENAME_COMPONENT(ext ${f} EXT)
1428         IF(ext STREQUAL .py)
1429         ELSE(ext STREQUAL .py)
1430         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1431         ENDIF(ext STREQUAL .py)
1432         ENDFOREACH(f ${l})
1433         ''')
1434         # --
1435         # Add the library to cmake
1436         # --
1437         newlines.append(r'''
1438         ADD_LIBRARY(${name} ${type} ${srcs})
1439         ''')
1440         # --
1441         # The compilation flags
1442         # --
1443         self.setCompilationFlags(key, newlines)
1444         # --
1445         newlines.append(r'''
1446         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1447         ''')
1448         # --
1449         self.setLibAdd(key, newlines)
1450         # --
1451         if 1: # key != "noinst_LTLIBRARIES":
1452             if self.module == "medfile":
1453                 newlines.append(r'''
1454                 SET(DEST lib)
1455                 ''')
1456             else:
1457                 newlines.append(r'''
1458                 SET(DEST lib/salome)
1459                 ''')
1460                 pass
1461             newlines.append(r'''
1462             IF(BEGIN_WITH_lib)
1463             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1464             ''')
1465             if self.module == "gui":
1466                 newlines.append(r'''
1467                 FOREACH(lib SalomePyQt)
1468                 IF(name STREQUAL lib)
1469                 IF(WINDOWS)
1470                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1471                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1472                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1473                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1474                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1475                 ELSE(WINDOWS)
1476                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1477                 ENDIF(WINDOWS)
1478                 ENDIF(name STREQUAL lib)
1479                 ENDFOREACH(lib SalomePyQt)
1480                 FOREACH(lib SalomePy)
1481                 IF(name STREQUAL lib)
1482                 IF(WINDOWS)
1483                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1484                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1485                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1486                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1487                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1488                 ENDIF(WINDOWS)
1489                 ENDIF(name STREQUAL lib)
1490                 ENDFOREACH(lib SalomePy)
1491                 ''')
1492                 pass
1493             if self.module == "geom":
1494                 newlines.append(r'''
1495                 IF(WINDOWS)
1496                 STRING(REGEX MATCH "Export" ISExport ${name})
1497                 IF(ISExport)
1498                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1499                 ENDIF(ISExport)
1500                 STRING(REGEX MATCH "Import" ISImport ${name})
1501                 IF(ISImport)
1502                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1503                 ENDIF(ISImport)
1504                 ENDIF(WINDOWS)
1505                 ''')
1506                 pass
1507             newlines.append(r'''
1508             ELSE(BEGIN_WITH_lib)
1509             ''')
1510             newlines.append(r'''
1511             IF(WINDOWS)
1512             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1513             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1514             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)
1515             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1516             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)
1517             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1518             ELSE(WINDOWS)
1519             GET_TARGET_PROPERTY(version ${name} VERSION)
1520             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1521             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1522             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1523             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1524             ENDIF(WINDOWS)
1525             ''')
1526             newlines.append(r'''
1527             ENDIF(BEGIN_WITH_lib)
1528             ''')
1529             pass
1530         # --
1531         newlines.append(r'''
1532         ENDFOREACH(amname ${%s})
1533         '''%(key))
1534         # --
1535         return
1536
1537     def addBinTarget(self, key, newlines):
1538         # --
1539         newlines.append(r'''
1540         FOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1541         ''')
1542         # --
1543         newlines.append(r'''
1544         SET(name "${amname}_exe")
1545         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1546         SET(l ${nodist_${amname}_SOURCES})
1547         FOREACH(f ${l})
1548         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1549         SET(srcs ${srcs} ${src})
1550         ENDFOREACH(f ${l})
1551         LIST(LENGTH srcs nb)
1552         IF(nb)
1553         ADD_EXECUTABLE(${name} ${srcs})
1554         ''')
1555         # --
1556         self.setCompilationFlags(key, newlines)
1557         # --
1558         self.setLibAdd(key, newlines)
1559         # --
1560         if self.module == "medfile":
1561             newlines.append(r'''
1562             SET(DEST bin)
1563             ''')
1564         else:
1565             newlines.append(r'''
1566             SET(DEST bin/salome)
1567             ''')
1568             pass
1569         # --
1570         if key == "bin_PROGRAMS":
1571             newlines.append(r'''
1572             IF(WINDOWS)
1573             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1574             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1575             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1576             ELSE(WINDOWS)
1577             SET(PERMS)
1578             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1579             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1580             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1581             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1582             ENDIF(WINDOWS)
1583             ''')
1584             pass
1585         # --
1586         newlines.append(r'''
1587         ENDIF(nb)
1588         ''')
1589         # --
1590         newlines.append(r'''
1591         ENDFOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1592         ''')
1593         # --
1594         return
1595
1596     def addInstallTarget(self, key, destination, newlines):
1597         newlines.append(r"FOREACH(f ${%s})"%(key))
1598         newlines.append(r'''
1599         SET(DEST %s)
1600         '''%(destination))
1601         newlines.append(r'''
1602         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1603         IF(test_SALOMEconfig.h.in)
1604         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1605         ELSE(test_SALOMEconfig.h.in)
1606         SET(dummy dummy-NOTFOUND)
1607         MARK_AS_ADVANCED(dummy)
1608         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1609         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1610         IF(dummy)
1611         ''')
1612         if key in ['dist_salomescript_SCRIPTS']:
1613             newlines.append(r'''
1614             SET(PERMS)
1615             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1616             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1617             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1618             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1619             ''')
1620         else:
1621             newlines.append(r'''
1622             GET_FILENAME_COMPONENT(ext ${f} EXT)
1623             IF(ext STREQUAL .py)
1624             IF(DEST STREQUAL bin/salome)
1625             SET(PERMS)
1626             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1627             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1628             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1629             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1630             ELSE(DEST STREQUAL bin/salome)
1631             INSTALL(FILES ${f} DESTINATION ${DEST})
1632             ENDIF(DEST STREQUAL bin/salome)
1633             ELSE(ext STREQUAL .py)
1634             INSTALL(FILES ${f} DESTINATION ${DEST})
1635             ENDIF(ext STREQUAL .py)
1636             ''')
1637             pass
1638         newlines.append(r'''
1639         ELSE(dummy)
1640         GET_FILENAME_COMPONENT(ext ${f} EXT)
1641         IF(ext STREQUAL .qm)
1642         STRING(REGEX REPLACE .qm .ts input ${f})
1643         ''')
1644         if self.module in ["kernel", "gui", "yacs"]:
1645             newlines.append(r'''
1646             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1647             ''')
1648         else:
1649             newlines.append(r'''
1650             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1651             ''')
1652             pass
1653         newlines.append(r'''
1654         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1655         # ADD_CUSTOM_COMMAND(
1656         # OUTPUT ${output}
1657         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1658         # MAIN_DEPENDENCY ${input}
1659         # )
1660         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1661         ENDIF(ext STREQUAL .qm)
1662         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1663         ENDIF(dummy)
1664         ENDIF(test_SALOMEconfig.h.in)
1665         ''')
1666         newlines.append(r'''
1667         GET_FILENAME_COMPONENT(ext ${f} EXT)
1668         IF(ext STREQUAL .py)
1669         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1670         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1671         INSTALL(CODE "SET(DEST ${DEST})")
1672         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1673         ''')
1674         if self.module == "kernel":
1675             newlines.append('''
1676             IF(f STREQUAL SALOME_ContainerPy.py)
1677             ELSE(f STREQUAL SALOME_ContainerPy.py)
1678             IF(f STREQUAL am2cmake.py)
1679             ELSE(f STREQUAL am2cmake.py)
1680             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1681             ENDIF(f STREQUAL am2cmake.py)
1682             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1683             ''')
1684         else:
1685             newlines.append('''
1686             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1687             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1688             ''')
1689             pass
1690         newlines.append(r'''
1691         ENDIF(ext STREQUAL .py)
1692         ''')
1693         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1694         return
1695
1696     def writeListsFile(self):
1697         f = open(self.listsFile, "w")
1698         f.write(self.content)
1699         f.close()
1700         return
1701
1702     pass
1703
1704 def convertAmFile(the_root, root, dirs, files, f, module):
1705     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1706     cmake.writeListsFile()
1707     return
1708
1709 def usage(exit_status):
1710     from sys import exit
1711     from sys import argv
1712     print "Usage: %s --module"%(argv[0])
1713     exit(exit_status)
1714     return
1715
1716 if __name__ == "__main__":
1717     #
1718     from sys import argv
1719     if len(argv) != 2:
1720         usage(1)
1721         pass
1722     #
1723     module = argv[1]
1724     if module.find('--') != 0:
1725         usage(1)
1726         pass
1727     module = module[2:]
1728     if len(module) == 0:
1729         usage(1)
1730         pass
1731     #
1732     from os import getcwd
1733     the_root = getcwd()
1734     #
1735     from os import walk
1736     for root, dirs, files in walk(the_root):
1737         # --
1738         # E.A. : Remove 'CVS' in dirs
1739         # E.A. : It allows to not recurse in CVS dirs
1740         # E.A. : See os module python documentation
1741         # --
1742         try:
1743             dirs.remove('CVS')
1744         except ValueError:
1745             pass
1746         # --
1747         if "Makefile.am.cmake" in files:
1748             if "Makefile.am" in files:
1749                 files.remove("Makefile.am")
1750                 pass
1751             pass
1752         # --
1753         for f in files:
1754             if f in ["Makefile.am", "Makefile.am.cmake"]:
1755                 convertAmFile(the_root, root, dirs, files, f, module)
1756                 pass
1757             pass
1758         pass
1759     #
1760     pass