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             newlines.append(r'''
 642             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 643             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 644             ''')
 645             pass
 646         # --
 647         return
 648
 649     def treatLine(self, line, newlines, opened_ifs):
 650
 651         # --
 652         # Print the comment above the line itself
 653         # --
 654         if line.find('#') >= 0:
 655             fields = line.split('#')
 656             line = fields[0]
 657             comment = '#'.join([''] + fields[1:])
 658             newlines.append(comment)
 659             if len(line) == 0:
 660                 return
 661             pass
 662
 663         # --
 664         # If the line begins with 'include ', just comment it
 665         # --
 666         if line.find("include ") == 0:
 667             newlines.append("# " + line)
 668             return
 669
 670         # --
 671         # If the line begins with '-include', just comment it
 672         # --
 673         if line.find("-include") == 0:
 674             newlines.append("# " + line)
 675             return
 676
 677         # --
 678         # If the line is a definition of a make rule, just comment it
 679         # --
 680         if line.count(':') == 1:
 681             newlines.append("# " + line)
 682             return
 683
 684         # --
 685         # A particuliar case where there are two ":" on the same line
 686         # --
 687         if line.find('install-exec-local:') == 0:
 688             newlines.append("# " + line)
 689             return
 690
 691         # --
 692         # If the line begin by a tabulation, consider it's a makefile command and comment it
 693         # --
 694         if line.find("\t") == 0:
 695             newlines.append("# " + line)
 696             return
 697
 698         # --
 699         # --
 700         key = "-version-info"
 701         if line.find(key) >= 0:
 702             # --
 703             before = line.split(key)[0]
 704             after = line[len(before)+len(key):]
 705             sep = after[0]
 706             after = after[1:]
 707             version_info = after.split()[0]
 708             line = line.replace(key+sep+version_info, "")
 709             # --
 710             version_info = version_info.replace(':', '.')
 711             soversion_info = version_info.split('.')[0]
 712             newlines.append("SET(VERSION_INFO " + version_info + ")")
 713             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 714             # --
 715             pass
 716
 717         # --
 718         # Replace the $(TOTO) by ${TOTO}
 719         # Replace the @TOTO@  by ${TOTO}
 720         # --
 721         line = p_dollar.sub(r"${\1}", line)
 722         line = p_arobas.sub(r"${\1}", line)
 723
 724         # --
 725         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 726         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 727         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 728         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 729         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 730
 731         # --
 732         # Check if the line is a 'if' condition
 733         # If yes, replace it by a cmake grammar
 734         # --
 735         match = p_if.match(line)
 736         if match:
 737             theif = match.group("val")
 738             if theif[0] == "!":
 739                 theif = "NOT " + theif[1:]
 740                 pass
 741             line = p_if.sub(r"IF(%s)"%(theif), line)
 742             opened_ifs.append(theif)
 743             newlines.append(line)
 744             return
 745
 746         # --
 747         # Check if the line is a 'else' condition
 748         # If yes, replace it by a cmake grammar
 749         # --
 750         match = p_else.match(line)
 751         if match:
 752             line = "ELSE(%s)"%(opened_ifs[-1])
 753             newlines.append(line)
 754             return
 755
 756         # --
 757         # Check if the line is a 'endif' condition
 758         # If yes, replace it by a cmake grammar
 759         # --
 760         match = p_endif.match(line)
 761         if match:
 762             line = "ENDIF(%s)"%(opened_ifs[-1])
 763             opened_ifs[-1:] = []
 764             newlines.append(line)
 765             return
 766
 767         # --
 768         # Check if the line is an attribution '=' or '+='
 769         # --
 770         match = p_attribution.match(line)
 771         if match:
 772             self.treatAttribution(match, newlines)
 773             return
 774
 775         # --
 776         newlines.append(line)
 777
 778         # --
 779         return
 780
 781     def treatAttribution(self, match, newlines):
 782
 783         spaces = match.group("spaces")
 784         key = match.group("key")
 785         method = match.group("method")
 786         value = match.group("value")
 787         # print [spaces, key, method, value]
 788
 789         # --
 790         # Open cmake SET command
 791         # --
 792         newlines.append(spaces + "SET(" + key)
 793
 794         # --
 795         # If method is '+=', put the previous definition as first value
 796         # --
 797         if method == "+=":
 798             newlines.append("%s    ${%s}"%(spaces, key))
 799             pass
 800
 801         # --
 802         fields = value.split()
 803         for i in range(len(fields)):
 804             newlines.append("%s    %s"%(spaces, fields[i]))
 805             pass
 806
 807         # --
 808         if method == "+=":
 809             # --
 810             # The try: except KeyError is here if the +=
 811             # is an error which occurs in salome ...
 812             # --
 813             try:
 814                 self.__thedict__[key] += fields[:]
 815             except KeyError:
 816                 self.__thedict__[key] = fields[:]
 817                 pass
 818             pass
 819         else:
 820             self.__thedict__[key]  = fields[:]
 821             pass
 822
 823         # --
 824         # Close cmake SET command
 825         # --
 826
 827         newlines.append("%s)"%(spaces))
 828
 829         return
 830
 831     def finalize(self, newlines):
 832
 833         # --
 834         # Convert the .in files in build dir
 835         # --
 836         for f in self.files:
 837             if f[-3:] == ".in":
 838                 if f == "sstream.in":
 839                     continue
 840                 if f in ["runContainer.in", "stopContainer.in"]:
 841                     if self.module == "med":
 842                         if self.root[-3:] == "csh":
 843                             continue
 844                         pass
 845                     pass
 846                 if f == "SALOMEconfig.ref.in":
 847                     out = "SALOMEconfig.h"
 848                 else:
 849                     out = f[:-3]
 850                     pass
 851                 newlines.append(r'''
 852                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 853                 '''%(f))
 854                 newlines.append(r'''
 855                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 856                 '''%(out))
 857                 newlines.append(r'''
 858                 MESSAGE(STATUS "Creation of ${output}")
 859                 CONFIGURE_FILE(${input} ${output})
 860                 ''')
 861                 pass
 862             pass
 863
 864         # --
 865         # convert the SUBDIRS in cmake grammar
 866         # --
 867         if 1: # self.__thedict__.has_key("SUBDIRS"):
 868             newlines.append(r'''
 869             FOREACH(dir ${SUBDIRS})
 870             IF(NOT dir STREQUAL .)
 871             ADD_SUBDIRECTORY(${dir})
 872             ENDIF(NOT dir STREQUAL .)
 873             ENDFOREACH(dir ${SUBDIRS})
 874             ''')
 875             pass
 876
 877         # --
 878         # --
 879         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 880             if self.__thedict__.has_key(key):
 881                 self.addLibTarget(key, newlines)
 882                 pass
 883             pass
 884
 885         # --
 886         # --
 887         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
 888             if self.__thedict__.has_key(key):
 889                 self.addBinTarget(key, newlines)
 890                 pass
 891             pass
 892
 893         # --
 894         # --
 895         if self.__thedict__.has_key("BASEIDL_FILES"):
 896             if not self.__thedict__.has_key("IDL_FILES"):
 897                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 898                 newlines.append('''
 899                 SET(IDL_FILES ${BASEIDL_FILES})
 900                 ''')
 901                 pass
 902             pass
 903
 904         # --
 905         # --
 906
 907         key = "IDL_FILES"
 908         if self.__thedict__.has_key(key):
 909             if self.module == "kernel":
 910                 newlines.append('''
 911                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
 912                 ''')
 913                 pass
 914             newlines.append('''
 915             FOREACH(input ${IDL_FILES})
 916             STRING(REGEX REPLACE ".idl" "" base ${input})
 917             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 918             SET(outputs ${src})
 919             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 920             SET(outputs ${outputs} ${dynsrc})
 921             IF(input STREQUAL Calcium_Ports.idl)
 922             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
 923             ELSE(input STREQUAL Calcium_Ports.idl)
 924             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 925             ENDIF(input STREQUAL Calcium_Ports.idl)
 926             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
 927             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
 928             IF(NOT ISBCXX)
 929             SET(flags -bcxx ${flags})
 930             ENDIF(NOT ISBCXX)
 931             ADD_CUSTOM_COMMAND(
 932             OUTPUT ${outputs}
 933             COMMAND ${OMNIORB_IDL} ${flags} ${input}
 934             MAIN_DEPENDENCY ${input}
 935             )
 936             install(FILES ${input} DESTINATION idl/salome)
 937             SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 938             install(FILES ${IDL_HEADER} DESTINATION include/salome)
 939             INSTALL(CODE "SET(IDL_FILE ${input})")
 940             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 941             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 942             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 943             # --
 944             SET(flags)
 945             FOREACH(f ${IDLPYFLAGS})
 946             SET(flags "${flags} ${f}")
 947             ENDFOREACH(f ${IDLPYFLAGS})
 948             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
 949             IF(NOT ISBPYTHON)
 950             SET(flags "-bpython ${flags}")
 951             ENDIF(NOT ISBPYTHON)
 952             SET(IDLPYFLAGS ${flags})
 953             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 954             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 955             # --
 956             ''')
 957             if self.module == "kernel":
 958                 newlines.append('''
 959                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 960                 ''')
 961             else:
 962                 newlines.append('''
 963                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 964                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 965                 ''')
 966                 pass
 967             newlines.append('''
 968             ENDFOREACH(input ${IDL_FILES})
 969             ''')
 970             pass
 971
 972         # --
 973         # --
 974         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
 975             if self.__thedict__.has_key(key):
 976                 newlines.append('''
 977                 SET(SWIG_SOURCES ${%s})
 978                 '''%(key))
 979                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
 980                 pass
 981             pass
 982
 983         # --
 984         # --
 985         if self.__thedict__.has_key("SWIG_SOURCES"):
 986             newlines.append('''
 987             IF(SWIG_SOURCES MATCHES ";")
 988             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 989             ELSE(SWIG_SOURCES MATCHES ";")
 990             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 991             ENDIF(SWIG_SOURCES MATCHES ";")
 992             ADD_CUSTOM_COMMAND(
 993             OUTPUT ${build_srcs}
 994             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
 995             MAIN_DEPENDENCY ${SWIG_SOURCES}
 996             )
 997             ''')
 998             pass
 999
1000         # --
1001         # --
1002         key = "MOC_FILES"
1003         if self.__thedict__.has_key(key):
1004             newlines.append('''
1005             FOREACH(output ${MOC_FILES})
1006             STRING(REGEX REPLACE _moc.cxx .h input ${output})
1007             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1008             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1009             ADD_CUSTOM_COMMAND(
1010             OUTPUT ${output}
1011             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1012             MAIN_DEPENDENCY ${input}
1013             )
1014             ENDFOREACH(output ${MOC_FILES})
1015             ''')
1016             pass
1017
1018         # --
1019         # --
1020         key = "UIC_FILES"
1021         if self.__thedict__.has_key(key):
1022             newlines.append('''
1023             FOREACH(output ${UIC_FILES})
1024             STRING(REPLACE "ui_" "" input ${output})
1025             STRING(REPLACE ".h" ".ui" input ${input})
1026             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1027             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1028             ADD_CUSTOM_COMMAND(
1029             OUTPUT ${output}
1030             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1031             MAIN_DEPENDENCY ${input}
1032             )
1033             ENDFOREACH(output ${UIC_FILES})
1034             ''')
1035             pass
1036
1037         # --
1038         # --
1039         key = "QRC_FILES"
1040         if self.__thedict__.has_key(key):
1041             newlines.append('''
1042             FOREACH(output ${QRC_FILES})
1043             STRING(REGEX REPLACE "qrc_" "" input ${output})
1044             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1045             STRING(REGEX REPLACE ".qrc" "" name ${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_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1051             MAIN_DEPENDENCY ${input}
1052             )
1053             ENDFOREACH(output ${QRC_FILES})
1054             ''')
1055             pass
1056
1057         # --
1058         # --
1059         key = "SIP_FILES"
1060         if self.__thedict__.has_key(key):
1061             newlines.append('''
1062             FOREACH(input ${SIP_FILES})
1063             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1064             SET(output)
1065             FOREACH(out ${SIP_SRC})
1066             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1067             ENDFOREACH(out ${SIP_SRC})
1068             ADD_CUSTOM_COMMAND(
1069             OUTPUT ${output}
1070             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1071             MAIN_DEPENDENCY ${input}
1072             )
1073             ENDFOREACH(input ${SIP_FILES})
1074             ''')
1075             pass
1076
1077         # --
1078         # Treat the install targets
1079         # --
1080         d = {
1081             "salomeadmux_DATA"            :  "salome_adm/unix",
1082             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1083             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1084             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1085             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1086             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1087             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1088             "salomeinclude_DATA"          :  "include/salome",
1089             "salomeinclude_HEADERS"       :  "include/salome",
1090             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1091             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1092             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1093             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1094             "dist_salomescript_DATA"      :  "bin/salome",
1095             "dist_salomescript_PYTHON"    :  "bin/salome",
1096             "nodist_salomescript_DATA"    :  "bin/salome",
1097             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1098             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1099             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1100             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1101             }
1102         if self.module == "medfile":
1103             d = {
1104                 "include_HEADERS"        :  "include",
1105                 "nodist_include_HEADERS" :  "include",
1106                 "bin_SCRIPTS"            :  "bin",
1107                 "doc_DATA"               :  "${docdir}",
1108                 }
1109             pass
1110         for key, value in d.items():
1111             if self.__thedict__.has_key(key):
1112                 self.addInstallTarget(key, value, newlines)
1113                 pass
1114             pass
1115
1116         # --
1117         return
1118
1119     def setLibAdd(self, key, newlines):
1120         # --
1121         newlines.append(r'''
1122         SET(libadd)
1123         ''')
1124         # --
1125         newlines.append(r'''
1126         IF(WINDOWS)
1127         SET(targets)
1128         SET(targets ${targets} MEFISTO2D)
1129         FOREACH(target ${targets})
1130         IF(name STREQUAL ${target})
1131         SET(dir $ENV{F2CHOME})
1132         STRING(REPLACE "\\\\" "/" dir ${dir})
1133         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1134         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1135         ENDIF(name STREQUAL ${target})
1136         ENDFOREACH(target ${targets})
1137         ENDIF(WINDOWS)
1138         ''')
1139         # --
1140         newlines.append(r'''
1141         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1142         FOREACH(lib SALOMEBasics SalomeBatch)
1143         IF(name STREQUAL lib)
1144         SET(libs ${libs} ${PTHREAD_LIBS})
1145         ENDIF(name STREQUAL lib)
1146         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1147         ''')
1148         if key == "bin_PROGRAMS":
1149             newlines.append(r'''
1150             SET(libs ${libs} ${LDADD})
1151             ''')
1152             pass
1153         # --
1154         newlines.append(r'''
1155         FOREACH(lib ${libs})
1156         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1157         IF(ext STREQUAL .la)
1158         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1159         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1160         ENDIF(ext STREQUAL .la)
1161         SET(vars)
1162         SET(vars ${vars} -no-undefined)
1163         SET(vars ${vars} -lvtkWidgets)
1164         IF(WINDOWS)
1165         SET(vars ${vars} -module)
1166         SET(vars ${vars} -Wl,-E)
1167         SET(vars ${vars} -Xlinker)
1168         SET(vars ${vars} -export-dynamic)
1169         SET(vars ${vars} -lm)
1170         SET(vars ${vars} -lboost_thread)
1171         SET(vars ${vars} -lboost_signals)
1172         ENDIF(WINDOWS)
1173         FOREACH(v ${vars})
1174         IF(lib STREQUAL v)
1175         SET(lib)
1176         ENDIF(lib STREQUAL v)
1177         ENDFOREACH(v ${vars})
1178         SET(libadd ${libadd} ${lib})
1179         ENDFOREACH(lib ${libs})
1180         TARGET_LINK_LIBRARIES(${name} ${libadd})
1181         ''')
1182         # --
1183         newlines.append(r'''
1184         IF(WINDOWS)
1185         SET(targets)
1186         SET(targets ${targets} MEFISTO2D)
1187         FOREACH(target ${targets})
1188         IF(name STREQUAL ${target})
1189         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1190         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1191         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1192         ENDIF(name STREQUAL ${target})
1193         ENDFOREACH(target ${targets})
1194         ENDIF(WINDOWS)
1195         ''')
1196         # --
1197         return
1198
1199     def setCompilationFlags(self, key, newlines):
1200         newlines.append(r'''
1201         SET(var)
1202         IF(WINDOWS)
1203         SET(targets)
1204         SET(targets ${targets} SalomeIDLKernel)
1205         SET(targets ${targets} SalomeDS)
1206         SET(targets ${targets} SALOMEDSTest)
1207         SET(targets ${targets} SALOMEDS_Client_exe)
1208         SET(targets ${targets} SalomeIDLGEOM)
1209         SET(targets ${targets} GEOMEngine)
1210         SET(targets ${targets} MEDEngine)
1211         SET(targets ${targets} SMESHEngine)
1212         SET(targets ${targets} SMESH)
1213         FOREACH(target ${targets})
1214         IF(name STREQUAL ${target})
1215         SET(var ${var} -DNOGDI)
1216         ENDIF(name STREQUAL ${target})
1217         ENDFOREACH(target ${targets})
1218         ENDIF(WINDOWS)
1219         ''')
1220         # --
1221         newlines.append(r'''
1222         IF(WINDOWS)
1223         SET(targets)
1224         SET(targets ${targets} MEFISTO2D)
1225         FOREACH(target ${targets})
1226         IF(name STREQUAL ${target})
1227         SET(dir $ENV{F2CHOME})
1228         STRING(REPLACE "\\\\" "/" dir ${dir})
1229         SET(var ${var} -I${dir})
1230         SET(var ${var} -DF2C_BUILD)
1231         ENDIF(name STREQUAL ${target})
1232         ENDFOREACH(target ${targets})
1233         ENDIF(WINDOWS)
1234         ''')
1235         # --
1236         if self.module in ["geom", "med"]:
1237             newlines.append(r'''
1238             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1239             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1240             ''')
1241             pass
1242         newlines.append(r'''
1243         SET(var ${var} ${AM_CPPFLAGS})
1244         SET(var ${var} ${AM_CXXFLAGS})
1245         ''')
1246         if self.module == "yacs":
1247             newlines.append(r'''
1248             SET(var ${var} -DYACS_PTHREAD)
1249             ''')
1250             pass
1251         newlines.append(r'''
1252         SET(var ${var} ${PLATFORM_CPPFLAGS})
1253         SET(var ${var} ${PTHREAD_CFLAGS})
1254         SET(var ${var} ${${amname}_CPPFLAGS})
1255         SET(var ${var} ${${amname}_CXXFLAGS})
1256         SET(var ${var} ${${amname}_CFLAGS})
1257         SET(vars)
1258         IF(WINDOWS)
1259         SET(vars ${vars} -include SALOMEconfig.h)
1260         SET(vars ${vars} -ftemplate-depth-32)
1261         SET(vars ${vars} -fPIC)
1262         ENDIF(WINDOWS)
1263         SET(flags)
1264         FOREACH(f ${var})
1265         FOREACH(v ${vars})
1266         IF(f STREQUAL v)
1267         SET(f)
1268         ENDIF(f STREQUAL v)
1269         ENDFOREACH(v ${vars})
1270         SET(flags "${flags} ${f}")
1271         ENDFOREACH(f ${var})
1272         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1273         ''')
1274         return
1275
1276     def addLibTarget(self, key, newlines):
1277         newlines.append(r'''
1278         FOREACH(amname ${%s})
1279         '''%(key))
1280         # --
1281         # Replace .la by _la ...
1282         # --
1283         newlines.append(r'''
1284         STRING(REPLACE .la _la amname ${amname})
1285         ''')
1286         # --
1287         # Remove the _la for the cmake name
1288         # --
1289         newlines.append(r'''
1290         STRING(LENGTH ${amname} len)
1291         MATH(EXPR newlen "${len}-3")
1292         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1293         ''')
1294         # --
1295         # Does the target begins with lib ??
1296         # If yes, remove lib at beginning for cmake name
1297         # --
1298         newlines.append(r'''
1299         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1300         IF(BEGIN_WITH_lib)
1301         STRING(LENGTH ${name} len)
1302         MATH(EXPR newlen "${len}-3")
1303         STRING(SUBSTRING ${name} 3 ${newlen} name)
1304         ENDIF(BEGIN_WITH_lib)
1305         ''')
1306         # --
1307         # Does the target is an idl library
1308         # --
1309         newlines.append(r'''
1310         STRING(REGEX MATCH "IDL" ISIDL ${name})
1311         ''')
1312         # --
1313         # Set the type of the library
1314         # --
1315         newlines.append(r'''
1316         IF(ISIDL)
1317         IF(WINDOWS)
1318         SET(type STATIC)
1319         ELSE(WINDOWS)
1320         SET(type SHARED)
1321         ENDIF(WINDOWS)
1322         ELSE(ISIDL)
1323         SET(type SHARED)
1324         ENDIF(ISIDL)
1325         ''')
1326         # --
1327         # Set sources for the library
1328         # --
1329         newlines.append(r'''
1330         SET(srcs)
1331         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1332         GET_FILENAME_COMPONENT(ext ${src} EXT)
1333         IF(ext STREQUAL .f)
1334         IF(src STREQUAL trte.f)
1335         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1336         STRING(REPLACE ".f" ".c" src ${src})
1337         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1338         SET(output ${src})
1339         ADD_CUSTOM_COMMAND(
1340         OUTPUT ${output}
1341         COMMAND f2c ${input}
1342         MAIN_DEPENDENCY ${input}
1343         )
1344         ELSE(src STREQUAL trte.f)
1345         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1346         STRING(REPLACE ".f" ".o" src ${src})
1347         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1348         SET(output ${src})
1349         IF(WINDOWS)
1350         SET(F77 g77)
1351         ELSE(WINDOWS)
1352         SET(F77 gfortran)
1353         ENDIF(WINDOWS)
1354         ADD_CUSTOM_COMMAND(
1355         OUTPUT ${output}
1356         COMMAND ${F77} -c -o ${output} ${input}
1357         MAIN_DEPENDENCY ${input}
1358         )
1359         ENDIF(src STREQUAL trte.f)
1360         ENDIF(ext STREQUAL .f)
1361         SET(srcs ${srcs} ${src})
1362         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1363         ''')
1364         newlines.append(r'''
1365         SET(l ${nodist_${amname}_SOURCES})
1366         FOREACH(f ${l})
1367         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1368         SET(srcs ${srcs} ${src})
1369         ENDFOREACH(f ${l})
1370         ''')
1371         newlines.append(r'''
1372         SET(build_srcs)
1373         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1374         FOREACH(f ${l})
1375         GET_FILENAME_COMPONENT(ext ${f} EXT)
1376         IF(ext STREQUAL .py)
1377         ELSE(ext STREQUAL .py)
1378         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1379         ENDIF(ext STREQUAL .py)
1380         ENDFOREACH(f ${l})
1381         ''')
1382         # --
1383         # Add the library to cmake
1384         # --
1385         newlines.append(r'''
1386         ADD_LIBRARY(${name} ${type} ${srcs})
1387         ''')
1388         # --
1389         # The compilation flags
1390         # --
1391         self.setCompilationFlags(key, newlines)
1392         # --
1393         newlines.append(r'''
1394         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1395         ''')
1396         # --
1397         self.setLibAdd(key, newlines)
1398         # --
1399         if 1: # key != "noinst_LTLIBRARIES":
1400             if self.module == "medfile":
1401                 newlines.append(r'''
1402                 SET(DEST lib)
1403                 ''')
1404             else:
1405                 newlines.append(r'''
1406                 SET(DEST lib/salome)
1407                 ''')
1408                 pass
1409             newlines.append(r'''
1410             IF(BEGIN_WITH_lib)
1411             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1412             ''')
1413             if self.module == "gui":
1414                 newlines.append(r'''
1415                 FOREACH(lib SalomePyQt)
1416                 IF(name STREQUAL lib)
1417                 IF(WINDOWS)
1418                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1419                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1420                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1421                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1422                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1423                 ELSE(WINDOWS)
1424                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1425                 ENDIF(WINDOWS)
1426                 ENDIF(name STREQUAL lib)
1427                 ENDFOREACH(lib SalomePyQt)
1428                 FOREACH(lib SalomePy)
1429                 IF(name STREQUAL lib)
1430                 IF(WINDOWS)
1431                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1432                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1433                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1434                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1435                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1436                 ENDIF(WINDOWS)
1437                 ENDIF(name STREQUAL lib)
1438                 ENDFOREACH(lib SalomePy)
1439                 ''')
1440                 pass
1441             if self.module == "geom":
1442                 newlines.append(r'''
1443                 IF(WINDOWS)
1444                 STRING(REGEX MATCH "Export" ISExport ${name})
1445                 IF(ISExport)
1446                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1447                 ENDIF(ISExport)
1448                 STRING(REGEX MATCH "Import" ISImport ${name})
1449                 IF(ISImport)
1450                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1451                 ENDIF(ISImport)
1452                 ENDIF(WINDOWS)
1453                 ''')
1454                 pass
1455             newlines.append(r'''
1456             ELSE(BEGIN_WITH_lib)
1457             ''')
1458             newlines.append(r'''
1459             IF(WINDOWS)
1460             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1461             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1462             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)
1463             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1464             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)
1465             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1466             ELSE(WINDOWS)
1467             GET_TARGET_PROPERTY(version ${name} VERSION)
1468             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1469             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1470             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1471             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1472             ENDIF(WINDOWS)
1473             ''')
1474             newlines.append(r'''
1475             ENDIF(BEGIN_WITH_lib)
1476             ''')
1477             pass
1478         # --
1479         newlines.append(r'''
1480         ENDFOREACH(amname ${%s})
1481         '''%(key))
1482         # --
1483         return
1484
1485     def addBinTarget(self, key, newlines):
1486         # --
1487         newlines.append(r'''
1488         FOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1489         ''')
1490         # --
1491         newlines.append(r'''
1492         SET(name "${amname}_exe")
1493         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1494         LIST(LENGTH srcs nb)
1495         IF(nb)
1496         ADD_EXECUTABLE(${name} ${srcs})
1497         ''')
1498         # --
1499         self.setCompilationFlags(key, newlines)
1500         # --
1501         self.setLibAdd(key, newlines)
1502         # --
1503         if self.module == "medfile":
1504             newlines.append(r'''
1505             SET(DEST bin)
1506             ''')
1507         else:
1508             newlines.append(r'''
1509             SET(DEST bin/salome)
1510             ''')
1511             pass
1512         # --
1513         if key == "bin_PROGRAMS":
1514             newlines.append(r'''
1515             IF(WINDOWS)
1516             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1517             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1518             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1519             ELSE(WINDOWS)
1520             SET(PERMS)
1521             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1522             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1523             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1524             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1525             ENDIF(WINDOWS)
1526             ''')
1527             pass
1528         # --
1529         newlines.append(r'''
1530         ENDIF(nb)
1531         ''')
1532         # --
1533         newlines.append(r'''
1534         ENDFOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1535         ''')
1536         # --
1537         return
1538
1539     def addInstallTarget(self, key, destination, newlines):
1540         newlines.append(r"FOREACH(f ${%s})"%(key))
1541         newlines.append(r'''
1542         SET(DEST %s)
1543         '''%(destination))
1544         newlines.append(r'''
1545         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1546         IF(test_SALOMEconfig.h.in)
1547         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1548         ELSE(test_SALOMEconfig.h.in)
1549         SET(dummy dummy-NOTFOUND)
1550         MARK_AS_ADVANCED(dummy)
1551         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1552         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1553         IF(dummy)
1554         ''')
1555         if key in ['dist_salomescript_SCRIPTS']:
1556             newlines.append(r'''
1557             SET(PERMS)
1558             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1559             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1560             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1561             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1562             ''')
1563         else:
1564             newlines.append(r'''
1565             GET_FILENAME_COMPONENT(ext ${f} EXT)
1566             IF(ext STREQUAL .py)
1567             IF(DEST STREQUAL bin/salome)
1568             SET(PERMS)
1569             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1570             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1571             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1572             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1573             ELSE(DEST STREQUAL bin/salome)
1574             INSTALL(FILES ${f} DESTINATION ${DEST})
1575             ENDIF(DEST STREQUAL bin/salome)
1576             ELSE(ext STREQUAL .py)
1577             INSTALL(FILES ${f} DESTINATION ${DEST})
1578             ENDIF(ext STREQUAL .py)
1579             ''')
1580             pass
1581         newlines.append(r'''
1582         ELSE(dummy)
1583         GET_FILENAME_COMPONENT(ext ${f} EXT)
1584         IF(ext STREQUAL .qm)
1585         STRING(REGEX REPLACE .qm .ts input ${f})
1586         ''')
1587         if self.module in ["kernel", "gui"]:
1588             newlines.append(r'''
1589             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1590             ''')
1591         else:
1592             newlines.append(r'''
1593             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1594             ''')
1595             pass
1596         newlines.append(r'''
1597         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1598         # ADD_CUSTOM_COMMAND(
1599         # OUTPUT ${output}
1600         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1601         # MAIN_DEPENDENCY ${input}
1602         # )
1603         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1604         ENDIF(ext STREQUAL .qm)
1605         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1606         ENDIF(dummy)
1607         ENDIF(test_SALOMEconfig.h.in)
1608         ''')
1609         newlines.append(r'''
1610         GET_FILENAME_COMPONENT(ext ${f} EXT)
1611         IF(ext STREQUAL .py)
1612         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1613         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1614         INSTALL(CODE "SET(DEST ${DEST})")
1615         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1616         ''')
1617         if self.module == "kernel":
1618             newlines.append('''
1619             IF(f STREQUAL SALOME_ContainerPy.py)
1620             ELSE(f STREQUAL SALOME_ContainerPy.py)
1621             IF(f STREQUAL am2cmake.py)
1622             ELSE(f STREQUAL am2cmake.py)
1623             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1624             ENDIF(f STREQUAL am2cmake.py)
1625             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1626             ''')
1627         else:
1628             newlines.append('''
1629             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1630             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1631             ''')
1632             pass
1633         newlines.append(r'''
1634         ENDIF(ext STREQUAL .py)
1635         ''')
1636         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1637         return
1638
1639     def writeListsFile(self):
1640         f = open(self.listsFile, "w")
1641         f.write(self.content)
1642         f.close()
1643         return
1644
1645     pass
1646
1647 def convertAmFile(the_root, root, dirs, files, f, module):
1648     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1649     cmake.writeListsFile()
1650     return
1651
1652 def usage(exit_status):
1653     from sys import exit
1654     from sys import argv
1655     print "Usage: %s --module"%(argv[0])
1656     exit(exit_status)
1657     return
1658
1659 if __name__ == "__main__":
1660     #
1661     from sys import argv
1662     if len(argv) != 2:
1663         usage(1)
1664         pass
1665     #
1666     module = argv[1]
1667     if module.find('--') != 0:
1668         usage(1)
1669         pass
1670     module = module[2:]
1671     if len(module) == 0:
1672         usage(1)
1673         pass
1674     #
1675     from os import getcwd
1676     the_root = getcwd()
1677     #
1678     from os import walk
1679     for root, dirs, files in walk(the_root):
1680         # --
1681         # E.A. : Remove 'CVS' in dirs
1682         # E.A. : It allows to not recurse in CVS dirs
1683         # E.A. : See os module python documentation
1684         # --
1685         try:
1686             dirs.remove('CVS')
1687         except ValueError:
1688             pass
1689         # --
1690         for f in files:
1691             if f == "Makefile.am":
1692                 convertAmFile(the_root, root, dirs, files, f, module)
1693                 pass
1694             pass
1695         pass
1696     #
1697     pass