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