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