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