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             "CalciumC",
 209             "DF",
 210             "Launcher",
 211             "LifeCycleCORBATest",
 212             "NamingServiceTest",
 213             "OpUtil",
 214             "Registry",
 215             "ResourcesManager",
 216             "SALOMEBasics",
 217             "SalomeCatalog",
 218             "SalomeCommunication",
 219             "SalomeContainer",
 220             "SalomeDatastream",
 221             "SalomeDSCContainer",
 222             "SalomeDSClient",
 223             "SalomeDSCSupervBasic",
 224             "SalomeDSCSuperv",
 225             "SalomeDSImpl",
 226             "SALOMEDSImplTest",
 227             "SalomeDS",
 228             "SALOMEDSTest",
 229             "SalomeGenericObj",
 230             "SalomeHDFPersist",
 231             "SalomeIDLKernel",
 232             "SalomeLauncher",
 233             "SalomeLifeCycleCORBA",
 234             "SALOMELocalTrace",
 235             "SALOMELocalTraceTest",
 236             "SalomeLoggerServer",
 237             "SalomeMPIContainer",
 238             "SalomeNotification",
 239             "SalomeNS",
 240             "SalomeResourcesManager",
 241             "SalomeTestComponentEngine",
 242             "SalomeTestMPIComponentEngine",
 243             "SALOMETraceCollectorTest",
 244             "TOOLSDS",
 245             "UtilsTest",
 246             "with_loggerTraceCollector",
 247             ]
 248         gui_list = [
 249             "caf",
 250             "CAM",
 251             "CASCatch",
 252             "DDS",
 253             "Event",
 254             "GLViewer",
 255             "LightApp",
 256             "LogWindow",
 257             "ObjBrowser",
 258             "OCCViewer",
 259             "OpenGLUtils",
 260             "Plot2d",
 261             "PyConsole",
 262             "PyInterp",
 263             "QDS",
 264             "qtx",
 265             "QxScene",
 266             "SalomeApp",
 267             "SalomeAppTest",
 268             "SalomeIDLGUI",
 269             "SalomeObject",
 270             "SalomePrs",
 271             "SalomePyQtGUILight",
 272             "SalomePyQtGUI",
 273             "SalomePyQt",
 274             "SalomePy",
 275             "SalomeSession",
 276             "SalomeStyle",
 277             "SOCC",
 278             "SPlot2d",
 279             "std",
 280             "SUITApp",
 281             "suit",
 282             "SUPERVGraph",
 283             "SVTK",
 284             "ToolsGUI",
 285             "ViewerTools",
 286             "VTKViewer",
 287             ]
 288         geom_list = [
 289             "AdvancedGUI",
 290             "BasicGUI",
 291             "BlocksGUI",
 292             "BooleanGUI",
 293             "BREPExport",
 294             "BREPImport",
 295             "BuildGUI",
 296             "DisplayGUI",
 297             "DlgRef",
 298             "EntityGUI",
 299             "GenerationGUI",
 300             "GEOMAlgo",
 301             "GEOMArchimede",
 302             "GEOMBase",
 303             "GEOMbasic",
 304             "GEOMClient",
 305             "GEOMEngine",
 306             "GEOMFiltersSelection",
 307             "GEOMimpl",
 308             "GEOMObject",
 309             "GEOMSketcher",
 310             "GEOM",
 311             "GEOM_SupervEngine",
 312             "GEOMToolsGUI",
 313             "GroupGUI",
 314             "IGESExport",
 315             "IGESImport",
 316             "MeasureGUI",
 317             "NMTDS",
 318             "NMTTools",
 319             "OCC2VTK",
 320             "OperationGUI",
 321             "PrimitiveGUI",
 322             "RepairGUI",
 323             "SalomeIDLGEOM",
 324             "ShHealOper",
 325             "STEPExport",
 326             "STEPImport",
 327             "STLExport",
 328             "TransformationGUI",
 329             "VTKExport",
 330             ]
 331         med_list = [
 332             "interpkernel",
 333             "InterpKernelTest",
 334             "MEDClientcmodule",
 335             "medcouplingclient",
 336             "medcouplingcorba",
 337             "medcouplingremapper",
 338             "medcoupling",
 339             "MEDEngine",
 340             "medloader",
 341             "MEDMEMCppTest",
 342             "MEDMEMImpl",
 343             "medmem",
 344             "MED",
 345             "medsplitter",
 346             "MEDSPLITTERTest",
 347             "med_V2_1",
 348             "MEDWrapperBase",
 349             "MEDWrapper",
 350             "MEDWrapper_V2_1",
 351             "MEDWrapper_V2_2",
 352             "paramedcouplingcorba",
 353             "paramedloader",
 354             "paramedmemcompo",
 355             "paramedmem",
 356             "ParaMEDMEMTest",
 357             "SalomeIDLMED",
 358             "SalomeIDLMEDTests",
 359             ]
 360         smesh_list = [
 361             "GeomSelectionTools",
 362             "MEFISTO2D",
 363             "MeshDriverDAT",
 364             "MeshDriverMED",
 365             "MeshDriver",
 366             "MeshDriverSTL",
 367             "MeshDriverUNV",
 368             "SalomeIDLSMESH",
 369             "SMDS",
 370             "SMESHClient",
 371             "SMESHControls",
 372             "SMESHDS",
 373             "SMESHEngine",
 374             "SMESHFiltersSelection",
 375             "SMESHimpl",
 376             "SMESHObject",
 377             "SMESH",
 378             "StdMeshersEngine",
 379             "StdMeshersGUI",
 380             "StdMeshers",
 381             ]
 382         full_list  = cas_list + vtk_list
 383         full_list += kernel_list + gui_list
 384         full_list += geom_list + med_list + smesh_list
 385         # --
 386         # E.A. : sort by len before substitution ...
 387         # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 388         # And you understand ...
 389         # --
 390         full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 391         # --
 392         for key in full_list:
 393             content = content.replace("-l%s"%(key), "${%s}"%(key))
 394             pass
 395
 396         # --
 397         # Split content in lines to treat each one separately
 398         # --
 399         lines = content.split('\n')
 400
 401         # --
 402         # newlines contains the lines of the future CMakeLists.txt file
 403         # --
 404         newlines = []
 405
 406         # --
 407         # opened_ifs is used to deals with nested conditionnals
 408         # --
 409         opened_ifs = []
 410
 411         # --
 412         # the __thedict__ dictionnary contains key, val
 413         # of the Makefile.am file
 414         # --
 415         self.__thedict__ = {}
 416
 417         # --
 418         # Initialize file ... mainly includes other cmake files
 419         # --
 420         self.initialize(newlines)
 421
 422         # --
 423         # Do the job for each line
 424         # --
 425         for line in lines:
 426             self.treatLine(line, newlines, opened_ifs)
 427             pass
 428
 429         # --
 430         # Finalize file ... it is in here the cmake job is done
 431         # --
 432         self.finalize(newlines)
 433
 434         # --
 435         # Concatenate newlines into content
 436         # --
 437         content = '\n'.join(newlines)
 438
 439         # --
 440         # Add a CR at end if necessary
 441         # --
 442         lines = content.split('\n')
 443         # lines = [ l.strip() for l in lines ]
 444         if len(lines[-1]) != 0:
 445             lines.append('')
 446             pass
 447         content = '\n'.join(lines)
 448
 449         # --
 450         self.content = content
 451
 452         # --
 453         return
 454
 455     def initialize(self, newlines):
 456         if self.root == self.the_root:
 457             # --
 458             newlines.append("""
 459             CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
 460             IF(COMMAND cmake_policy)
 461             cmake_policy(SET CMP0003 NEW)
 462             ENDIF(COMMAND cmake_policy)
 463             """)
 464             # --
 465             newlines.append("""
 466             ENABLE_TESTING()
 467             """)
 468             # --
 469             if self.module == "kernel":
 470                 newlines.append("""
 471                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 472                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 473                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 474                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 475                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 476                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 477                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 478                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 479                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 480                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 481                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 482                 """)
 483                 pass
 484             else:
 485                 if self.module == "med":
 486                     newlines.append("""
 487                     SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 488                     IF(KERNEL_ROOT_DIR)
 489                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 490                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 491                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 492                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 493                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 494                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 495                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 496                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 497                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 498                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 499                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 500                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 501                     ELSE(KERNEL_ROOT_DIR)
 502                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
 503                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
 504                     ENDIF(KERNEL_ROOT_DIR)
 505                     """)
 506                 else:
 507                     newlines.append("""
 508                     SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 509                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 510                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 511                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 512                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 513                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 514                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 515                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 516                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 517                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 518                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
 519                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
 520                     INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 521                     """)
 522                     pass
 523                 if self.module == "gui":
 524                     newlines.append("""
 525                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 526                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 527                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 528                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 529                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 530                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 531                     """)
 532                 else:
 533                     newlines.append("""
 534                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 535                     IF(GUI_ROOT_DIR)
 536                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 537                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 538                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 539                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 540                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 541                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 542                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 543                     ENDIF(GUI_ROOT_DIR)
 544                     """)
 545                     if self.module == "med":
 546                         newlines.append("""
 547                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 548                         IF(WINDOWS)
 549                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
 550                         ENDIF(WINDOWS)
 551                         """)
 552                         pass
 553                     if self.module == "smesh":
 554                         newlines.append("""
 555                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 556                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 557                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 558                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 559                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 560                         """)
 561                         pass
 562                     if self.module == "netgenplugin":
 563                         newlines.append("""
 564                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 565                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 566                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 567                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 568                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 569                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 570                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 571                         """)
 572                         pass
 573                     if self.module == "blsurfplugin":
 574                         newlines.append("""
 575                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 576                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 577                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 578                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 579                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 580                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 581                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 582                         """)
 583                         pass
 584                     if self.module in ["ghs3dplugin", "hexoticplugin"]:
 585                         newlines.append("""
 586                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 587                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 588                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 589                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 590                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 591                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 592                         """)
 593                         pass
 594                     if self.module == "ghs3dprlplugin":
 595                         newlines.append("""
 596                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 597                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 598                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 599                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 600                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 601                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 602                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 603                         """)
 604                         pass
 605                     if self.module == "visu":
 606                         newlines.append("""
 607                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 608                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 609                         """)
 610                         pass
 611                     if self.module == "yacs":
 612                         newlines.append("""
 613                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
 614                         INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
 615                         """)
 616                         pass
 617                     if self.module == "hxx2salome":
 618                         newlines.append("""
 619                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 620                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 621                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 622                         """)
 623                         pass
 624                     pass
 625                 pass
 626             # --
 627             newlines.append("""
 628             SET(DOXYGEN_IS_OK 0)
 629             """)
 630             if self.module not in ['med']:
 631                 newlines.append("""
 632                 IF(WINDOWS)
 633                 SET(CPPUNIT_IS_OK 0)
 634                 ENDIF(WINDOWS)
 635                 """)
 636                 pass
 637             # --
 638             if self.module == "kernel":
 639                 newlines.append("""
 640                 SET(WITH_LOCAL 1)
 641                 SET(WITH_BATCH 1)
 642                 SET(CALCIUM_IDL_INT_F77 long)
 643                 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
 644                 SET(LONG_OR_INT int)
 645                 """)
 646             elif self.module == "gui":
 647                 newlines.append("""
 648                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 649                 SET(ENABLE_VTKVIEWER ON)
 650                 SET(ENABLE_SALOMEOBJECT ON)
 651                 SET(ENABLE_OCCVIEWER ON)
 652                 SET(ENABLE_GLVIEWER ON)
 653                 SET(ENABLE_PLOT2DVIEWER ON)
 654                 SET(ENABLE_PYCONSOLE ON)
 655                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 656                 SET(ENABLE_QXGRAPHVIEWER ON)
 657                 """)
 658                 pass
 659             elif self.module == "geom":
 660                 newlines.append("""
 661                 IF(GUI_ROOT_DIR)
 662                 SET(GEOM_ENABLE_GUI ON)
 663                 ENDIF(GUI_ROOT_DIR)
 664                 """)
 665                 pass
 666             elif self.module == "medfile":
 667                 newlines.append("""
 668                 SET(MED_NUM_MAJEUR 2)
 669                 SET(MED_NUM_MINEUR 3)
 670                 SET(MED_NUM_RELEASE 5)
 671                 SET(LONG_OR_INT int)
 672                 IF(NOT WINDOWS)
 673                 SET(FLIBS -lgfortranbegin -lgfortran)
 674                 ENDIF(NOT WINDOWS)
 675                 """)
 676                 pass
 677             elif self.module == "med":
 678                 newlines.append("""
 679                 IF(KERNEL_ROOT_DIR)
 680                 SET(MED_ENABLE_KERNEL ON)
 681                 IF(NOT WINDOWS)
 682                 SET(MED_ENABLE_SPLITTER ON)
 683                 ENDIF(NOT WINDOWS)
 684                 ENDIF(KERNEL_ROOT_DIR)
 685                 IF(GUI_ROOT_DIR)
 686                 SET(MED_ENABLE_GUI ON)
 687                 ENDIF(GUI_ROOT_DIR)
 688                 """)
 689                 pass
 690             elif self.module == "smesh":
 691                 newlines.append("""
 692                 IF(GUI_ROOT_DIR)
 693                 SET(SMESH_ENABLE_GUI ON)
 694                 ENDIF(GUI_ROOT_DIR)
 695                 """)
 696                 pass
 697             elif self.module == "netgen":
 698                 newlines.append("""
 699                 SET(OCCFLAGS ${CAS_CPPFLAGS})
 700                 SET(OCCLIBS ${CAS_LDPATH})
 701                 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
 702                 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
 703                 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
 704                 """)
 705                 pass
 706             elif self.module == "netgenplugin":
 707                 newlines.append("""
 708                 IF(GUI_ROOT_DIR)
 709                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 710                 ENDIF(GUI_ROOT_DIR)
 711                 """)
 712                 pass
 713             elif self.module == "blsurfplugin":
 714                 newlines.append("""
 715                 IF(GUI_ROOT_DIR)
 716                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 717                 ENDIF(GUI_ROOT_DIR)
 718                 """)
 719                 pass
 720             elif self.module == "ghs3dplugin":
 721                 newlines.append("""
 722                 IF(GUI_ROOT_DIR)
 723                 SET(GHS3DPLUGIN_ENABLE_GUI ON)
 724                 ENDIF(GUI_ROOT_DIR)
 725                 """)
 726                 pass
 727             elif self.module == "hexoticplugin":
 728                 newlines.append("""
 729                 IF(GUI_ROOT_DIR)
 730                 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
 731                 ENDIF(GUI_ROOT_DIR)
 732                 """)
 733                 pass
 734             elif self.module == "ghs3dprlplugin":
 735                 newlines.append("""
 736                 IF(GUI_ROOT_DIR)
 737                 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
 738                 ENDIF(GUI_ROOT_DIR)
 739                 """)
 740                 pass
 741             elif self.module == "yacs":
 742                 newlines.append("""
 743                 SET(SALOME_KERNEL ON)
 744                 SET(HAS_GUI ON)
 745                 SET(WITH_QT4 ON)
 746                 """)
 747                 pass
 748             # --
 749             newlines.append("""
 750             set(VERSION 5.1.5)
 751             set(XVERSION 0x050105)
 752             """)
 753             pass
 754         # --
 755         newlines.append("""
 756         SET(VERSION_INFO 0.0.0)
 757         SET(SOVERSION_INFO 0)
 758         SET(SUBDIRS)
 759         SET(AM_CPPFLAGS)
 760         SET(AM_CXXFLAGS)
 761         SET(LDADD)
 762         SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
 763         SET(salomepythondir ${pythondir}/salome)
 764         SET(salomepypkgdir ${salomepythondir}/salome)
 765         """)
 766         if self.module == "netgen":
 767             newlines.append(r'''
 768             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_BINARY_DIR} -I${CMAKE_CURRENT_SOURCE_DIR})
 769             ''')
 770         elif self.module == "kernel":
 771             newlines.append(r'''
 772             SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 773             SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
 774             ''')
 775         else:
 776             if self.module not in ["yacs"]:
 777                 newlines.append(r'''
 778                 IF(KERNEL_ROOT_DIR)
 779                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 780                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
 781                 ENDIF(KERNEL_ROOT_DIR)
 782                 ''')
 783                 pass
 784             if self.module == "hxx2salome":
 785                 key = "_SRC"
 786                 if self.the_root[-len(key):] != key:
 787                     msg = "Source dir must finished with %s !"%(key)
 788                     raise Exception(msg)
 789                 hxxmodule = self.the_root[:-len(key)]
 790                 from os.path import basename
 791                 hxxmodule = basename(hxxmodule)
 792                 hxxmodule = hxxmodule.lower()
 793                 self.hxxmodule = hxxmodule
 794                 newlines.append(r'''
 795                 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
 796                 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 797                 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
 798                 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
 799                 '''%(hxxmodule.upper()))
 800                 pass
 801             pass
 802         # --
 803         return
 804
 805     def treatLine(self, line, newlines, opened_ifs):
 806
 807         # --
 808         # Print the comment above the line itself
 809         # --
 810         if line.find('#') >= 0:
 811             fields = line.split('#')
 812             line = fields[0]
 813             comment = '#'.join([''] + fields[1:])
 814             newlines.append(comment)
 815             if len(line) == 0:
 816                 return
 817             pass
 818
 819         # --
 820         # If the line begins with 'include ', just comment it
 821         # --
 822         if line.find("include ") == 0:
 823             newlines.append("# " + line)
 824             return
 825
 826         # --
 827         # If the line begins with '-include', just comment it
 828         # --
 829         if line.find("-include") == 0:
 830             newlines.append("# " + line)
 831             return
 832
 833         # --
 834         # If the line is a definition of a make rule, just comment it
 835         # --
 836         if line.count(':') == 1:
 837             newlines.append("# " + line)
 838             return
 839
 840         # --
 841         # A particuliar case where there are two ":" on the same line
 842         # --
 843         if line.find('install-exec-local:') == 0:
 844             newlines.append("# " + line)
 845             return
 846
 847         # --
 848         # If the line begin by a tabulation, consider it's a makefile command and comment it
 849         # --
 850         if line.find("\t") == 0:
 851             newlines.append("# " + line)
 852             return
 853
 854         # --
 855         # --
 856         key = "-version-info"
 857         if line.find(key) >= 0:
 858             # --
 859             before = line.split(key)[0]
 860             after = line[len(before)+len(key):]
 861             sep = after[0]
 862             after = after[1:]
 863             version_info = after.split()[0]
 864             line = line.replace(key+sep+version_info, "")
 865             # --
 866             version_info = version_info.replace(':', '.')
 867             soversion_info = version_info.split('.')[0]
 868             newlines.append("SET(VERSION_INFO " + version_info + ")")
 869             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 870             # --
 871             pass
 872
 873         # --
 874         # Replace the $(TOTO) by ${TOTO}
 875         # Replace the @TOTO@  by ${TOTO}
 876         # --
 877         line = p_dollar.sub(r"${\1}", line)
 878         line = p_arobas.sub(r"${\1}", line)
 879
 880         # --
 881         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 882         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 883         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 884         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 885         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 886
 887         # --
 888         # Check if the line is a 'if' condition
 889         # If yes, replace it by a cmake grammar
 890         # --
 891         match = p_if.match(line)
 892         if match:
 893             theif = match.group("val")
 894             if theif[0] == "!":
 895                 theif = "NOT " + theif[1:]
 896                 pass
 897             line = p_if.sub(r"IF(%s)"%(theif), line)
 898             opened_ifs.append(theif)
 899             newlines.append(line)
 900             return
 901
 902         # --
 903         # Check if the line is a 'else' condition
 904         # If yes, replace it by a cmake grammar
 905         # --
 906         match = p_else.match(line)
 907         if match:
 908             line = "ELSE(%s)"%(opened_ifs[-1])
 909             newlines.append(line)
 910             return
 911
 912         # --
 913         # Check if the line is a 'endif' condition
 914         # If yes, replace it by a cmake grammar
 915         # --
 916         match = p_endif.match(line)
 917         if match:
 918             line = "ENDIF(%s)"%(opened_ifs[-1])
 919             opened_ifs[-1:] = []
 920             newlines.append(line)
 921             return
 922
 923         # --
 924         # Check if the line is an attribution '=' or '+='
 925         # --
 926         match = p_attribution.match(line)
 927         if match:
 928             self.treatAttribution(match, newlines)
 929             return
 930
 931         # --
 932         newlines.append(line)
 933
 934         # --
 935         return
 936
 937     def treatAttribution(self, match, newlines):
 938
 939         spaces = match.group("spaces")
 940         key = match.group("key")
 941         method = match.group("method")
 942         value = match.group("value")
 943         # print [spaces, key, method, value]
 944
 945         # --
 946         # Open cmake SET command
 947         # --
 948         newlines.append(spaces + "SET(" + key)
 949
 950         # --
 951         # If method is '+=', put the previous definition as first value
 952         # --
 953         if method == "+=":
 954             newlines.append("%s    ${%s}"%(spaces, key))
 955             pass
 956
 957         # --
 958         fields = value.split()
 959         for i in range(len(fields)):
 960             newlines.append("%s    %s"%(spaces, fields[i]))
 961             pass
 962
 963         # --
 964         if method == "+=":
 965             # --
 966             # The try: except KeyError is here if the +=
 967             # is an error which occurs in salome ...
 968             # --
 969             try:
 970                 self.__thedict__[key] += fields[:]
 971             except KeyError:
 972                 self.__thedict__[key] = fields[:]
 973                 pass
 974             pass
 975         else:
 976             self.__thedict__[key]  = fields[:]
 977             pass
 978
 979         # --
 980         # Close cmake SET command
 981         # --
 982
 983         newlines.append("%s)"%(spaces))
 984
 985         return
 986
 987     def finalize(self, newlines):
 988
 989         # --
 990         # Convert the .in files in build dir
 991         # --
 992
 993         import operator
 994         mod = self.module
 995         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
 996             newlines.append(r'''
 997             SET(top_builddir
 998                 ${CMAKE_BINARY_DIR}
 999             )
1000             SET(top_srcdir
1001                 ${CMAKE_SOURCE_DIR}
1002             )
1003             SET(srcdir
1004                 ${CMAKE_CURRENT_SOURCE_DIR}
1005             )
1006             SET(builddir
1007                 ${CMAKE_CURRENT_BINARY_DIR}
1008             )
1009             SET(datadir
1010                 ${CMAKE_INSTALL_PREFIX}/share
1011             )
1012             SET(docdir
1013                 ${datadir}/doc/salome
1014             )
1015             ''')
1016             self.files.append("static/header.html.in")
1017         elif self.root[-len(mod):] == mod.upper() and operator.contains(self.root, 'doc') or mod in ['kernel', 'gui', 'geom', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1018             newlines.append(r'''
1019             SET(top_builddir
1020                 ${CMAKE_BINARY_DIR}
1021             )
1022             SET(top_srcdir
1023                 ${CMAKE_SOURCE_DIR}
1024             )
1025             SET(srcdir
1026                 ${CMAKE_CURRENT_SOURCE_DIR}
1027             )
1028             SET(builddir
1029                 ${CMAKE_CURRENT_BINARY_DIR}
1030             )
1031             SET(datadir
1032                 ${CMAKE_INSTALL_PREFIX}/share
1033             )
1034             SET(docdir
1035                 ${datadir}/doc/salome
1036             )
1037             ''')
1038             self.files.append("static/header.html.in")
1039         if self.module == "yacs":
1040             key = "salomegui"
1041             if self.root[-len(key):] == key:
1042                 self.files.append("resources/YACSCatalog.xml.in")
1043                 pass
1044             pass
1045         for f in self.files:
1046             if f[-3:] == ".in":
1047                 if self.module == 'yacs' and f == "Doxyfile.in":
1048                     continue
1049                 if f == "sstream.in":
1050                     continue
1051                 if f in ["runContainer.in", "stopContainer.in"]:
1052                     if self.module == "med":
1053                         if self.root[-3:] == "csh":
1054                             continue
1055                         pass
1056                     pass
1057                 if f == "SALOMEconfig.ref.in":
1058                     out = "SALOMEconfig.h"
1059                 else:
1060                     out = f[:-3]
1061                     pass
1062                 newlines.append(r'''
1063                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1064                 '''%(f))
1065                 newlines.append(r'''
1066                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1067                 '''%(out))
1068                 newlines.append(r'''
1069                 MESSAGE(STATUS "Creation of ${output}")
1070                 CONFIGURE_FILE(${input} ${output})
1071                 ''')
1072                 pass
1073             pass
1074
1075         # --
1076         # add commands for generating of user's documentation
1077         # --
1078
1079         upmod = self.module.upper()
1080         doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1081         doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1082         doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1083         head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1084         if mod == 'kernel':
1085             copytree_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files"
1086         else:
1087             copytree_src = "$ENV{KERNEL_ROOT_DIR}/salome_adm/cmake_files"
1088         str = "import re \nimport sys \noutfile = open(sys.argv[1], 'wb') \nfor line in open(sys.argv[2], 'rb').readlines():"
1089         str += "\n    if re.match('class '+sys.argv[3]+'DC', line): \n        continue \n    line = re.sub(r'^\s+\#', '#', line) \n    line = re.sub(r'^\s+def', 'def', line) \n    line = re.sub(sys.argv[3]+'DC', sys.argv[3], line)"
1090         str += "\n    outfile.write(line) \noutfile.close()"
1091
1092         if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1093             if mod == 'med':
1094                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1095                 input = "Doxyfile_med_user"
1096             else:
1097                 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1098                 input = ""
1099             newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1100             COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1101             VERBATIM
1102             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1103             )"""%(input, copytree_src, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1104
1105         if mod in ['geom', 'smesh', 'visu'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc'):
1106             ign = r"""'tempfile', '*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1107             if mod in ['geom', 'smesh']:
1108                 if mod == 'geom':
1109                     tmp = 'geompy'
1110                     input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1111                 else:
1112                     tmp =  'smesh'
1113                     input = ''
1114                 newlines.append(r"""
1115                 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1116                 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1117                 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1118                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1119                 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1120                 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''', r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''', r'''%s''')"
1121                 VERBATIM
1122                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1123                 )"""%(str, upmod, tmp, upmod, tmp, tmp, input, upmod, tmp, copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1124             else:
1125                 newlines.append("""\t    ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} doxyfile_idl
1126                 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1127                 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''',True); import copytree1; copytree1.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''',r'''%s''', ignore=copytree1.ignore_patterns(%s)); shutil.copy(r'''%s''',r'''%s''')"
1128                 VERBATIM
1129                 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1130                 )"""%(copytree_src, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1131
1132         # --
1133         # add commands for generating of developer's documentation
1134         # --
1135
1136         upmod = self.module.upper()
1137         if mod in ['kernel', 'gui', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1138             if mod == 'kernel':
1139                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1140             COMMAND ${DOXYGEN_EXECUTABLE}
1141             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')"  """
1142                 tmp1=""
1143             else:
1144                 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1145                 if mod == 'visu':
1146                     tmp1= r"""\n           COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/visuscreen.png''', r'''%s''')" """%(doc_tui_destination)
1147                 elif mod == 'smesh':
1148                     extra_srcdir = "${CMAKE_CURRENT_SOURCE_DIR}/extra"
1149                     tmp1= """\n            COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.pdf''', r'''%s'''); copy(r'''%s/PluginMeshers.html''', r'''%s''')"
1150             COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''%s/AddNetgenInSalome2.ps''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.sxw''', r'''%s''')" """%(doc_tui_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination,extra_srcdir,doc_destination)
1151                 else:
1152                     tmp1=""
1153             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1154             newlines.append(tmp + """
1155             COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')" """%(copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination) + tmp1 + """
1156             VERBATIM
1157             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1158             )""")
1159         if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1160             tmp = 'geompy'
1161             doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1162             newlines.append(r"""
1163             FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/tempfile "%s")
1164             ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} tempfile ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1165             COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1166             COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1167             COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; sys.path.append(r'''%s'''); shutil.rmtree(r'''%s''', True); import copytree1; copytree1.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s'''); shutil.copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/geomscreen.png''', r'''%s''')"
1168             VERBATIM
1169             WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1170             )"""%(str, upmod, tmp, upmod, tmp, tmp, upmod, tmp, copytree_src, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination, doc_tui_destination))
1171
1172         # --
1173         # convert the SUBDIRS in cmake grammar
1174         # --
1175         if 1: # self.__thedict__.has_key("SUBDIRS"):
1176             newlines.append(r'''
1177             FOREACH(dir ${SUBDIRS})
1178             IF(NOT dir STREQUAL .)
1179             ADD_SUBDIRECTORY(${dir})
1180             ENDIF(NOT dir STREQUAL .)
1181             ENDFOREACH(dir ${SUBDIRS})
1182             ''')
1183             pass
1184
1185         # --
1186         # --
1187         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
1188             if self.__thedict__.has_key(key):
1189                 self.addLibTarget(key, newlines)
1190                 pass
1191             pass
1192
1193         # --
1194         # --
1195         for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1196             if self.__thedict__.has_key(key):
1197                 self.addBinTarget(key, newlines)
1198                 pass
1199             pass
1200
1201         # --
1202         # --
1203         if self.__thedict__.has_key("BASEIDL_FILES"):
1204             if not self.__thedict__.has_key("IDL_FILES"):
1205                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1206                 newlines.append('''
1207                 SET(IDL_FILES ${BASEIDL_FILES})
1208                 ''')
1209                 pass
1210             pass
1211
1212         # --
1213         # --
1214
1215         key = "IDL_FILES"
1216         if self.__thedict__.has_key(key):
1217             if self.module == "kernel":
1218                 newlines.append('''
1219                 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1220                 ''')
1221                 pass
1222             newlines.append('''
1223             FOREACH(input ${IDL_FILES})
1224             STRING(REGEX REPLACE ".idl" "" base ${input})
1225             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1226             SET(outputs ${src})
1227             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1228             SET(outputs ${outputs} ${dynsrc})
1229             SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1230             SET(outputs ${outputs} ${inc})
1231             IF(input STREQUAL Calcium_Ports.idl)
1232             SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1233             ELSE(input STREQUAL Calcium_Ports.idl)
1234             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1235             ENDIF(input STREQUAL Calcium_Ports.idl)
1236             SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1237             STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1238             IF(NOT ISBCXX)
1239             SET(flags -bcxx ${flags})
1240             ENDIF(NOT ISBCXX)
1241             ADD_CUSTOM_COMMAND(
1242             OUTPUT ${outputs}
1243             COMMAND ${OMNIORB_IDL} ${flags} ${input}
1244             MAIN_DEPENDENCY ${input}
1245             )
1246             ''')
1247             newlines.append('''
1248             install(FILES ${input} DESTINATION idl/salome)
1249             ''')
1250             if self.module not in ["pyhello"]:
1251                 newlines.append('''
1252                 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1253                 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1254                 ''')
1255                 pass
1256             newlines.append('''
1257             INSTALL(CODE "SET(IDL_FILE ${input})")
1258             INSTALL(CODE "SET(DIR ${salomepythondir})")
1259             IF(WINDOWS)
1260             INSTALL(CODE "SET(DIR bin/salome)")
1261             ENDIF(WINDOWS)
1262             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1263             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1264             # --
1265             SET(flags)
1266             FOREACH(f ${IDLPYFLAGS})
1267             SET(flags "${flags} ${f}")
1268             ENDFOREACH(f ${IDLPYFLAGS})
1269             STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1270             IF(NOT ISBPYTHON)
1271             SET(flags "-bpython ${flags}")
1272             ENDIF(NOT ISBPYTHON)
1273             SET(IDLPYFLAGS ${flags})
1274             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1275             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1276             # --
1277             ''')
1278             if self.module == "kernel":
1279                 newlines.append('''
1280                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1281                 ''')
1282             else:
1283                 newlines.append('''
1284                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1285                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1286                 ''')
1287                 pass
1288             newlines.append('''
1289             ENDFOREACH(input ${IDL_FILES})
1290             ''')
1291             pass
1292
1293         # --
1294         # --
1295         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1296             if self.__thedict__.has_key(key):
1297                 newlines.append('''
1298                 SET(SWIG_SOURCES ${%s})
1299                 '''%(key))
1300                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1301                 pass
1302             pass
1303
1304         # --
1305         # --
1306         if self.__thedict__.has_key("SWIG_SOURCES"):
1307             newlines.append('''
1308             IF(SWIG_SOURCES MATCHES ";")
1309             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1310             ELSE(SWIG_SOURCES MATCHES ";")
1311             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1312             ENDIF(SWIG_SOURCES MATCHES ";")
1313             SET(flags)
1314             FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1315             SET(test ON)
1316             IF(flags)
1317             LIST(FIND flags ${f} index)
1318             IF(NOT index EQUAL -1)
1319             SET(test OFF)
1320             ENDIF(NOT index EQUAL -1)
1321             ENDIF(flags)
1322             IF(test)
1323             SET(flags ${flags} ${f})
1324             ENDIF(test)
1325             ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1326             ADD_CUSTOM_COMMAND(
1327             OUTPUT ${build_srcs}
1328             COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1329             MAIN_DEPENDENCY ${SWIG_SOURCES}
1330             )
1331             ''')
1332             pass
1333
1334         # --
1335         # --
1336         if self.__thedict__.has_key("BUILT_SOURCES"):
1337             newlines.append('''
1338             FOREACH(f ${BUILT_SOURCES})
1339             IF(f MATCHES "WRAP.cxx$")
1340             # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1341             STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1342             ADD_CUSTOM_COMMAND(
1343             OUTPUT ${f} # ${inc}
1344             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1345             MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1346             )
1347             ENDIF(f MATCHES "WRAP.cxx$")
1348             ENDFOREACH(f ${BUILT_SOURCES})
1349             ''')
1350             pass
1351
1352         # --
1353         # --
1354         key = "MOC_FILES"
1355         if self.__thedict__.has_key(key):
1356             newlines.append('''
1357             FOREACH(output ${MOC_FILES})
1358             ''')
1359             if self.module == "yacs":
1360                 newlines.append('''
1361                 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1362                 ''')
1363             else:
1364                 newlines.append('''
1365                 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1366                 ''')
1367                 pass
1368             newlines.append('''
1369             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1370             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1371             ADD_CUSTOM_COMMAND(
1372             OUTPUT ${output}
1373             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1374             MAIN_DEPENDENCY ${input}
1375             )
1376             ENDFOREACH(output ${MOC_FILES})
1377             ''')
1378             pass
1379
1380         # --
1381         # --
1382         key = "UIC_FILES"
1383         if self.__thedict__.has_key(key):
1384             newlines.append('''
1385             FOREACH(output ${UIC_FILES})
1386             STRING(REPLACE "ui_" "" input ${output})
1387             STRING(REPLACE ".h" ".ui" input ${input})
1388             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1389             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1390             ADD_CUSTOM_COMMAND(
1391             OUTPUT ${output}
1392             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1393             MAIN_DEPENDENCY ${input}
1394             )
1395             ENDFOREACH(output ${UIC_FILES})
1396             ''')
1397             pass
1398
1399         # --
1400         # --
1401         key = "QRC_FILES"
1402         if self.__thedict__.has_key(key):
1403             newlines.append('''
1404             FOREACH(output ${QRC_FILES})
1405             STRING(REGEX REPLACE "qrc_" "" input ${output})
1406             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1407             STRING(REGEX REPLACE ".qrc" "" name ${input})
1408             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1409             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1410             ADD_CUSTOM_COMMAND(
1411             OUTPUT ${output}
1412             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1413             MAIN_DEPENDENCY ${input}
1414             )
1415             ENDFOREACH(output ${QRC_FILES})
1416             ''')
1417             pass
1418
1419         # --
1420         # --
1421         key = "SIP_FILES"
1422         if self.__thedict__.has_key(key):
1423             newlines.append('''
1424             FOREACH(input ${SIP_FILES})
1425             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1426             SET(output)
1427             FOREACH(out ${SIP_SRC})
1428             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1429             ENDFOREACH(out ${SIP_SRC})
1430             ADD_CUSTOM_COMMAND(
1431             OUTPUT ${output}
1432             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1433             MAIN_DEPENDENCY ${input}
1434             )
1435             ENDFOREACH(input ${SIP_FILES})
1436             ''')
1437             pass
1438
1439         # --
1440         # For make check
1441         # --
1442         for key in ["TESTS"]:
1443             if self.__thedict__.has_key(key):
1444                 newlines.append('''
1445                 SET(UNIT_TEST_PROG ${%s})
1446                 '''%(key))
1447                 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1448                 pass
1449             pass
1450         key = "UNIT_TEST_PROG"
1451         if self.__thedict__.has_key(key):
1452             newlines.append('''
1453             FOREACH(input ${UNIT_TEST_PROG})
1454             GET_FILENAME_COMPONENT(ext ${input} EXT)
1455             IF(ext STREQUAL .py)
1456             SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1457             ELSE(ext STREQUAL .py)
1458             IF(WINDOWS)
1459             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1460             ELSE()
1461             SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1462             ENDIF()
1463             ENDIF(ext STREQUAL .py)
1464             ADD_TEST(${input} ${test})
1465             SET(fail_regex "KO")
1466             SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1467             # IF(NOT WINDOWS)
1468             # ADD_TEST(${input}_valgrind valgrind ${test})
1469             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1470             # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1471             # ENDIF()
1472             ENDFOREACH(input ${UNIT_TEST_PROG})
1473             ''')
1474             pass
1475
1476         # --
1477         # Treat the install targets
1478         # --
1479         resdir = self.module
1480         if resdir == "hxx2salome":
1481             resdir = self.hxxmodule
1482             pass
1483         d = {
1484             "salomeadmux_DATA"                 :  "salome_adm/unix",
1485             "dist_salomeadmux_DATA"            :  "salome_adm/unix",
1486             "dist_salome_cmake_DATA"           :  "salome_adm/cmake_files",
1487             "dist_salomem4_DATA"               :  "salome_adm/unix/config_files",
1488             "dist_salome4depr_DATA"            :  "salome_adm/unix/config_files/DEPRECATED",
1489             "dist_admlocalm4_DATA"             :  "adm_local/unix/config_files",
1490             "dist_admlocal_cmake_DATA"         :  "adm_local/cmake_files",
1491             "salomeinclude_DATA"               :  "include/salome",
1492             "salomeinclude_HEADERS"            :  "include/salome",
1493             "nodist_salomeinclude_HEADERS"     :  "include/salome",
1494             "dist_salomeres_DATA"              :  "share/salome/resources/%s"%(resdir),
1495             "nodist_salomeres_DATA"            :  "share/salome/resources/%s"%(resdir),
1496             "nodist_salomeres_SCRIPTS"         :  "share/salome/resources/%s"%(resdir),
1497             "dist_salomescript_SCRIPTS"        :  "bin/salome",
1498             "dist_salomescript_DATA"           :  "bin/salome",
1499             "dist_salomescript_PYTHON"         :  "bin/salome",
1500             "nodist_salomescript_DATA"         :  "bin/salome",
1501             "salomepython_PYTHON"              :  "${salomepythondir}",
1502             "nodist_salomepython_PYTHON"       :  "${salomepythondir}",
1503             "dist_salomepython_DATA"           :  "${salomepythondir}",
1504             "sharedpkgpython_PYTHON"           :  "${salomepythondir}/shared_modules",
1505             "salomepypkg_PYTHON"               :  "${salomepypkgdir}",
1506             "mypkgpython_PYTHON"               :  "${mypkgpythondir}",
1507             }
1508         if self.module == "medfile":
1509             d = {
1510                 "include_HEADERS"        :  "include",
1511                 "nodist_include_HEADERS" :  "include",
1512                 "bin_SCRIPTS"            :  "bin",
1513                 "doc_DATA"               :  "${docdir}",
1514                 }
1515             pass
1516         if self.module == "netgen":
1517             d = {
1518                 "include_HEADERS"        :  "include",
1519                 "noinst_HEADERS"         :  "share/netgen/include",
1520                 "dist_pkgdata_DATA"      :  "share/netgen",
1521                 "dist_doc_DATA"          :  "share/doc/netgen",
1522                 }
1523             pass
1524         for key, value in d.items():
1525             if self.__thedict__.has_key(key):
1526                 self.addInstallTarget(key, value, newlines)
1527                 pass
1528             pass
1529
1530         # --
1531         return
1532
1533     def setLibAdd(self, key, newlines):
1534         # --
1535         newlines.append(r'''
1536         SET(libadd)
1537         ''')
1538         # --
1539         newlines.append(r'''
1540         IF(WINDOWS)
1541         SET(targets)
1542         SET(targets ${targets} MEFISTO2D)
1543         FOREACH(target ${targets})
1544         IF(name STREQUAL ${target})
1545         SET(dir $ENV{F2CHOME})
1546         STRING(REPLACE "\\\\" "/" dir ${dir})
1547         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1548         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1549         ENDIF(name STREQUAL ${target})
1550         ENDFOREACH(target ${targets})
1551         ENDIF(WINDOWS)
1552         ''')
1553         # --
1554         newlines.append(r'''
1555         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1556         FOREACH(lib SALOMEBasics SalomeBatch)
1557         IF(name STREQUAL lib)
1558         SET(libs ${libs} ${PTHREAD_LIBS})
1559         ENDIF(name STREQUAL lib)
1560         ENDFOREACH(lib SALOMEBasics SalomeBatch)
1561         ''')
1562         # --
1563         newlines.append(r'''
1564         FOREACH(lib ${libs})
1565         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1566         IF(ext STREQUAL .la)
1567         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1568         STRING(REGEX REPLACE "^lib" "" lib ${lib})
1569         ENDIF(ext STREQUAL .la)
1570         SET(vars)
1571         SET(vars ${vars} -no-undefined)
1572         SET(vars ${vars} -lvtkWidgets)
1573         IF(WINDOWS)
1574         SET(vars ${vars} -module)
1575         SET(vars ${vars} -Wl,-E)
1576         SET(vars ${vars} -Xlinker)
1577         SET(vars ${vars} -export-dynamic)
1578         SET(vars ${vars} -lm)
1579         SET(vars ${vars} -lboost_thread)
1580         SET(vars ${vars} -lboost_signals)
1581         SET(vars ${vars} -pthread -lpthread -ldl)
1582         ENDIF(WINDOWS)
1583         FOREACH(v ${vars})
1584         IF(lib STREQUAL v)
1585         SET(lib)
1586         ENDIF(lib STREQUAL v)
1587         ENDFOREACH(v ${vars})
1588         SET(libadd ${libadd} ${lib})
1589         ENDFOREACH(lib ${libs})
1590         TARGET_LINK_LIBRARIES(${name} ${libadd})
1591         ''')
1592         # --
1593         newlines.append(r'''
1594         IF(WINDOWS)
1595         SET(targets)
1596         SET(targets ${targets} MEFISTO2D)
1597         FOREACH(target ${targets})
1598         IF(name STREQUAL ${target})
1599         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1600         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1601         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1602         ENDIF(name STREQUAL ${target})
1603         ENDFOREACH(target ${targets})
1604         ENDIF(WINDOWS)
1605         ''')
1606         # --
1607         return
1608
1609     def setCompilationFlags(self, key, newlines):
1610         newlines.append(r'''
1611         SET(var)
1612         IF(WINDOWS)
1613         SET(targets)
1614         SET(targets ${targets} SalomeIDLKernel)
1615         SET(targets ${targets} SalomeDS)
1616         SET(targets ${targets} SALOMEDSTest)
1617         SET(targets ${targets} SALOMEDS_Client_exe)
1618         SET(targets ${targets} SalomeIDLGEOM)
1619         SET(targets ${targets} GEOMEngine)
1620         SET(targets ${targets} MEDEngine)
1621         SET(targets ${targets} SMESHEngine)
1622         SET(targets ${targets} SMESH)
1623         FOREACH(target ${targets})
1624         IF(name STREQUAL ${target})
1625         SET(var ${var} -DNOGDI)
1626         ENDIF(name STREQUAL ${target})
1627         ENDFOREACH(target ${targets})
1628         ENDIF(WINDOWS)
1629         ''')
1630         # --
1631         if self.module in ["medfile", "yacs"]:
1632             newlines.append(r'''
1633             IF(WINDOWS)
1634             SET(var ${var} -DNOGDI)
1635             ENDIF(WINDOWS)
1636             ''')
1637             pass
1638         # --
1639         newlines.append(r'''
1640         IF(WINDOWS)
1641         SET(targets)
1642         SET(targets ${targets} MEFISTO2D)
1643         FOREACH(target ${targets})
1644         IF(name STREQUAL ${target})
1645         SET(dir $ENV{F2CHOME})
1646         STRING(REPLACE "\\\\" "/" dir ${dir})
1647         SET(var ${var} -I${dir})
1648         SET(var ${var} -DF2C_BUILD)
1649         ENDIF(name STREQUAL ${target})
1650         ENDFOREACH(target ${targets})
1651         ENDIF(WINDOWS)
1652         ''')
1653         # --
1654         if self.module in ["geom", "med"]:
1655             newlines.append(r'''
1656             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1657             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1658             ''')
1659             pass
1660         newlines.append(r'''
1661         SET(var ${var} ${AM_CPPFLAGS})
1662         SET(var ${var} ${AM_CXXFLAGS})
1663         ''')
1664         # --
1665         newlines.append(r'''
1666         IF(type STREQUAL STATIC)
1667         SET(var ${var} -fPIC)
1668         ENDIF(type STREQUAL STATIC)
1669         ''')
1670         # --
1671         if self.module == "yacs":
1672             newlines.append(r'''
1673             SET(var ${var} -DYACS_PTHREAD)
1674             SET(var ${var} -DCMAKE_BUILD)
1675             SET(var ${var} -DSALOME_KERNEL)
1676             SET(var ${var} -DDSC_PORTS)
1677             SET(var ${var} -DOMNIORB)
1678             ''')
1679             pass
1680         newlines.append(r'''
1681         SET(var ${var} ${PLATFORM_CPPFLAGS})
1682         SET(var ${var} ${PTHREAD_CFLAGS})
1683         SET(var ${var} ${${amname}_CPPFLAGS})
1684         SET(var ${var} ${${amname}_CXXFLAGS})
1685         SET(var ${var} ${${amname}_CFLAGS})
1686         SET(vars)
1687         IF(WINDOWS)
1688         SET(vars ${vars} -include SALOMEconfig.h)
1689         SET(vars ${vars} -ftemplate-depth-32)
1690         SET(vars ${vars} -fPIC)
1691         SET(vars ${vars} -g)
1692         ENDIF(WINDOWS)
1693         SET(flags)
1694         FOREACH(f ${var})
1695         FOREACH(v ${vars})
1696         IF(f STREQUAL v)
1697         SET(f)
1698         ENDIF(f STREQUAL v)
1699         ENDFOREACH(v ${vars})
1700         IF(f)
1701         string(REGEX MATCH "^-I" test_include ${f})
1702         if(test_include)
1703         string(REGEX REPLACE "^-I" "" include_dir ${f})
1704         if(include_dir)
1705         if(include_dir STREQUAL /usr/include)
1706         else(include_dir STREQUAL /usr/include)
1707         string(REGEX MATCH "^\\." test_dot ${include_dir})
1708         if(test_dot)
1709         set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
1710         endif(test_dot)
1711         include_directories(${include_dir})
1712         endif(include_dir STREQUAL /usr/include)
1713         endif(include_dir)
1714         else(test_include)
1715         SET(flags "${flags} ${f}")
1716         endif(test_include)
1717         ENDIF(f)
1718         ENDFOREACH(f ${var})
1719         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1720         ''')
1721         return
1722
1723     def addLibTarget(self, key, newlines):
1724         newlines.append(r'''
1725         FOREACH(amname ${%s})
1726         '''%(key))
1727         # --
1728         # Replace .la by _la ...
1729         # --
1730         newlines.append(r'''
1731         STRING(REPLACE .la _la amname ${amname})
1732         ''')
1733         # --
1734         # Remove the _la for the cmake name
1735         # --
1736         newlines.append(r'''
1737         STRING(LENGTH ${amname} len)
1738         MATH(EXPR newlen "${len}-3")
1739         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1740         ''')
1741         # --
1742         # Does the target begins with lib ??
1743         # If yes, remove lib at beginning for cmake name
1744         # --
1745         newlines.append(r'''
1746         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1747         IF(BEGIN_WITH_lib)
1748         STRING(LENGTH ${name} len)
1749         MATH(EXPR newlen "${len}-3")
1750         STRING(SUBSTRING ${name} 3 ${newlen} name)
1751         ENDIF(BEGIN_WITH_lib)
1752         ''')
1753         # --
1754         # Does the target is an idl library
1755         # --
1756         newlines.append(r'''
1757         STRING(REGEX MATCH "IDL" ISIDL ${name})
1758         ''')
1759         # --
1760         # Set the type of the library
1761         # --
1762         newlines.append(r'''
1763         IF(ISIDL)
1764         IF(WINDOWS)
1765         SET(type STATIC)
1766         ELSE(WINDOWS)
1767         SET(type SHARED)
1768         ENDIF(WINDOWS)
1769         ELSE(ISIDL)
1770         SET(type SHARED)
1771         ENDIF(ISIDL)
1772         ''')
1773         if key == "noinst_LTLIBRARIES":
1774             newlines.append(r'''
1775             IF(WINDOWS)
1776             SET(type STATIC)
1777             ELSE(WINDOWS)
1778             SET(type STATIC)
1779             ENDIF(WINDOWS)
1780             ''')
1781             pass
1782         # --
1783         # Set sources for the library
1784         # --
1785         newlines.append(r'''
1786         SET(srcs)
1787         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1788         GET_FILENAME_COMPONENT(ext ${src} EXT)
1789         IF(ext STREQUAL .f)
1790         IF(src STREQUAL trte.f)
1791         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1792         STRING(REPLACE ".f" ".c" src ${src})
1793         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1794         SET(output ${src})
1795         SET(cmd f2c)
1796         IF(NOT WINDOWS)
1797         IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
1798         SET(cmd valgrind f2c)  # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
1799         ENDIF()
1800         ENDIF(NOT WINDOWS)
1801         ADD_CUSTOM_COMMAND(
1802         OUTPUT ${output}
1803         COMMAND ${cmd} ${input}
1804         MAIN_DEPENDENCY ${input}
1805         )
1806         ELSE(src STREQUAL trte.f)
1807         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1808         STRING(REPLACE ".f" ".o" src ${src})
1809         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1810         SET(output ${src})
1811         IF(WINDOWS)
1812         SET(F77 g77)
1813         ELSE(WINDOWS)
1814         SET(F77 gfortran)
1815         ENDIF(WINDOWS)
1816         ADD_CUSTOM_COMMAND(
1817         OUTPUT ${output}
1818         COMMAND ${F77} -c -o ${output} ${input}
1819         MAIN_DEPENDENCY ${input}
1820         )
1821         ENDIF(src STREQUAL trte.f)
1822         ENDIF(ext STREQUAL .f)
1823         SET(srcs ${srcs} ${src})
1824         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1825         ''')
1826         newlines.append(r'''
1827         SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1828         FOREACH(f ${l})
1829         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1830         SET(srcs ${srcs} ${src})
1831         ENDFOREACH(f ${l})
1832         ''')
1833         newlines.append(r'''
1834         SET(build_srcs)
1835         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1836         FOREACH(f ${l})
1837         GET_FILENAME_COMPONENT(ext ${f} EXT)
1838         IF(ext STREQUAL .py)
1839         ELSE(ext STREQUAL .py)
1840         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1841         ENDIF(ext STREQUAL .py)
1842         ENDFOREACH(f ${l})
1843         ''')
1844         # --
1845         # Add the library to cmake
1846         # --
1847         newlines.append(r'''
1848         ADD_LIBRARY(${name} ${type} ${srcs})
1849         ''')
1850         # --
1851         # The compilation flags
1852         # --
1853         self.setCompilationFlags(key, newlines)
1854         # --
1855         newlines.append(r'''
1856         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1857         ''')
1858         # --
1859         self.setLibAdd(key, newlines)
1860         # --
1861         if 1: # key != "noinst_LTLIBRARIES":
1862             newlines.append(r'''
1863             SET(key %s)
1864             '''%(key))
1865             newlines.append(r'''
1866             SET(test ON)
1867             IF(${key} STREQUAL noinst_LTLIBRARIES)
1868             SET(test OFF)
1869             ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
1870             ''')
1871             if self.module == "netgen" :
1872                 newlines.append(r'''
1873                 IF(${key} STREQUAL noinst_LTLIBRARIES)
1874                 IF(WINDOWS)
1875                 SET(test ON)
1876                 ENDIF(WINDOWS)
1877                 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
1878                 ''')
1879                 pass
1880             newlines.append(r'''
1881             IF(test)
1882             ''')
1883             if self.module in ["medfile", "netgen"]:
1884                 newlines.append(r'''
1885                 SET(DEST lib)
1886                 ''')
1887             else:
1888                 newlines.append(r'''
1889                 SET(DEST lib/salome)
1890                 ''')
1891                 pass
1892             newlines.append(r'''
1893             IF(BEGIN_WITH_lib)
1894             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1895             ''')
1896             if self.module == "gui":
1897                 newlines.append(r'''
1898                 FOREACH(lib SalomePyQt)
1899                 IF(name STREQUAL lib)
1900                 IF(WINDOWS)
1901                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1902                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1903                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1904                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1905                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1906                 ELSE(WINDOWS)
1907                 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1908                 ENDIF(WINDOWS)
1909                 ENDIF(name STREQUAL lib)
1910                 ENDFOREACH(lib SalomePyQt)
1911                 FOREACH(lib SalomePy)
1912                 IF(name STREQUAL lib)
1913                 IF(WINDOWS)
1914                 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1915                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1916                 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1917                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1918                 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1919                 ENDIF(WINDOWS)
1920                 ENDIF(name STREQUAL lib)
1921                 ENDFOREACH(lib SalomePy)
1922                 ''')
1923                 pass
1924             if self.module == "geom":
1925                 newlines.append(r'''
1926                 IF(WINDOWS)
1927                 STRING(REGEX MATCH "Export" ISExport ${name})
1928                 IF(ISExport)
1929                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1930                 ENDIF(ISExport)
1931                 STRING(REGEX MATCH "Import" ISImport ${name})
1932                 IF(ISImport)
1933                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1934                 ENDIF(ISImport)
1935                 ENDIF(WINDOWS)
1936                 ''')
1937                 pass
1938             newlines.append(r'''
1939             ELSE(BEGIN_WITH_lib)
1940             ''')
1941             newlines.append(r'''
1942             IF(WINDOWS)
1943             INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
1944             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1945             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
1946             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1947             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
1948             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1949             ELSE(WINDOWS)
1950             GET_TARGET_PROPERTY(version ${name} VERSION)
1951             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1952             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
1953             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
1954             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
1955             ENDIF(WINDOWS)
1956             ''')
1957             newlines.append(r'''
1958             ENDIF(BEGIN_WITH_lib)
1959             ''')
1960             newlines.append(r'''
1961             ENDIF(test)
1962             ''')
1963             pass
1964         # --
1965         newlines.append(r'''
1966         ENDFOREACH(amname ${%s})
1967         '''%(key))
1968         # --
1969         return
1970
1971     def addBinTarget(self, key, newlines):
1972         # --
1973         newlines.append(r'''
1974         FOREACH(amname ${%s})
1975         '''%(key))
1976         # --
1977         newlines.append(r'''
1978         SET(test ON)
1979         ''')
1980         if key == "check_PROGRAMS":
1981             newlines.append(r'''
1982             IF(bin_PROGRAMS)
1983             STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
1984             IF(is_present)
1985             SET(test OFF)
1986             ENDIF(is_present)
1987             ENDIF(bin_PROGRAMS)
1988             ''')
1989             pass
1990         newlines.append(r'''
1991         IF(test)
1992         ''')
1993         # --
1994         newlines.append(r'''
1995         SET(name "${amname}_exe")
1996         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1997         SET(l ${nodist_${amname}_SOURCES})
1998         FOREACH(f ${l})
1999         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2000         SET(srcs ${srcs} ${src})
2001         ENDFOREACH(f ${l})
2002         LIST(LENGTH srcs nb)
2003         IF(nb)
2004         ADD_EXECUTABLE(${name} ${srcs})
2005         ''')
2006         # --
2007         self.setCompilationFlags(key, newlines)
2008         # --
2009         self.setLibAdd(key, newlines)
2010         # --
2011         if self.module in ["medfile", "netgen"]:
2012             newlines.append(r'''
2013             SET(DEST bin)
2014             ''')
2015         else:
2016             newlines.append(r'''
2017             SET(DEST bin/salome)
2018             ''')
2019             pass
2020         # --
2021         if key == "bin_PROGRAMS":
2022             newlines.append(r'''
2023             IF(WINDOWS)
2024             INSTALL(TARGETS ${name} DESTINATION ${DEST})
2025             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2026             INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2027             ELSE(WINDOWS)
2028             SET(PERMS)
2029             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2030             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2031             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2032             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2033             ENDIF(WINDOWS)
2034             ''')
2035             pass
2036         # --
2037         newlines.append(r'''
2038         ENDIF(nb)
2039         ''')
2040         # --
2041         newlines.append(r'''
2042         ENDIF(test)
2043         ''')
2044         newlines.append(r'''
2045         ENDFOREACH(amname ${%s})
2046         '''%(key))
2047         # --
2048         return
2049
2050     def addInstallTarget(self, key, destination, newlines):
2051         newlines.append(r"FOREACH(f ${%s})"%(key))
2052         newlines.append(r'''
2053         SET(DEST %s)
2054         '''%(destination))
2055         newlines.append(r'''
2056         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2057         IF(test_SALOMEconfig.h.in)
2058         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2059         ELSE(test_SALOMEconfig.h.in)
2060         SET(dummy dummy-NOTFOUND)
2061         MARK_AS_ADVANCED(dummy)
2062         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2063         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2064         IF(dummy)
2065         ''')
2066         if key in ['dist_salomescript_SCRIPTS']:
2067             newlines.append(r'''
2068             SET(PERMS)
2069             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2070             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2071             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2072             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2073             ''')
2074         else:
2075             newlines.append(r'''
2076             GET_FILENAME_COMPONENT(ext ${f} EXT)
2077             IF(ext STREQUAL .py)
2078             IF(DEST STREQUAL bin/salome)
2079             SET(PERMS)
2080             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2081             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2082             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2083             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2084             ELSE(DEST STREQUAL bin/salome)
2085             INSTALL(FILES ${f} DESTINATION ${DEST})
2086             ENDIF(DEST STREQUAL bin/salome)
2087             ELSE(ext STREQUAL .py)
2088             INSTALL(FILES ${f} DESTINATION ${DEST})
2089             ENDIF(ext STREQUAL .py)
2090             ''')
2091             pass
2092         newlines.append(r'''
2093         ELSE(dummy)
2094         GET_FILENAME_COMPONENT(ext ${f} EXT)
2095         IF(ext STREQUAL .qm)
2096         STRING(REGEX REPLACE .qm .ts input ${f})
2097         ''')
2098         if self.module in ["kernel", "gui", "yacs"]:
2099             newlines.append(r'''
2100             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2101             ''')
2102         else:
2103             newlines.append(r'''
2104             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2105             ''')
2106             pass
2107         newlines.append(r'''
2108         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2109         # ADD_CUSTOM_COMMAND(
2110         # OUTPUT ${output}
2111         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2112         # MAIN_DEPENDENCY ${input}
2113         # )
2114         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2115         ENDIF(ext STREQUAL .qm)
2116         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2117         ENDIF(dummy)
2118         ENDIF(test_SALOMEconfig.h.in)
2119         ''')
2120         newlines.append(r'''
2121         GET_FILENAME_COMPONENT(ext ${f} EXT)
2122         IF(ext STREQUAL .py)
2123         INSTALL(CODE "SET(PYTHON_FILE ${f})")
2124         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2125         INSTALL(CODE "SET(DEST ${DEST})")
2126         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2127         ''')
2128         if self.module == "kernel":
2129             newlines.append('''
2130             IF(f STREQUAL SALOME_ContainerPy.py)
2131             ELSE(f STREQUAL SALOME_ContainerPy.py)
2132             IF(f STREQUAL am2cmake.py)
2133             ELSE(f STREQUAL am2cmake.py)
2134             IF(f STREQUAL copytree1.py)
2135             ELSE(f STREQUAL copytree1.py)
2136             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2137             ENDIF(f STREQUAL copytree1.py)
2138             ENDIF(f STREQUAL am2cmake.py)
2139             ENDIF(f STREQUAL SALOME_ContainerPy.py)
2140             ''')
2141         else:
2142             newlines.append('''
2143             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2144             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2145             ''')
2146             pass
2147         newlines.append(r'''
2148         ENDIF(ext STREQUAL .py)
2149         ''')
2150         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2151         return
2152
2153     def writeListsFile(self):
2154         f = open(self.listsFile, "w")
2155         f.write(self.content)
2156         f.close()
2157         return
2158
2159     pass
2160
2161 def convertAmFile(the_root, root, dirs, files, f, module):
2162     cmake = CMakeFile(the_root, root, dirs, files, f, module)
2163     cmake.writeListsFile()
2164     return
2165
2166 def usage(exit_status):
2167     from sys import exit
2168     from sys import argv
2169     print "Usage: %s --module"%(argv[0])
2170     exit(exit_status)
2171     return
2172
2173 if __name__ == "__main__":
2174     #
2175     from sys import argv
2176     if len(argv) != 2:
2177         usage(1)
2178         pass
2179     #
2180     module = argv[1]
2181     if module.find('--') != 0:
2182         usage(1)
2183         pass
2184     module = module[2:]
2185     if len(module) == 0:
2186         usage(1)
2187         pass
2188     #
2189     from os import getcwd
2190     the_root = getcwd()
2191     #
2192     nok = 0
2193     #
2194     from os import walk
2195     for root, dirs, files in walk(the_root):
2196         # --
2197         # E.A. : Remove 'CVS' in dirs
2198         # E.A. : It allows to not recurse in CVS dirs
2199         # E.A. : See os module python documentation
2200         # --
2201         try:
2202             dirs.remove('CVS')
2203         except ValueError:
2204             pass
2205         # --
2206         if "Makefile.am.cmake" in files:
2207             if "Makefile.am" in files:
2208                 files.remove("Makefile.am")
2209                 pass
2210             pass
2211         # --
2212         from sys import stdout
2213         for f in files:
2214             if f in ["Makefile.am", "Makefile.am.cmake"]:
2215                 convertAmFile(the_root, root, dirs, files, f, module)
2216                 nok += 1
2217                 pass
2218             pass
2219         pass
2220     #
2221     if nok:
2222         if nok == 1:
2223             msg = "%s file has been converted to cmake"%(nok)
2224         else:
2225             msg = "%s files have been converted to cmake"%(nok)
2226             pass
2227         stdout.write(msg)
2228         stdout.write("\n")
2229         stdout.flush()
2230         pass
2231     pass