adm_local_without_kernel/cmake_files/am2cmake.py

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