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         SET(var ${var} -DF2C_BUILD)
1206         ENDIF(name STREQUAL ${target})
1207         ENDFOREACH(target ${targets})
1208         ENDIF(WINDOWS)
1209         ''')
1210         # --
1211         if self.module in ["geom", "med"]:
1212             newlines.append(r'''
1213             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1214             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1215             ''')
1216             pass
1217         newlines.append(r'''
1218         SET(var ${var} ${AM_CPPFLAGS})
1219         SET(var ${var} ${AM_CXXFLAGS})
1220         ''')
1221         newlines.append(r'''
1222         SET(var ${var} ${PLATFORM_CPPFLAGS})
1223         SET(var ${var} ${PTHREAD_CFLAGS})
1224         SET(var ${var} ${${amname}_CPPFLAGS})
1225         SET(var ${var} ${${amname}_CXXFLAGS})
1226         SET(var ${var} ${${amname}_CFLAGS})
1227         SET(vars)
1228         IF(WINDOWS)
1229         SET(vars ${vars} -include SALOMEconfig.h)
1230         SET(vars ${vars} -ftemplate-depth-32)
1231         ENDIF(WINDOWS)
1232         SET(flags)
1233         FOREACH(f ${var})
1234         FOREACH(v ${vars})
1235         IF(f STREQUAL v)
1236         SET(f)
1237         ENDIF(f STREQUAL v)
1238         ENDFOREACH(v ${vars})
1239         SET(flags "${flags} ${f}")
1240         ENDFOREACH(f ${var})
1241         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1242         ''')
1243         return
1244
1245     def addLibTarget(self, key, newlines):
1246         newlines.append(r'''
1247         FOREACH(amname ${%s})
1248         '''%(key))
1249         # --
1250         # Replace .la by _la ...
1251         # --
1252         newlines.append(r'''
1253         STRING(REPLACE .la _la amname ${amname})
1254         ''')
1255         # --
1256         # Remove the _la for the cmake name
1257         # --
1258         newlines.append(r'''
1259         STRING(LENGTH ${amname} len)
1260         MATH(EXPR newlen "${len}-3")
1261         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1262         ''')
1263         # --
1264         # Does the target begins with lib ??
1265         # If yes, remove lib at beginning for cmake name
1266         # --
1267         newlines.append(r'''
1268         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1269         IF(BEGIN_WITH_lib)
1270         STRING(LENGTH ${name} len)
1271         MATH(EXPR newlen "${len}-3")
1272         STRING(SUBSTRING ${name} 3 ${newlen} name)
1273         ENDIF(BEGIN_WITH_lib)
1274         ''')
1275         # --
1276         # Does the target is an idl library
1277         # --
1278         newlines.append(r'''
1279         STRING(REGEX MATCH "IDL" ISIDL ${name})
1280         ''')
1281         # --
1282         # Set the type of the library
1283         # --
1284         newlines.append(r'''
1285         IF(ISIDL)
1286         IF(WINDOWS)
1287         SET(type STATIC)
1288         ELSE(WINDOWS)
1289         SET(type SHARED)
1290         ENDIF(WINDOWS)
1291         ELSE(ISIDL)
1292         SET(type SHARED)
1293         ENDIF(ISIDL)
1294         ''')
1295         # --
1296         # Set sources for the library
1297         # --
1298         newlines.append(r'''
1299         SET(srcs)
1300         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1301         GET_FILENAME_COMPONENT(ext ${src} EXT)
1302         IF(ext STREQUAL .f)
1303         IF(src STREQUAL trte.f)
1304         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1305         STRING(REPLACE ".f" ".c" src ${src})
1306         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1307         SET(output ${src})
1308         ADD_CUSTOM_COMMAND(
1309         OUTPUT ${output}
1310         COMMAND f2c ${input}
1311         MAIN_DEPENDENCY ${input}
1312         )
1313         ELSE(src STREQUAL trte.f)
1314         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1315         STRING(REPLACE ".f" ".o" src ${src})
1316         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1317         SET(output ${src})
1318         IF(WINDOWS)
1319         SET(F77 g77)
1320         ELSE(WINDOWS)
1321         SET(F77 gfortran)
1322         ENDIF(WINDOWS)
1323         ADD_CUSTOM_COMMAND(
1324         OUTPUT ${output}
1325         COMMAND ${F77} -c -o ${output} ${input}
1326         MAIN_DEPENDENCY ${input}
1327         )
1328         ENDIF(src STREQUAL trte.f)
1329         ENDIF(ext STREQUAL .f)
1330         SET(srcs ${srcs} ${src})
1331         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1332         ''')
1333         newlines.append(r'''
1334         SET(build_srcs)
1335         ''')
1336         newlines.append(r'''
1337         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1338         ''')
1339         newlines.append(r'''
1340         FOREACH(f ${l})
1341         GET_FILENAME_COMPONENT(ext ${f} EXT)
1342         IF(ext STREQUAL .py)
1343         ELSE(ext STREQUAL .py)
1344         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1345         ENDIF(ext STREQUAL .py)
1346         ENDFOREACH(f ${l})
1347         SET(srcs ${build_srcs} ${srcs})
1348         ''')
1349         # --
1350         # Add the library to cmake
1351         # --
1352         newlines.append(r'''
1353         ADD_LIBRARY(${name} ${type} ${srcs})
1354         ''')
1355         # --
1356         # The compilation flags
1357         # --
1358         self.setCompilationFlags(key, newlines)
1359         # --
1360         newlines.append(r'''
1361         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1362         ''')
1363         # --
1364         self.setLibAdd(key, newlines)
1365         # --
1366         if 1: # key != "noinst_LTLIBRARIES":
1367             if self.module == "medfile":
1368                 newlines.append(r'''
1369                 SET(DEST lib)
1370                 ''')
1371             else:
1372                 newlines.append(r'''
1373                 SET(DEST lib/salome)
1374                 ''')
1375                 pass
1376             newlines.append(r'''
1377             IF(BEGIN_WITH_lib)
1378             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1379             ''')
1380             if self.module == "gui":
1381                 newlines.append(r'''
1382                 FOREACH(lib SalomePyQt)
1383                 IF(name STREQUAL lib)
1384                 IF(WINDOWS)
1385                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1386                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1387                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1388                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1389                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1390                 ELSE(WINDOWS)
1391                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1392                 ENDIF(WINDOWS)
1393                 ENDIF(name STREQUAL lib)
1394                 ENDFOREACH(lib SalomePyQt)
1395                 FOREACH(lib SalomePy)
1396                 IF(name STREQUAL lib)
1397                 IF(WINDOWS)
1398                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1399                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1400                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1401                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1402                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1403                 ENDIF(WINDOWS)
1404                 ENDIF(name STREQUAL lib)
1405                 ENDFOREACH(lib SalomePy)
1406                 ''')
1407                 pass
1408             if self.module == "geom":
1409                 newlines.append(r'''
1410                 IF(WINDOWS)
1411                 STRING(REGEX MATCH "Export" ISExport ${name})
1412                 IF(ISExport)
1413                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1414                 ENDIF(ISExport)
1415                 STRING(REGEX MATCH "Import" ISImport ${name})
1416                 IF(ISImport)
1417                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1418                 ENDIF(ISImport)
1419                 ENDIF(WINDOWS)
1420                 ''')
1421                 pass
1422             newlines.append(r'''
1423             ELSE(BEGIN_WITH_lib)
1424             ''')
1425             newlines.append(r'''
1426             IF(WINDOWS)
1427             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1428             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1429             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)
1430             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1431             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)
1432             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1433             ELSE(WINDOWS)
1434             GET_TARGET_PROPERTY(version ${name} VERSION)
1435             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1436             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1437             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1438             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1439             ENDIF(WINDOWS)
1440             ''')
1441             newlines.append(r'''
1442             ENDIF(BEGIN_WITH_lib)
1443             ''')
1444             pass
1445         # --
1446         newlines.append(r'''
1447         ENDFOREACH(amname ${%s})
1448         '''%(key))
1449         # --
1450         return
1451
1452     def addBinTarget(self, key, newlines):
1453         # --
1454         newlines.append(r'''
1455         FOREACH(amname ${bin_PROGRAMS})
1456         ''')
1457         # --
1458         newlines.append(r'''
1459         SET(name "${amname}_exe")
1460         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1461         LIST(LENGTH srcs nb)
1462         IF(nb)
1463         ADD_EXECUTABLE(${name} ${srcs})
1464         ''')
1465         # --
1466         self.setCompilationFlags(key, newlines)
1467         # --
1468         self.setLibAdd(key, newlines)
1469         # --
1470         if self.module == "medfile":
1471             newlines.append(r'''
1472             SET(DEST bin)
1473             ''')
1474         else:
1475             newlines.append(r'''
1476             SET(DEST bin/salome)
1477             ''')
1478             pass
1479         # --
1480         newlines.append(r'''
1481         IF(WINDOWS)
1482         INSTALL(TARGETS ${name} DESTINATION ${DEST})
1483         INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1484         INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1485         ELSE(WINDOWS)
1486         SET(PERMS)
1487         SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1488         SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1489         SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1490         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1491         ENDIF(WINDOWS)
1492         ''')
1493         # --
1494         newlines.append(r'''
1495         ENDIF(nb)
1496         ''')
1497         # --
1498         newlines.append(r'''
1499         ENDFOREACH(amname ${bin_PROGRAMS})
1500         ''')
1501         # --
1502         return
1503
1504     def addInstallTarget(self, key, destination, newlines):
1505         newlines.append(r"FOREACH(f ${%s})"%(key))
1506         newlines.append(r'''
1507         SET(DEST %s)
1508         '''%(destination))
1509         newlines.append(r'''
1510         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1511         IF(test_SALOMEconfig.h.in)
1512         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1513         ELSE(test_SALOMEconfig.h.in)
1514         SET(dummy dummy-NOTFOUND)
1515         MARK_AS_ADVANCED(dummy)
1516         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1517         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1518         IF(dummy)
1519         ''')
1520         if key in ['dist_salomescript_SCRIPTS']:
1521             newlines.append(r'''
1522             SET(PERMS)
1523             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1524             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1525             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1526             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1527             ''')
1528         else:
1529             newlines.append(r'''
1530             GET_FILENAME_COMPONENT(ext ${f} EXT)
1531             IF(ext STREQUAL .py)
1532             IF(DEST STREQUAL bin/salome)
1533             SET(PERMS)
1534             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1535             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1536             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1537             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1538             ELSE(DEST STREQUAL bin/salome)
1539             INSTALL(FILES ${f} DESTINATION ${DEST})
1540             ENDIF(DEST STREQUAL bin/salome)
1541             ELSE(ext STREQUAL .py)
1542             INSTALL(FILES ${f} DESTINATION ${DEST})
1543             ENDIF(ext STREQUAL .py)
1544             ''')
1545             pass
1546         newlines.append(r'''
1547         ELSE(dummy)
1548         GET_FILENAME_COMPONENT(ext ${f} EXT)
1549         IF(ext STREQUAL .qm)
1550         STRING(REGEX REPLACE .qm .ts input ${f})
1551         ''')
1552         if self.module in ["kernel", "gui"]:
1553             newlines.append(r'''
1554             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1555             ''')
1556         else:
1557             newlines.append(r'''
1558             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1559             ''')
1560             pass
1561         newlines.append(r'''
1562         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1563         # ADD_CUSTOM_COMMAND(
1564         # OUTPUT ${output}
1565         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1566         # MAIN_DEPENDENCY ${input}
1567         # )
1568         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1569         ENDIF(ext STREQUAL .qm)
1570         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1571         ENDIF(dummy)
1572         ENDIF(test_SALOMEconfig.h.in)
1573         ''')
1574         newlines.append(r'''
1575         GET_FILENAME_COMPONENT(ext ${f} EXT)
1576         IF(ext STREQUAL .py)
1577         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1578         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1579         INSTALL(CODE "SET(DEST ${DEST})")
1580         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1581         ''')
1582         if self.module == "kernel":
1583             newlines.append('''
1584             IF(f STREQUAL SALOME_ContainerPy.py)
1585             ELSE(f STREQUAL SALOME_ContainerPy.py)
1586             IF(f STREQUAL am2cmake.py)
1587             ELSE(f STREQUAL am2cmake.py)
1588             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1589             ENDIF(f STREQUAL am2cmake.py)
1590             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1591             ''')
1592         else:
1593             newlines.append('''
1594             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1595             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1596             ''')
1597             pass
1598         newlines.append(r'''
1599         ENDIF(ext STREQUAL .py)
1600         ''')
1601         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1602         return
1603
1604     def writeListsFile(self):
1605         f = open(self.listsFile, "w")
1606         f.write(self.content)
1607         f.close()
1608         return
1609
1610     pass
1611
1612 def convertAmFile(the_root, root, dirs, files, f, module):
1613     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1614     cmake.writeListsFile()
1615     return
1616
1617 def usage(exit_status):
1618     from sys import exit
1619     from sys import argv
1620     print "Usage: %s --module"%(argv[0])
1621     exit(exit_status)
1622     return
1623
1624 if __name__ == "__main__":
1625     #
1626     from sys import argv
1627     if len(argv) != 2:
1628         usage(1)
1629         pass
1630     #
1631     module = argv[1]
1632     if module.find('--') != 0:
1633         usage(1)
1634         pass
1635     module = module[2:]
1636     if len(module) == 0:
1637         usage(1)
1638         pass
1639     #
1640     from os import getcwd
1641     the_root = getcwd()
1642     #
1643     from os import walk
1644     for root, dirs, files in walk(the_root):
1645         # --
1646         # E.A. : Remove 'CVS' in dirs
1647         # E.A. : It allows to not recurse in CVS dirs
1648         # E.A. : See os module python documentation
1649         # --
1650         try:
1651             dirs.remove('CVS')
1652         except ValueError:
1653             pass
1654         # --
1655         for f in files:
1656             if f == "Makefile.am":
1657                 convertAmFile(the_root, root, dirs, files, f, module)
1658                 pass
1659             pass
1660         pass
1661     #
1662     pass