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