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