salome_adm/cmake_files/am2cmake.py

   1 #  -*- coding: iso-8859-1 -*-
   2 #  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
   3 #
   4 #  This library is free software; you can redistribute it and/or
   5 #  modify it under the terms of the GNU Lesser General Public
   6 #  License as published by the Free Software Foundation; either
   7 #  version 2.1 of the License.
   8 #
   9 #  This library is distributed in the hope that it will be useful,
  10 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 #  Lesser General Public License for more details.
  13 #
  14 #  You should have received a copy of the GNU Lesser General Public
  15 #  License along with this library; if not, write to the Free Software
  16 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 #
  18 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 import re
  22
  23 # ----
  24 # A set of regular expressions used ...
  25 # ----
  26
  27 p_multiline = re.compile(r"""
  28 \\           # One backslash
  29 \s*          # 0 or more space
  30 \n           # One CR
  31 """, re.VERBOSE)
  32
  33 p_dollar = re.compile(r"""
  34 \$\(           # a $ then a (
  35 (?P<val>       # open the group val
  36 [^)]*          # the group contain 0 or more non ) characters
  37 )              # close the group
  38 \)             # a ) at the end
  39 """, re.VERBOSE)
  40
  41 p_arobas = re.compile(r"""
  42 @              # a @
  43 (?P<val>       # open the group val
  44 [^@]*            # the group contain 0 or more non @ characters
  45 )              # close the group
  46 @              # a @ at the end
  47 """, re.VERBOSE)
  48
  49 p_if = re.compile(r"""
  50 ^          # beginning of the string
  51 \s*        # 0 or more space
  52 if         # an if
  53 \s+        # 1 or more space
  54 (?P<val>   # open the group val
  55 .+         # the group contain 1 or more non space characters
  56 )          # close the group
  57 """, re.VERBOSE)
  58
  59 p_else = re.compile(r"""
  60 ^          # beginning of the line
  61 \s*        # 0 or more space
  62 else       #
  63 \s*        # 0 or more space
  64 """, re.VERBOSE)
  65
  66 p_endif = re.compile(r"""
  67 ^          # beginning of the line
  68 \s*        # 0 or more space
  69 endif      # a endif
  70 \s*        # 0 or more space
  71 """, re.VERBOSE)
  72
  73 p_attribution = re.compile(r"""
  74 ^              # beginning of the line
  75 (?P<spaces>    # open the group spaces
  76 \s*            # 0 or more space
  77 )              # close the group
  78 (?P<key>       # open the group key
  79 \w+            # the group contain 1 or more alphanumeric characters
  80 )              # close the group
  81 \s*            # 0 or more space
  82 (?P<method>    # open the group method
  83 \+?            # 0 or 1 +
  84 =              # One =
  85 )              # close the group
  86 (?P<value>     # open the group value
  87 .*             # 0 or more any characters
  88 )              # close the group
  89 """, re.VERBOSE)
  90
  91 # -----
  92
  93 class CMakeFile(object):
  94
  95     def __init__(self, the_root, root, dirs, files, f, module):
  96         #
  97         self.the_root = the_root
  98         self.root = root
  99         self.dirs = dirs
 100         self.files = files
 101         self.module = module
 102         #
 103         from os.path import join
 104         self.amFile = join(root, f)
 105         self.listsFile = join(root, "CMakeLists.txt")
 106         #
 107         self.parseFile()
 108         #
 109         return
 110
 111     def parseFile(self):
 112
 113         # --
 114         # Read the Makefile.am file
 115         # --
 116         amFile = self.amFile
 117         stream = open(amFile)
 118         content = stream.read()
 119         stream.close()
 120
 121         # --
 122         # Replace the composed lines separated by "\\n" by an unique line
 123         # --
 124         content = p_multiline.sub(r' ', content)
 125
 126         # --
 127         # Compatibility netgen plugin
 128         # --
 129         content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
 130
 131         # --
 132         cas_list = [
 133             "BinLPlugin",
 134             "BinPlugin",
 135             "BinTObjPlugin",
 136             "BinXCAFPlugin",
 137             "FWOSPlugin",
 138             "PTKernel",
 139             "StdLPlugin",
 140             "StdPlugin",
 141             "TKAdvTools",
 142             "TKBin",
 143             "TKBinL",
 144             "TKBinTObj",
 145             "TKBinXCAF",
 146             "TKBO",
 147             "TKBool",
 148             "TKBRep",
 149             "TKCAF",
 150             "TKCDF",
 151             "TKernel",
 152             "TKFeat",
 153             "TKFillet",
 154             "TKG2d",
 155             "TKG3d",
 156             "TKGeomAlgo",
 157             "TKGeomBase",
 158             "TKHLR",
 159             "TKIGES",
 160             "TKLCAF",
 161             "TKMath",
 162             "TKMesh",
 163             "TKMeshVS",
 164             "TKNIS",
 165             "TKOffset",
 166             "TKOpenGl",
 167             "TKPCAF",
 168             "TKPLCAF",
 169             "TKPrim",
 170             "TKPShape",
 171             "TKService",
 172             "TKShapeSchema",
 173             "TKShHealing",
 174             "TKStdLSchema",
 175             "TKStdSchema",
 176             "TKSTEP",
 177             "TKSTEP209",
 178             "TKSTEPAttr",
 179             "TKSTEPBase",
 180             "TKSTL",
 181             "TKTObj",
 182             "TKTopAlgo",
 183             "TKV2d",
 184             "TKV3d",
 185             "TKVRML",
 186             "TKXCAF",
 187             "TKXCAFSchema",
 188             "TKXDEIGES",
 189             "TKXDESTEP",
 190             "TKXMesh",
 191             "TKXml",
 192             "TKXmlL",
 193             "TKXmlTObj",
 194             "TKXmlXCAF",
 195             "TKXSBase",
 196             "XCAFPlugin",
 197             "XmlLPlugin",
 198             "XmlPlugin",
 199             "XmlTObjPlugin",
 200             "XmlXCAFPlugin",
 201             ]
 202         vtk_list = [
 203             "vtkCommonPythonD",
 204             "vtkGraphicsPythonD",
 205             "vtkImagingPythonD",
 206             ]
 207         kernel_list  = [
 208             "DF",
 209             "Launcher",
 210             "OpUtil",
 211             "Registry",
 212             "ResourcesManager",
 213             "SALOMEBasics",
 214             "SalomeBatch",
 215             "SalomeCatalog",
 216             "SalomeCommunication",
 217             "SalomeContainer",
 218             "SalomeDSCContainer",
 219             "SalomeDSClient",
 220             "SalomeDSImpl",
 221             "SalomeDS",
 222             "SalomeGenericObj",
 223             "SalomeHDFPersist",
 224             "SalomeIDLKernel",
 225             "SalomeLauncher",
 226             "SalomeLifeCycleCORBA",
 227             "SALOMELocalTrace",
 228             "SalomeLoggerServer",
 229             "SalomeNotification",
 230             "SalomeNS",
 231             "SalomeResourcesManager",
 232             "TOOLSDS",
 233             "with_loggerTraceCollector",
 234             ]
 235         gui_list = [
 236             "caf",
 237             "CAM",
 238             "CASCatch",
 239             "DDS",
 240             "Event",
 241             "GLViewer",
 242             "LightApp",
 243             "LogWindow",
 244             "ObjBrowser",
 245             "OCCViewer",
 246             "Plot2d",
 247             "PyConsole",
 248             "PyInterp",
 249             "QDS",
 250             "qtx",
 251             "QxScene",
 252             "SalomeApp",
 253             "SalomeIDLGUI",
 254             "SalomeObject",
 255             "SalomePrs",
 256             "SalomeSession",
 257             "SalomeStyle",
 258             "SOCC",
 259             "SPlot2d",
 260             "std",
 261             "SUITApp",
 262             "suit",
 263             "SUPERVGraph",
 264             "SVTK",
 265             "ToolsGUI",
 266             "VTKViewer",
 267             ]
 268         geom_list = [
 269             "BasicGUI",
 270             "BlocksGUI",
 271             "BooleanGUI",
 272             "BREPExport",
 273             "BREPImport",
 274             "BuildGUI",
 275             "DisplayGUI",
 276             "DlgRef",
 277             "EntityGUI",
 278             "GenerationGUI",
 279             "GEOMAlgo",
 280             "GEOMArchimede",
 281             "GEOMBase",
 282             "GEOMbasic",
 283             "GEOMClient",
 284             "GEOMEngine",
 285             "GEOMFiltersSelection",
 286             "GEOMimpl",
 287             "GEOMObject",
 288             "GEOMSketcher",
 289             "GEOM",
 290             "GEOM_SupervEngine",
 291             "GEOMToolsGUI",
 292             "GroupGUI",
 293             "IGESExport",
 294             "IGESImport",
 295             "MeasureGUI",
 296             "NMTDS",
 297             "NMTTools",
 298             "OperationGUI",
 299             "PrimitiveGUI",
 300             "RepairGUI",
 301             "SalomeIDLGEOM",
 302             "ShHealOper",
 303             "STEPExport",
 304             "STEPImport",
 305             "STLExport",
 306             "TransformationGUI",
 307             ]
 308         med_list = [
 309             "InterpGeometric2DAlg",
 310             "interpkernelbases",
 311             "interpkernel",
 312             "MEDClientcmodule",
 313             "medcoupling",
 314             "MEDEngine",
 315             "MEDMEMImpl",
 316             "medmem",
 317             "MED",
 318             "med_V2_1",
 319             "MEDWrapperBase",
 320             "MEDWrapper",
 321             "MEDWrapper_V2_1",
 322             "MEDWrapper_V2_2",
 323             "SalomeIDLMED",
 324             ]
 325         smesh_list = [
 326             "GeomSelectionTools",
 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                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 442                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 443                 """)
 444                 pass
 445             else:
 446                 if self.module == "med":
 447                     newlines.append("""
 448                     SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 449                     IF(KERNEL_ROOT_DIR)
 450                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 451                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 452                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 453                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 454                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 455                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 456                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 457                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 458                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 459                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 460                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 461                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 462                     ELSE(KERNEL_ROOT_DIR)
 463                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
 464                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
 465                     ENDIF(KERNEL_ROOT_DIR)
 466                     """)
 467                 else:
 468                     newlines.append("""
 469                     SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 470                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 471                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 472                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 473                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 474                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 475                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 476                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 477                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 478                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 479                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 480                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 481                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 482                     """)
 483                     pass
 484                 if self.module == "gui":
 485                     newlines.append("""
 486                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 487                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 488                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 489                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 490                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 491                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 492                     """)
 493                 else:
 494                     newlines.append("""
 495                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 496                     IF(GUI_ROOT_DIR)
 497                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 498                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 499                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 500                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 501                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 502                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 503                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 504                     ENDIF(GUI_ROOT_DIR)
 505                     """)
 506                     if self.module == "med":
 507                         newlines.append("""
 508                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 509                         IF(WINDOWS)
 510                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
 511                         ENDIF(WINDOWS)
 512                         """)
 513                         pass
 514                     if self.module == "smesh":
 515                         newlines.append("""
 516                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 517                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 518                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 519                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 520                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 521                         """)
 522                         pass
 523                     if self.module == "netgenplugin":
 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                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 532                         """)
 533                         pass
 534                     if self.module == "blsurfplugin":
 535                         newlines.append("""
 536                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 537                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 538                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 539                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 540                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 541                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 542                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 543                         """)
 544                         pass
 545                     if self.module in ["ghs3dplugin", "hexoticplugin"]:
 546                         newlines.append("""
 547                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 548                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 549                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 550                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 551                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 552                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 553                         """)
 554                         pass
 555                     if self.module == "ghs3dprlplugin":
 556                         newlines.append("""
 557                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 558                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 559                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 560                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 561                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 562                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 563                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 564                         """)
 565                         pass
 566                     if self.module == "visu":
 567                         newlines.append("""
 568                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 569                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 570                         """)
 571                         pass
 572                     if self.module == "yacs":
 573                         newlines.append("""
 574                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 575                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 576                         """)
 577                         pass
 578                     pass
 579                 pass
 580             # --
 581             newlines.append("""
 582             SET(DOXYGEN_IS_OK 0)
 583             """)
 584             if self.module not in ['med']:
 585                 newlines.append("""
 586                 IF(WINDOWS)
 587                 SET(CPPUNIT_IS_OK 0)
 588                 ENDIF(WINDOWS)
 589                 """)
 590                 pass
 591             # --
 592             if self.module == "kernel":
 593                 newlines.append("""
 594                 SET(WITH_LOCAL 1)
 595                 SET(WITH_BATCH 1)
 596                 set(VERSION 5.1.4)
 597                 set(XVERSION 0x050104)
 598                 SET(CALCIUM_IDL_INT_F77 long)
 599                 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 600                 SET(LONG_OR_INT int)
 601                 """)
 602             elif self.module == "gui":
 603                 newlines.append("""
 604                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 605                 SET(ENABLE_VTKVIEWER ON)
 606                 SET(ENABLE_SALOMEOBJECT ON)
 607                 SET(ENABLE_OCCVIEWER ON)
 608                 SET(ENABLE_GLVIEWER ON)
 609                 SET(ENABLE_PLOT2DVIEWER ON)
 610                 SET(ENABLE_PYCONSOLE ON)
 611                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 612                 SET(ENABLE_QXGRAPHVIEWER ON)
 613                 set(VERSION 5.1.4)
 614                 set(XVERSION 0x050104)
 615                 """)
 616                 pass
 617             elif self.module == "geom":
 618                 newlines.append("""
 619                 IF(GUI_ROOT_DIR)
 620                 SET(GEOM_ENABLE_GUI ON)
 621                 ENDIF(GUI_ROOT_DIR)
 622                 """)
 623                 pass
 624             elif self.module == "medfile":
 625                 newlines.append("""
 626                 SET(MED_NUM_MAJEUR 2)
 627                 SET(MED_NUM_MINEUR 3)
 628                 SET(MED_NUM_RELEASE 5)
 629                 SET(LONG_OR_INT int)
 630                 IF(NOT WINDOWS)
 631                 SET(FLIBS -lgfortranbegin -lgfortran)
 632                 ENDIF(NOT WINDOWS)
 633                 """)
 634                 pass
 635             elif self.module == "med":
 636                 newlines.append("""
 637                 IF(KERNEL_ROOT_DIR)
 638                 SET(MED_ENABLE_KERNEL ON)
 639                 IF(NOT WINDOWS)
 640                 SET(MED_ENABLE_SPLITTER ON)
 641                 ENDIF(NOT WINDOWS)
 642                 ENDIF(KERNEL_ROOT_DIR)
 643                 IF(GUI_ROOT_DIR)
 644                 SET(MED_ENABLE_GUI ON)
 645                 ENDIF(GUI_ROOT_DIR)
 646                 """)
 647                 pass
 648             elif self.module == "smesh":
 649                 newlines.append("""
 650                 IF(GUI_ROOT_DIR)
 651                 SET(SMESH_ENABLE_GUI ON)
 652                 ENDIF(GUI_ROOT_DIR)
 653                 """)
 654                 pass
 655             elif self.module == "netgenplugin":
 656                 newlines.append("""
 657                 IF(GUI_ROOT_DIR)
 658                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 659                 ENDIF(GUI_ROOT_DIR)
 660                 """)
 661                 pass
 662             elif self.module == "blsurfplugin":
 663                 newlines.append("""
 664                 IF(GUI_ROOT_DIR)
 665                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 666                 ENDIF(GUI_ROOT_DIR)
 667                 """)
 668                 pass
 669             elif self.module == "ghs3dplugin":
 670                 newlines.append("""
 671                 IF(GUI_ROOT_DIR)
 672                 SET(GHS3DPLUGIN_ENABLE_GUI ON)
 673                 ENDIF(GUI_ROOT_DIR)
 674                 """)
 675                 pass
 676             elif self.module == "hexoticplugin":
 677                 newlines.append("""
 678                 IF(GUI_ROOT_DIR)
 679                 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
 680                 ENDIF(GUI_ROOT_DIR)
 681                 """)
 682                 pass
 683             elif self.module == "ghs3dprlplugin":
 684                 newlines.append("""
 685                 IF(GUI_ROOT_DIR)
 686                 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
 687                 ENDIF(GUI_ROOT_DIR)
 688                 """)
 689                 pass
 690             elif self.module == "yacs":
 691                 newlines.append("""
 692                 SET(SALOME_KERNEL ON)
 693                 SET(HAS_GUI ON)
 694                 SET(WITH_QT4 ON)
 695                 """)
 696                 pass
 697             # --
 698             pass
 699         # --
 700         newlines.append("""
 701         SET(VERSION_INFO 0.0.0)
 702         SET(SOVERSION_INFO 0)
 703         SET(SUBDIRS)
 704         SET(AM_CPPFLAGS)
 705         SET(AM_CXXFLAGS)
 706         SET(LDADD)
 707         """)
 708         if self.module == "kernel":
 709             newlines.append(r'''
 710             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 711             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 712             ''')
 713         else:
 714             if self.module not in ["yacs"]:
 715                 newlines.append(r'''
 716                 IF(KERNEL_ROOT_DIR)
 717                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 718                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 719                 ENDIF(KERNEL_ROOT_DIR)
 720                 ''')
 721                 pass
 722             pass
 723         # --
 724         return
 725
 726     def treatLine(self, line, newlines, opened_ifs):
 727
 728         # --
 729         # Print the comment above the line itself
 730         # --
 731         if line.find('#') >= 0:
 732             fields = line.split('#')
 733             line = fields[0]
 734             comment = '#'.join([''] + fields[1:])
 735             newlines.append(comment)
 736             if len(line) == 0:
 737                 return
 738             pass
 739
 740         # --
 741         # If the line begins with 'include ', just comment it
 742         # --
 743         if line.find("include ") == 0:
 744             newlines.append("# " + line)
 745             return
 746
 747         # --
 748         # If the line begins with '-include', just comment it
 749         # --
 750         if line.find("-include") == 0:
 751             newlines.append("# " + line)
 752             return
 753
 754         # --
 755         # If the line is a definition of a make rule, just comment it
 756         # --
 757         if line.count(':') == 1:
 758             newlines.append("# " + line)
 759             return
 760
 761         # --
 762         # A particuliar case where there are two ":" on the same line
 763         # --
 764         if line.find('install-exec-local:') == 0:
 765             newlines.append("# " + line)
 766             return
 767
 768         # --
 769         # If the line begin by a tabulation, consider it's a makefile command and comment it
 770         # --
 771         if line.find("\t") == 0:
 772             newlines.append("# " + line)
 773             return
 774
 775         # --
 776         # --
 777         key = "-version-info"
 778         if line.find(key) >= 0:
 779             # --
 780             before = line.split(key)[0]
 781             after = line[len(before)+len(key):]
 782             sep = after[0]
 783             after = after[1:]
 784             version_info = after.split()[0]
 785             line = line.replace(key+sep+version_info, "")
 786             # --
 787             version_info = version_info.replace(':', '.')
 788             soversion_info = version_info.split('.')[0]
 789             newlines.append("SET(VERSION_INFO " + version_info + ")")
 790             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 791             # --
 792             pass
 793
 794         # --
 795         # Replace the $(TOTO) by ${TOTO}
 796         # Replace the @TOTO@  by ${TOTO}
 797         # --
 798         line = p_dollar.sub(r"${\1}", line)
 799         line = p_arobas.sub(r"${\1}", line)
 800
 801         # --
 802         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 803         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 804         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 805         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 806         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 807
 808         # --
 809         # Check if the line is a 'if' condition
 810         # If yes, replace it by a cmake grammar
 811         # --
 812         match = p_if.match(line)
 813         if match:
 814             theif = match.group("val")
 815             if theif[0] == "!":
 816                 theif = "NOT " + theif[1:]
 817                 pass
 818             line = p_if.sub(r"IF(%s)"%(theif), line)
 819             opened_ifs.append(theif)
 820             newlines.append(line)
 821             return
 822
 823         # --
 824         # Check if the line is a 'else' condition
 825         # If yes, replace it by a cmake grammar
 826         # --
 827         match = p_else.match(line)
 828         if match:
 829             line = "ELSE(%s)"%(opened_ifs[-1])
 830             newlines.append(line)
 831             return
 832
 833         # --
 834         # Check if the line is a 'endif' condition
 835         # If yes, replace it by a cmake grammar
 836         # --
 837         match = p_endif.match(line)
 838         if match:
 839             line = "ENDIF(%s)"%(opened_ifs[-1])
 840             opened_ifs[-1:] = []
 841             newlines.append(line)
 842             return
 843
 844         # --
 845         # Check if the line is an attribution '=' or '+='
 846         # --
 847         match = p_attribution.match(line)
 848         if match:
 849             self.treatAttribution(match, newlines)
 850             return
 851
 852         # --
 853         newlines.append(line)
 854
 855         # --
 856         return
 857
 858     def treatAttribution(self, match, newlines):
 859
 860         spaces = match.group("spaces")
 861         key = match.group("key")
 862         method = match.group("method")
 863         value = match.group("value")
 864         # print [spaces, key, method, value]
 865
 866         # --
 867         # Open cmake SET command
 868         # --
 869         newlines.append(spaces + "SET(" + key)
 870
 871         # --
 872         # If method is '+=', put the previous definition as first value
 873         # --
 874         if method == "+=":
 875             newlines.append("%s    ${%s}"%(spaces, key))
 876             pass
 877
 878         # --
 879         fields = value.split()
 880         for i in range(len(fields)):
 881             newlines.append("%s    %s"%(spaces, fields[i]))
 882             pass
 883
 884         # --
 885         if method == "+=":
 886             # --
 887             # The try: except KeyError is here if the +=
 888             # is an error which occurs in salome ...
 889             # --
 890             try:
 891                 self.__thedict__[key] += fields[:]
 892             except KeyError:
 893                 self.__thedict__[key] = fields[:]
 894                 pass
 895             pass
 896         else:
 897             self.__thedict__[key]  = fields[:]
 898             pass
 899
 900         # --
 901         # Close cmake SET command
 902         # --
 903
 904         newlines.append("%s)"%(spaces))
 905
 906         return
 907
 908     def finalize(self, newlines):
 909
 910         # --
 911         # Convert the .in files in build dir
 912         # --
 913         if self.module == "yacs":
 914             key = "salomegui"
 915             if self.root[-len(key):] == key:
 916                 self.files.append("resources/YACSCatalog.xml.in")
 917                 pass
 918             pass
 919         for f in self.files:
 920             if f[-3:] == ".in":
 921                 if f == "sstream.in":
 922                     continue
 923                 if f in ["runContainer.in", "stopContainer.in"]:
 924                     if self.module == "med":
 925                         if self.root[-3:] == "csh":
 926                             continue
 927                         pass
 928                     pass
 929                 if f == "SALOMEconfig.ref.in":
 930                     out = "SALOMEconfig.h"
 931                 else:
 932                     out = f[:-3]
 933                     pass
 934                 newlines.append(r'''
 935                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 936                 '''%(f))
 937                 newlines.append(r'''
 938                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 939                 '''%(out))
 940                 newlines.append(r'''
 941                 MESSAGE(STATUS "Creation of ${output}")
 942                 CONFIGURE_FILE(${input} ${output})
 943                 ''')
 944                 pass
 945             pass
 946
 947         # --
 948         # convert the SUBDIRS in cmake grammar
 949         # --
 950         if 1: # self.__thedict__.has_key("SUBDIRS"):
 951             newlines.append(r'''
 952             FOREACH(dir ${SUBDIRS})
 953             IF(NOT dir STREQUAL .)
 954             ADD_SUBDIRECTORY(${dir})
 955             ENDIF(NOT dir STREQUAL .)
 956             ENDFOREACH(dir ${SUBDIRS})
 957             ''')
 958             pass
 959
 960         # --
 961         # --
 962         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 963             if self.__thedict__.has_key(key):
 964                 self.addLibTarget(key, newlines)
 965                 pass
 966             pass
 967
 968         # --
 969         # --
 970         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
 971             if self.__thedict__.has_key(key):
 972                 self.addBinTarget(key, newlines)
 973                 pass
 974             pass
 975
 976         # --
 977         # --
 978         if self.__thedict__.has_key("BASEIDL_FILES"):
 979             if not self.__thedict__.has_key("IDL_FILES"):
 980                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 981                 newlines.append('''
 982                 SET(IDL_FILES ${BASEIDL_FILES})
 983                 ''')
 984                 pass
 985             pass
 986
 987         # --
 988         # --
 989
 990         key = "IDL_FILES"
 991         if self.__thedict__.has_key(key):
 992             if self.module == "kernel":
 993                 newlines.append('''
 994                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
 995                 ''')
 996                 pass
 997             newlines.append('''
 998             FOREACH(input ${IDL_FILES})
 999             STRING(REGEX REPLACE ".idl" "" base ${input})
1000             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1001             SET(outputs ${src})
1002             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1003             SET(outputs ${outputs} ${dynsrc})
1004             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1005             SET(outputs ${outputs} ${inc})
1006             IF(input STREQUAL Calcium_Ports.idl)
1007             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1008             ELSE(input STREQUAL Calcium_Ports.idl)
1009             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1010             ENDIF(input STREQUAL Calcium_Ports.idl)
1011             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1012             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1013             IF(NOT ISBCXX)
1014             SET(flags -bcxx ${flags})
1015             ENDIF(NOT ISBCXX)
1016             ADD_CUSTOM_COMMAND(
1017             OUTPUT ${outputs}
1018             COMMAND ${OMNIORB_IDL} ${flags} ${input}
1019             MAIN_DEPENDENCY ${input}
1020             )
1021             ''')
1022             newlines.append('''
1023             install(FILES ${input} DESTINATION idl/salome)
1024             ''')
1025             if self.module not in ["pyhello"]:
1026                 newlines.append('''
1027                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1028                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1029                 ''')
1030                 pass
1031             newlines.append('''
1032             INSTALL(CODE "SET(IDL_FILE ${input})")
1033             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
1034             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1035             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1036             # --
1037             SET(flags)
1038             FOREACH(f ${IDLPYFLAGS})
1039             SET(flags "${flags} ${f}")
1040             ENDFOREACH(f ${IDLPYFLAGS})
1041             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1042             IF(NOT ISBPYTHON)
1043             SET(flags "-bpython ${flags}")
1044             ENDIF(NOT ISBPYTHON)
1045             SET(IDLPYFLAGS ${flags})
1046             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1047             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1048             # --
1049             ''')
1050             if self.module == "kernel":
1051                 newlines.append('''
1052                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1053                 ''')
1054             else:
1055                 newlines.append('''
1056                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1057                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1058                 ''')
1059                 pass
1060             newlines.append('''
1061             ENDFOREACH(input ${IDL_FILES})
1062             ''')
1063             pass
1064
1065         # --
1066         # --
1067         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1068             if self.__thedict__.has_key(key):
1069                 newlines.append('''
1070                 SET(SWIG_SOURCES ${%s})
1071                 '''%(key))
1072                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1073                 pass
1074             pass
1075
1076         # --
1077         # --
1078         if self.__thedict__.has_key("SWIG_SOURCES"):
1079             newlines.append('''
1080             IF(SWIG_SOURCES MATCHES ";")
1081             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1082             ELSE(SWIG_SOURCES MATCHES ";")
1083             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1084             ENDIF(SWIG_SOURCES MATCHES ";")
1085             SET(flags)
1086             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1087             SET(test ON)
1088             IF(flags)
1089             LIST(FIND flags ${f} index)
1090             IF(NOT index EQUAL -1)
1091             SET(test OFF)
1092             ENDIF(NOT index EQUAL -1)
1093             ENDIF(flags)
1094             IF(test)
1095             SET(flags ${flags} ${f})
1096             ENDIF(test)
1097             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1098             ADD_CUSTOM_COMMAND(
1099             OUTPUT ${build_srcs}
1100             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1101             MAIN_DEPENDENCY ${SWIG_SOURCES}
1102             )
1103             ''')
1104             pass
1105
1106         # --
1107         # --
1108         if self.__thedict__.has_key("BUILT_SOURCES"):
1109             newlines.append('''
1110             FOREACH(f ${BUILT_SOURCES})
1111             IF(f MATCHES "WRAP.cxx$")
1112             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1113             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1114             ADD_CUSTOM_COMMAND(
1115             OUTPUT ${f} # ${inc}
1116             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1117             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1118             )
1119             ENDIF(f MATCHES "WRAP.cxx$")
1120             ENDFOREACH(f ${BUILT_SOURCES})
1121             ''')
1122             pass
1123
1124         # --
1125         # --
1126         key = "MOC_FILES"
1127         if self.__thedict__.has_key(key):
1128             newlines.append('''
1129             FOREACH(output ${MOC_FILES})
1130             ''')
1131             if self.module == "yacs":
1132                 newlines.append('''
1133                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1134                 ''')
1135             else:
1136                 newlines.append('''
1137                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1138                 ''')
1139                 pass
1140             newlines.append('''
1141             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1142             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1143             ADD_CUSTOM_COMMAND(
1144             OUTPUT ${output}
1145             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1146             MAIN_DEPENDENCY ${input}
1147             )
1148             ENDFOREACH(output ${MOC_FILES})
1149             ''')
1150             pass
1151
1152         # --
1153         # --
1154         key = "UIC_FILES"
1155         if self.__thedict__.has_key(key):
1156             newlines.append('''
1157             FOREACH(output ${UIC_FILES})
1158             STRING(REPLACE "ui_" "" input ${output})
1159             STRING(REPLACE ".h" ".ui" input ${input})
1160             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1161             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1162             ADD_CUSTOM_COMMAND(
1163             OUTPUT ${output}
1164             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1165             MAIN_DEPENDENCY ${input}
1166             )
1167             ENDFOREACH(output ${UIC_FILES})
1168             ''')
1169             pass
1170
1171         # --
1172         # --
1173         key = "QRC_FILES"
1174         if self.__thedict__.has_key(key):
1175             newlines.append('''
1176             FOREACH(output ${QRC_FILES})
1177             STRING(REGEX REPLACE "qrc_" "" input ${output})
1178             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1179             STRING(REGEX REPLACE ".qrc" "" name ${input})
1180             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1181             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1182             ADD_CUSTOM_COMMAND(
1183             OUTPUT ${output}
1184             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1185             MAIN_DEPENDENCY ${input}
1186             )
1187             ENDFOREACH(output ${QRC_FILES})
1188             ''')
1189             pass
1190
1191         # --
1192         # --
1193         key = "SIP_FILES"
1194         if self.__thedict__.has_key(key):
1195             newlines.append('''
1196             FOREACH(input ${SIP_FILES})
1197             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1198             SET(output)
1199             FOREACH(out ${SIP_SRC})
1200             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1201             ENDFOREACH(out ${SIP_SRC})
1202             ADD_CUSTOM_COMMAND(
1203             OUTPUT ${output}
1204             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1205             MAIN_DEPENDENCY ${input}
1206             )
1207             ENDFOREACH(input ${SIP_FILES})
1208             ''')
1209             pass
1210
1211         # --
1212         # Treat the install targets
1213         # --
1214         d = {
1215             "salomeadmux_DATA"            :  "salome_adm/unix",
1216             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1217             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1218             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1219             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1220             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1221             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1222             "salomeinclude_DATA"          :  "include/salome",
1223             "salomeinclude_HEADERS"       :  "include/salome",
1224             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1225             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1226             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1227             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1228             "dist_salomescript_DATA"      :  "bin/salome",
1229             "dist_salomescript_PYTHON"    :  "bin/salome",
1230             "nodist_salomescript_DATA"    :  "bin/salome",
1231             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1232             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1233             "dist_salomepython_DATA"      :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1234             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1235             }
1236         if self.module == "medfile":
1237             d = {
1238                 "include_HEADERS"        :  "include",
1239                 "nodist_include_HEADERS" :  "include",
1240                 "bin_SCRIPTS"            :  "bin",
1241                 "doc_DATA"               :  "${docdir}",
1242                 }
1243             pass
1244         for key, value in d.items():
1245             if self.__thedict__.has_key(key):
1246                 self.addInstallTarget(key, value, newlines)
1247                 pass
1248             pass
1249
1250         # --
1251         return
1252
1253     def setLibAdd(self, key, newlines):
1254         # --
1255         newlines.append(r'''
1256         SET(libadd)
1257         ''')
1258         # --
1259         newlines.append(r'''
1260         IF(WINDOWS)
1261         SET(targets)
1262         SET(targets ${targets} MEFISTO2D)
1263         FOREACH(target ${targets})
1264         IF(name STREQUAL ${target})
1265         SET(dir $ENV{F2CHOME})
1266         STRING(REPLACE "\\\\" "/" dir ${dir})
1267         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1268         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1269         ENDIF(name STREQUAL ${target})
1270         ENDFOREACH(target ${targets})
1271         ENDIF(WINDOWS)
1272         ''')
1273         # --
1274         newlines.append(r'''
1275         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1276         FOREACH(lib SALOMEBasics SalomeBatch)
1277         IF(name STREQUAL lib)
1278         SET(libs ${libs} ${PTHREAD_LIBS})
1279         ENDIF(name STREQUAL lib)
1280         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1281         ''')
1282         if key == "bin_PROGRAMS":
1283             newlines.append(r'''
1284             SET(libs ${libs} ${LDADD})
1285             ''')
1286             pass
1287         # --
1288         newlines.append(r'''
1289         FOREACH(lib ${libs})
1290         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1291         IF(ext STREQUAL .la)
1292         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1293         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1294         ENDIF(ext STREQUAL .la)
1295         SET(vars)
1296         SET(vars ${vars} -no-undefined)
1297         SET(vars ${vars} -lvtkWidgets)
1298         IF(WINDOWS)
1299         SET(vars ${vars} -module)
1300         SET(vars ${vars} -Wl,-E)
1301         SET(vars ${vars} -Xlinker)
1302         SET(vars ${vars} -export-dynamic)
1303         SET(vars ${vars} -lm)
1304         SET(vars ${vars} -lboost_thread)
1305         SET(vars ${vars} -lboost_signals)
1306         SET(vars ${vars} -pthread -lpthread -ldl)
1307         ENDIF(WINDOWS)
1308         FOREACH(v ${vars})
1309         IF(lib STREQUAL v)
1310         SET(lib)
1311         ENDIF(lib STREQUAL v)
1312         ENDFOREACH(v ${vars})
1313         SET(libadd ${libadd} ${lib})
1314         ENDFOREACH(lib ${libs})
1315         TARGET_LINK_LIBRARIES(${name} ${libadd})
1316         ''')
1317         # --
1318         newlines.append(r'''
1319         IF(WINDOWS)
1320         SET(targets)
1321         SET(targets ${targets} MEFISTO2D)
1322         FOREACH(target ${targets})
1323         IF(name STREQUAL ${target})
1324         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1325         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1326         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1327         ENDIF(name STREQUAL ${target})
1328         ENDFOREACH(target ${targets})
1329         ENDIF(WINDOWS)
1330         ''')
1331         # --
1332         return
1333
1334     def setCompilationFlags(self, key, newlines):
1335         newlines.append(r'''
1336         SET(var)
1337         IF(WINDOWS)
1338         SET(targets)
1339         SET(targets ${targets} SalomeIDLKernel)
1340         SET(targets ${targets} SalomeDS)
1341         SET(targets ${targets} SALOMEDSTest)
1342         SET(targets ${targets} SALOMEDS_Client_exe)
1343         SET(targets ${targets} SalomeIDLGEOM)
1344         SET(targets ${targets} GEOMEngine)
1345         SET(targets ${targets} MEDEngine)
1346         SET(targets ${targets} SMESHEngine)
1347         SET(targets ${targets} SMESH)
1348         FOREACH(target ${targets})
1349         IF(name STREQUAL ${target})
1350         SET(var ${var} -DNOGDI)
1351         ENDIF(name STREQUAL ${target})
1352         ENDFOREACH(target ${targets})
1353         ENDIF(WINDOWS)
1354         ''')
1355         # --
1356         if self.module in ["medfile", "yacs"]:
1357             newlines.append(r'''
1358             IF(WINDOWS)
1359             SET(var ${var} -DNOGDI)
1360             ENDIF(WINDOWS)
1361             ''')
1362             pass
1363         # --
1364         newlines.append(r'''
1365         IF(WINDOWS)
1366         SET(targets)
1367         SET(targets ${targets} MEFISTO2D)
1368         FOREACH(target ${targets})
1369         IF(name STREQUAL ${target})
1370         SET(dir $ENV{F2CHOME})
1371         STRING(REPLACE "\\\\" "/" dir ${dir})
1372         SET(var ${var} -I${dir})
1373         SET(var ${var} -DF2C_BUILD)
1374         ENDIF(name STREQUAL ${target})
1375         ENDFOREACH(target ${targets})
1376         ENDIF(WINDOWS)
1377         ''')
1378         # --
1379         if self.module in ["geom", "med"]:
1380             newlines.append(r'''
1381             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1382             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1383             ''')
1384             pass
1385         newlines.append(r'''
1386         SET(var ${var} ${AM_CPPFLAGS})
1387         SET(var ${var} ${AM_CXXFLAGS})
1388         ''')
1389         if self.module == "yacs":
1390             newlines.append(r'''
1391             SET(var ${var} -DYACS_PTHREAD)
1392             SET(var ${var} -DCMAKE_BUILD)
1393             SET(var ${var} -DSALOME_KERNEL)
1394             SET(var ${var} -DDSC_PORTS)
1395             SET(var ${var} -DOMNIORB)
1396             ''')
1397             pass
1398         newlines.append(r'''
1399         SET(var ${var} ${PLATFORM_CPPFLAGS})
1400         SET(var ${var} ${PTHREAD_CFLAGS})
1401         SET(var ${var} ${${amname}_CPPFLAGS})
1402         SET(var ${var} ${${amname}_CXXFLAGS})
1403         SET(var ${var} ${${amname}_CFLAGS})
1404         SET(vars)
1405         IF(WINDOWS)
1406         SET(vars ${vars} -include SALOMEconfig.h)
1407         SET(vars ${vars} -ftemplate-depth-32)
1408         SET(vars ${vars} -fPIC)
1409         SET(vars ${vars} -g)
1410         ENDIF(WINDOWS)
1411         SET(flags)
1412         FOREACH(f ${var})
1413         FOREACH(v ${vars})
1414         IF(f STREQUAL v)
1415         SET(f)
1416         ENDIF(f STREQUAL v)
1417         ENDFOREACH(v ${vars})
1418         SET(flags "${flags} ${f}")
1419         ENDFOREACH(f ${var})
1420         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1421         ''')
1422         return
1423
1424     def addLibTarget(self, key, newlines):
1425         newlines.append(r'''
1426         FOREACH(amname ${%s})
1427         '''%(key))
1428         # --
1429         # Replace .la by _la ...
1430         # --
1431         newlines.append(r'''
1432         STRING(REPLACE .la _la amname ${amname})
1433         ''')
1434         # --
1435         # Remove the _la for the cmake name
1436         # --
1437         newlines.append(r'''
1438         STRING(LENGTH ${amname} len)
1439         MATH(EXPR newlen "${len}-3")
1440         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1441         ''')
1442         # --
1443         # Does the target begins with lib ??
1444         # If yes, remove lib at beginning for cmake name
1445         # --
1446         newlines.append(r'''
1447         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1448         IF(BEGIN_WITH_lib)
1449         STRING(LENGTH ${name} len)
1450         MATH(EXPR newlen "${len}-3")
1451         STRING(SUBSTRING ${name} 3 ${newlen} name)
1452         ENDIF(BEGIN_WITH_lib)
1453         ''')
1454         # --
1455         # Does the target is an idl library
1456         # --
1457         newlines.append(r'''
1458         STRING(REGEX MATCH "IDL" ISIDL ${name})
1459         ''')
1460         # --
1461         # Set the type of the library
1462         # --
1463         newlines.append(r'''
1464         IF(ISIDL)
1465         IF(WINDOWS)
1466         SET(type STATIC)
1467         ELSE(WINDOWS)
1468         SET(type SHARED)
1469         ENDIF(WINDOWS)
1470         ELSE(ISIDL)
1471         SET(type SHARED)
1472         ENDIF(ISIDL)
1473         ''')
1474         if key == "noinst_LTLIBRARIES":
1475             newlines.append(r'''
1476             IF(WINDOWS)
1477             SET(type STATIC)
1478             ELSE(WINDOWS)
1479             SET(type STATIC)
1480             ENDIF(WINDOWS)
1481             ''')
1482             pass
1483         # --
1484         # Set sources for the library
1485         # --
1486         newlines.append(r'''
1487         SET(srcs)
1488         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1489         GET_FILENAME_COMPONENT(ext ${src} EXT)
1490         IF(ext STREQUAL .f)
1491         IF(src STREQUAL trte.f)
1492         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1493         STRING(REPLACE ".f" ".c" src ${src})
1494         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1495         SET(output ${src})
1496         ADD_CUSTOM_COMMAND(
1497         OUTPUT ${output}
1498         COMMAND f2c ${input}
1499         MAIN_DEPENDENCY ${input}
1500         )
1501         ELSE(src STREQUAL trte.f)
1502         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1503         STRING(REPLACE ".f" ".o" src ${src})
1504         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1505         SET(output ${src})
1506         IF(WINDOWS)
1507         SET(F77 g77)
1508         ELSE(WINDOWS)
1509         SET(F77 gfortran)
1510         ENDIF(WINDOWS)
1511         ADD_CUSTOM_COMMAND(
1512         OUTPUT ${output}
1513         COMMAND ${F77} -c -o ${output} ${input}
1514         MAIN_DEPENDENCY ${input}
1515         )
1516         ENDIF(src STREQUAL trte.f)
1517         ENDIF(ext STREQUAL .f)
1518         SET(srcs ${srcs} ${src})
1519         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1520         ''')
1521         newlines.append(r'''
1522         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1523         FOREACH(f ${l})
1524         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1525         SET(srcs ${srcs} ${src})
1526         ENDFOREACH(f ${l})
1527         ''')
1528         newlines.append(r'''
1529         SET(build_srcs)
1530         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1531         FOREACH(f ${l})
1532         GET_FILENAME_COMPONENT(ext ${f} EXT)
1533         IF(ext STREQUAL .py)
1534         ELSE(ext STREQUAL .py)
1535         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1536         ENDIF(ext STREQUAL .py)
1537         ENDFOREACH(f ${l})
1538         ''')
1539         # --
1540         # Add the library to cmake
1541         # --
1542         newlines.append(r'''
1543         ADD_LIBRARY(${name} ${type} ${srcs})
1544         ''')
1545         # --
1546         # The compilation flags
1547         # --
1548         self.setCompilationFlags(key, newlines)
1549         # --
1550         newlines.append(r'''
1551         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1552         ''')
1553         # --
1554         self.setLibAdd(key, newlines)
1555         # --
1556         if key != "noinst_LTLIBRARIES":
1557             if self.module == "medfile":
1558                 newlines.append(r'''
1559                 SET(DEST lib)
1560                 ''')
1561             else:
1562                 newlines.append(r'''
1563                 SET(DEST lib/salome)
1564                 ''')
1565                 pass
1566             newlines.append(r'''
1567             IF(BEGIN_WITH_lib)
1568             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1569             ''')
1570             if self.module == "gui":
1571                 newlines.append(r'''
1572                 FOREACH(lib SalomePyQt)
1573                 IF(name STREQUAL lib)
1574                 IF(WINDOWS)
1575                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1576                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1577                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1578                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1579                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1580                 ELSE(WINDOWS)
1581                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1582                 ENDIF(WINDOWS)
1583                 ENDIF(name STREQUAL lib)
1584                 ENDFOREACH(lib SalomePyQt)
1585                 FOREACH(lib SalomePy)
1586                 IF(name STREQUAL lib)
1587                 IF(WINDOWS)
1588                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1589                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1590                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1591                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1592                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1593                 ENDIF(WINDOWS)
1594                 ENDIF(name STREQUAL lib)
1595                 ENDFOREACH(lib SalomePy)
1596                 ''')
1597                 pass
1598             if self.module == "geom":
1599                 newlines.append(r'''
1600                 IF(WINDOWS)
1601                 STRING(REGEX MATCH "Export" ISExport ${name})
1602                 IF(ISExport)
1603                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1604                 ENDIF(ISExport)
1605                 STRING(REGEX MATCH "Import" ISImport ${name})
1606                 IF(ISImport)
1607                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1608                 ENDIF(ISImport)
1609                 ENDIF(WINDOWS)
1610                 ''')
1611                 pass
1612             newlines.append(r'''
1613             ELSE(BEGIN_WITH_lib)
1614             ''')
1615             newlines.append(r'''
1616             IF(WINDOWS)
1617             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1618             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1619             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)
1620             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1621             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)
1622             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1623             ELSE(WINDOWS)
1624             GET_TARGET_PROPERTY(version ${name} VERSION)
1625             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1626             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1627             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1628             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1629             ENDIF(WINDOWS)
1630             ''')
1631             newlines.append(r'''
1632             ENDIF(BEGIN_WITH_lib)
1633             ''')
1634             pass
1635         # --
1636         newlines.append(r'''
1637         ENDFOREACH(amname ${%s})
1638         '''%(key))
1639         # --
1640         return
1641
1642     def addBinTarget(self, key, newlines):
1643         # --
1644         newlines.append(r'''
1645         FOREACH(amname ${%s})
1646         '''%(key))
1647         # --
1648         newlines.append(r'''
1649         SET(test ON)
1650         ''')
1651         if key == "check_PROGRAMS":
1652             newlines.append(r'''
1653             IF(bin_PROGRAMS)
1654             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
1655             IF(is_present)
1656             SET(test OFF)
1657             ENDIF(is_present)
1658             ENDIF(bin_PROGRAMS)
1659             ''')
1660             pass
1661         newlines.append(r'''
1662         IF(test)
1663         ''')
1664         # --
1665         newlines.append(r'''
1666         SET(name "${amname}_exe")
1667         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1668         SET(l ${nodist_${amname}_SOURCES})
1669         FOREACH(f ${l})
1670         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1671         SET(srcs ${srcs} ${src})
1672         ENDFOREACH(f ${l})
1673         LIST(LENGTH srcs nb)
1674         IF(nb)
1675         ADD_EXECUTABLE(${name} ${srcs})
1676         ''')
1677         # --
1678         self.setCompilationFlags(key, newlines)
1679         # --
1680         self.setLibAdd(key, newlines)
1681         # --
1682         if self.module == "medfile":
1683             newlines.append(r'''
1684             SET(DEST bin)
1685             ''')
1686         else:
1687             newlines.append(r'''
1688             SET(DEST bin/salome)
1689             ''')
1690             pass
1691         # --
1692         if key == "bin_PROGRAMS":
1693             newlines.append(r'''
1694             IF(WINDOWS)
1695             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1696             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1697             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1698             ELSE(WINDOWS)
1699             SET(PERMS)
1700             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1701             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1702             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1703             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1704             ENDIF(WINDOWS)
1705             ''')
1706             pass
1707         # --
1708         newlines.append(r'''
1709         ENDIF(nb)
1710         ''')
1711         # --
1712         newlines.append(r'''
1713         ENDIF(test)
1714         ''')
1715         newlines.append(r'''
1716         ENDFOREACH(amname ${%s})
1717         '''%(key))
1718         # --
1719         return
1720
1721     def addInstallTarget(self, key, destination, newlines):
1722         newlines.append(r"FOREACH(f ${%s})"%(key))
1723         newlines.append(r'''
1724         SET(DEST %s)
1725         '''%(destination))
1726         newlines.append(r'''
1727         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1728         IF(test_SALOMEconfig.h.in)
1729         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1730         ELSE(test_SALOMEconfig.h.in)
1731         SET(dummy dummy-NOTFOUND)
1732         MARK_AS_ADVANCED(dummy)
1733         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1734         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1735         IF(dummy)
1736         ''')
1737         if key in ['dist_salomescript_SCRIPTS']:
1738             newlines.append(r'''
1739             SET(PERMS)
1740             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1741             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1742             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1743             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1744             ''')
1745         else:
1746             newlines.append(r'''
1747             GET_FILENAME_COMPONENT(ext ${f} EXT)
1748             IF(ext STREQUAL .py)
1749             IF(DEST STREQUAL bin/salome)
1750             SET(PERMS)
1751             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1752             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1753             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1754             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1755             ELSE(DEST STREQUAL bin/salome)
1756             INSTALL(FILES ${f} DESTINATION ${DEST})
1757             ENDIF(DEST STREQUAL bin/salome)
1758             ELSE(ext STREQUAL .py)
1759             INSTALL(FILES ${f} DESTINATION ${DEST})
1760             ENDIF(ext STREQUAL .py)
1761             ''')
1762             pass
1763         newlines.append(r'''
1764         ELSE(dummy)
1765         GET_FILENAME_COMPONENT(ext ${f} EXT)
1766         IF(ext STREQUAL .qm)
1767         STRING(REGEX REPLACE .qm .ts input ${f})
1768         ''')
1769         if self.module in ["kernel", "gui", "yacs"]:
1770             newlines.append(r'''
1771             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1772             ''')
1773         else:
1774             newlines.append(r'''
1775             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1776             ''')
1777             pass
1778         newlines.append(r'''
1779         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1780         # ADD_CUSTOM_COMMAND(
1781         # OUTPUT ${output}
1782         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1783         # MAIN_DEPENDENCY ${input}
1784         # )
1785         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1786         ENDIF(ext STREQUAL .qm)
1787         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1788         ENDIF(dummy)
1789         ENDIF(test_SALOMEconfig.h.in)
1790         ''')
1791         newlines.append(r'''
1792         GET_FILENAME_COMPONENT(ext ${f} EXT)
1793         IF(ext STREQUAL .py)
1794         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1795         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1796         INSTALL(CODE "SET(DEST ${DEST})")
1797         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1798         ''')
1799         if self.module == "kernel":
1800             newlines.append('''
1801             IF(f STREQUAL SALOME_ContainerPy.py)
1802             ELSE(f STREQUAL SALOME_ContainerPy.py)
1803             IF(f STREQUAL am2cmake.py)
1804             ELSE(f STREQUAL am2cmake.py)
1805             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1806             ENDIF(f STREQUAL am2cmake.py)
1807             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1808             ''')
1809         else:
1810             newlines.append('''
1811             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1812             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1813             ''')
1814             pass
1815         newlines.append(r'''
1816         ENDIF(ext STREQUAL .py)
1817         ''')
1818         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1819         return
1820
1821     def writeListsFile(self):
1822         f = open(self.listsFile, "w")
1823         f.write(self.content)
1824         f.close()
1825         return
1826
1827     pass
1828
1829 def convertAmFile(the_root, root, dirs, files, f, module):
1830     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1831     cmake.writeListsFile()
1832     return
1833
1834 def usage(exit_status):
1835     from sys import exit
1836     from sys import argv
1837     print "Usage: %s --module"%(argv[0])
1838     exit(exit_status)
1839     return
1840
1841 if __name__ == "__main__":
1842     #
1843     from sys import argv
1844     if len(argv) != 2:
1845         usage(1)
1846         pass
1847     #
1848     module = argv[1]
1849     if module.find('--') != 0:
1850         usage(1)
1851         pass
1852     module = module[2:]
1853     if len(module) == 0:
1854         usage(1)
1855         pass
1856     #
1857     from os import getcwd
1858     the_root = getcwd()
1859     #
1860     from os import walk
1861     for root, dirs, files in walk(the_root):
1862         # --
1863         # E.A. : Remove 'CVS' in dirs
1864         # E.A. : It allows to not recurse in CVS dirs
1865         # E.A. : See os module python documentation
1866         # --
1867         try:
1868             dirs.remove('CVS')
1869         except ValueError:
1870             pass
1871         # --
1872         if "Makefile.am.cmake" in files:
1873             if "Makefile.am" in files:
1874                 files.remove("Makefile.am")
1875                 pass
1876             pass
1877         # --
1878         from sys import stdout
1879         for f in files:
1880             if f in ["Makefile.am", "Makefile.am.cmake"]:
1881                 stdout.write("Scanning %s %s ..."%(root, f))
1882                 stdout.flush()
1883                 convertAmFile(the_root, root, dirs, files, f, module)
1884                 stdout.write(" done.\n")
1885                 pass
1886             pass
1887         pass
1888     #
1889     pass