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