salome_adm/cmake_files/am2cmake.py

   1 #  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 #
   3 #  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 #
   6 #  This library is free software; you can redistribute it and/or
   7 #  modify it under the terms of the GNU Lesser General Public
   8 #  License as published by the Free Software Foundation; either
   9 #  version 2.1 of the License.
  10 #
  11 #  This library is distributed in the hope that it will be useful,
  12 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 #  Lesser General Public License for more details.
  15 #
  16 #  You should have received a copy of the GNU Lesser General Public
  17 #  License along with this library; if not, write to the Free Software
  18 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 #
  20 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 #
  22 import re
  23
  24 # ----
  25 # A set of regular expressions used ...
  26 # ----
  27
  28 p_multiline = re.compile(r"""
  29 \\           # One backslash
  30 \s*          # 0 or more space
  31 \n           # One CR
  32 """, re.VERBOSE)
  33
  34 p_dollar = re.compile(r"""
  35 \$\(           # a $ then a (
  36 (?P<val>       # open the group val
  37 [^)]*          # the group contain 0 or more non ) characters
  38 )              # close the group
  39 \)             # a ) at the end
  40 """, re.VERBOSE)
  41
  42 p_arobas = re.compile(r"""
  43 @              # a @
  44 (?P<val>       # open the group val
  45 [^@]*            # the group contain 0 or more non @ characters
  46 )              # close the group
  47 @              # a @ at the end
  48 """, re.VERBOSE)
  49
  50 p_if = re.compile(r"""
  51 ^          # beginning of the string
  52 \s*        # 0 or more space
  53 if         # an if
  54 \s+        # 1 or more space
  55 (?P<val>   # open the group val
  56 [^\s]+     # the group contain 1 or more non space characters
  57 )          # close the group
  58 """, re.VERBOSE)
  59
  60 p_else = re.compile(r"""
  61 ^          # beginning of the line
  62 \s*        # 0 or more space
  63 else       #
  64 \s*        # 0 or more space
  65 """, re.VERBOSE)
  66
  67 p_endif = re.compile(r"""
  68 ^          # beginning of the line
  69 \s*        # 0 or more space
  70 endif      # a endif
  71 \s*        # 0 or more space
  72 """, re.VERBOSE)
  73
  74 p_attribution = re.compile(r"""
  75 ^              # beginning of the line
  76 (?P<spaces>    # open the group spaces
  77 \s*            # 0 or more space
  78 )              # close the group
  79 (?P<key>       # open the group key
  80 \w+            # the group contain 1 or more alphanumeric characters
  81 )              # close the group
  82 \s*            # 0 or more space
  83 (?P<method>    # open the group method
  84 \+?            # 0 or 1 +
  85 =              # One =
  86 )              # close the group
  87 (?P<value>     # open the group value
  88 .*             # 0 or more any characters
  89 )              # close the group
  90 """, re.VERBOSE)
  91
  92 # -----
  93
  94 class CMakeFile(object):
  95
  96     def __init__(self, the_root, root, dirs, files, f, module):
  97         #
  98         self.the_root = the_root
  99         self.root = root
 100         self.dirs = dirs
 101         self.files = files
 102         self.module = module
 103         #
 104         from os.path import join
 105         self.amFile = join(root, f)
 106         self.listsFile = join(root, "CMakeLists.txt")
 107         #
 108         self.parseFile()
 109         #
 110         return
 111
 112     def parseFile(self):
 113
 114         # --
 115         # Read the Makefile.am file
 116         # --
 117         amFile = self.amFile
 118         stream = open(amFile)
 119         content = stream.read()
 120         stream.close()
 121
 122         # --
 123         # Replace the composed lines separated by "\\n" by an unique line
 124         # --
 125         content = p_multiline.sub(r' ', content)
 126
 127         # --
 128         # Compatibility netgen plugin
 129         # --
 130         content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
 131
 132         # --
 133         cas_list = [
 134             "BinLPlugin",
 135             "BinPlugin",
 136             "BinTObjPlugin",
 137             "BinXCAFPlugin",
 138             "FWOSPlugin",
 139             "PTKernel",
 140             "StdLPlugin",
 141             "StdPlugin",
 142             "TKAdvTools",
 143             "TKBin",
 144             "TKBinL",
 145             "TKBinTObj",
 146             "TKBinXCAF",
 147             "TKBO",
 148             "TKBool",
 149             "TKBRep",
 150             "TKCAF",
 151             "TKCDF",
 152             "TKernel",
 153             "TKFeat",
 154             "TKFillet",
 155             "TKG2d",
 156             "TKG3d",
 157             "TKGeomAlgo",
 158             "TKGeomBase",
 159             "TKHLR",
 160             "TKIGES",
 161             "TKLCAF",
 162             "TKMath",
 163             "TKMesh",
 164             "TKMeshVS",
 165             "TKNIS",
 166             "TKOffset",
 167             "TKOpenGl",
 168             "TKPCAF",
 169             "TKPLCAF",
 170             "TKPrim",
 171             "TKPShape",
 172             "TKService",
 173             "TKShapeSchema",
 174             "TKShHealing",
 175             "TKStdLSchema",
 176             "TKStdSchema",
 177             "TKSTEP",
 178             "TKSTEP209",
 179             "TKSTEPAttr",
 180             "TKSTEPBase",
 181             "TKSTL",
 182             "TKTObj",
 183             "TKTopAlgo",
 184             "TKV2d",
 185             "TKV3d",
 186             "TKVRML",
 187             "TKXCAF",
 188             "TKXCAFSchema",
 189             "TKXDEIGES",
 190             "TKXDESTEP",
 191             "TKXMesh",
 192             "TKXml",
 193             "TKXmlL",
 194             "TKXmlTObj",
 195             "TKXmlXCAF",
 196             "TKXSBase",
 197             "XCAFPlugin",
 198             "XmlLPlugin",
 199             "XmlPlugin",
 200             "XmlTObjPlugin",
 201             "XmlXCAFPlugin",
 202             ]
 203         kernel_list  = [
 204             "DF",
 205             "Launcher",
 206             "OpUtil",
 207             "Registry",
 208             "ResourcesManager",
 209             "SALOMEBasics",
 210             "SalomeBatch",
 211             "SalomeCatalog",
 212             "SalomeCommunication",
 213             "SalomeContainer",
 214             "SalomeDSCContainer",
 215             "SalomeDSClient",
 216             "SalomeDSImpl",
 217             "SalomeDS",
 218             "SalomeGenericObj",
 219             "SalomeHDFPersist",
 220             "SalomeIDLKernel",
 221             "SalomeLauncher",
 222             "SalomeLifeCycleCORBA",
 223             "SALOMELocalTrace",
 224             "SalomeLoggerServer",
 225             "SalomeNotification",
 226             "SalomeNS",
 227             "SalomeResourcesManager",
 228             "TOOLSDS",
 229             "with_loggerTraceCollector",
 230             ]
 231         gui_list = [
 232             "caf",
 233             "CAM",
 234             "CASCatch",
 235             "DDS",
 236             "Event",
 237             "GLViewer",
 238             "LightApp",
 239             "LogWindow",
 240             "ObjBrowser",
 241             "OCCViewer",
 242             "Plot2d",
 243             "PyConsole",
 244             "PyInterp",
 245             "QDS",
 246             "qtx",
 247             "QxScene",
 248             "SalomeApp",
 249             "SalomeIDLGUI",
 250             "SalomeObject",
 251             "SalomePrs",
 252             "SalomeSession",
 253             "SalomeStyle",
 254             "SOCC",
 255             "SPlot2d",
 256             "std",
 257             "SUITApp",
 258             "suit",
 259             "SUPERVGraph",
 260             "SVTK",
 261             "ToolsGUI",
 262             "VTKViewer",
 263             ]
 264         geom_list = [
 265             "BasicGUI",
 266             "BlocksGUI",
 267             "BooleanGUI",
 268             "BREPExport",
 269             "BREPImport",
 270             "BuildGUI",
 271             "DisplayGUI",
 272             "DlgRef",
 273             "EntityGUI",
 274             "GenerationGUI",
 275             "GEOMAlgo",
 276             "GEOMArchimede",
 277             "GEOMBase",
 278             "GEOMbasic",
 279             "GEOMClient",
 280             "GEOMEngine",
 281             "GEOMFiltersSelection",
 282             "GEOMimpl",
 283             "GEOMObject",
 284             "GEOMSketcher",
 285             "GEOM",
 286             "GEOM_SupervEngine",
 287             "GEOMToolsGUI",
 288             "GroupGUI",
 289             "IGESExport",
 290             "IGESImport",
 291             "MeasureGUI",
 292             "NMTDS",
 293             "NMTTools",
 294             "OperationGUI",
 295             "PrimitiveGUI",
 296             "RepairGUI",
 297             "SalomeIDLGEOM",
 298             "ShHealOper",
 299             "STEPExport",
 300             "STEPImport",
 301             "STLExport",
 302             "TransformationGUI",
 303             ]
 304         med_list = [
 305             "InterpGeometric2DAlg",
 306             "interpkernelbases",
 307             "interpkernel",
 308             "MEDClientcmodule",
 309             "medcoupling",
 310             "MEDEngine",
 311             "MEDMEMImpl",
 312             "medmem",
 313             "MED",
 314             "med_V2_1",
 315             "MEDWrapperBase",
 316             "MEDWrapper",
 317             "MEDWrapper_V2_1",
 318             "MEDWrapper_V2_2",
 319             "SalomeIDLMED",
 320             ]
 321         smesh_list = [
 322             "MEFISTO2D",
 323             "MeshDriverDAT",
 324             "MeshDriverMED",
 325             "MeshDriver",
 326             "MeshDriverSTL",
 327             "MeshDriverUNV",
 328             "SalomeIDLSMESH",
 329             "SMDS",
 330             "SMESHClient",
 331             "SMESHControls",
 332             "SMESHDS",
 333             "SMESHEngine",
 334             "SMESHFiltersSelection",
 335             "SMESHimpl",
 336             "SMESHObject",
 337             "SMESH",
 338             "StdMeshersEngine",
 339             "StdMeshersGUI",
 340             "StdMeshers",
 341             ]
 342         full_list = cas_list + kernel_list + gui_list
 343         full_list += geom_list + med_list + smesh_list
 344         # --
 345         # E.A. : sort by len before substitution ...
 346         # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 347         # And you understand ...
 348         # --
 349         full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 350         # --
 351         for key in full_list:
 352             content = content.replace("-l%s"%(key), "${%s}"%(key))
 353             pass
 354
 355         # --
 356         # Split content in lines to treat each one separately
 357         # --
 358         lines = content.split('\n')
 359
 360         # --
 361         # newlines contains the lines of the future CMakeLists.txt file
 362         # --
 363         newlines = []
 364
 365         # --
 366         # opened_ifs is used to deals with nested conditionnals
 367         # --
 368         opened_ifs = []
 369
 370         # --
 371         # the __thedict__ dictionnary contains key, val
 372         # of the Makefile.am file
 373         # --
 374         self.__thedict__ = {}
 375
 376         # --
 377         # Initialize file ... mainly includes other cmake files
 378         # --
 379         self.initialize(newlines)
 380
 381         # --
 382         # Do the job for each line
 383         # --
 384         for line in lines:
 385             self.treatLine(line, newlines, opened_ifs)
 386             pass
 387
 388         # --
 389         # Finalize file ... it is in here the cmake job is done
 390         # --
 391         self.finalize(newlines)
 392
 393         # --
 394         # Concatenate newlines into content
 395         # --
 396         content = '\n'.join(newlines)
 397
 398         # --
 399         # Add a CR at end if necessary
 400         # --
 401         lines = content.split('\n')
 402         # lines = [ l.strip() for l in lines ]
 403         if len(lines[-1]) != 0:
 404             lines.append('')
 405             pass
 406         content = '\n'.join(lines)
 407
 408         # --
 409         self.content = content
 410
 411         # --
 412         return
 413
 414     def initialize(self, newlines):
 415         if self.root == self.the_root:
 416             # --
 417             newlines.append("""
 418             CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
 419             IF(COMMAND cmake_policy)
 420             cmake_policy(SET CMP0003 NEW)
 421             ENDIF(COMMAND cmake_policy)
 422             """)
 423             # --
 424             if self.module == "kernel":
 425                 newlines.append("""
 426                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 427                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 428                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 429                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 430                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 431                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 432                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 433                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 434                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 435                 """)
 436                 pass
 437             else:
 438                 newlines.append("""
 439                 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 440                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 441                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 442                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 443                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 444                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 445                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 446                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 447                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 448                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 449                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 450                 """)
 451                 if self.module == "gui":
 452                     newlines.append("""
 453                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 454                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 455                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 456                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 457                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 458                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 459                     """)
 460                 else:
 461                     newlines.append("""
 462                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 463                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 464                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 465                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 466                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 467                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 468                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 469                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 470                     """)
 471                     if self.module == "med":
 472                         newlines.append("""
 473                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 474                         """)
 475                         pass
 476                     if self.module == "smesh":
 477                         newlines.append("""
 478                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 479                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 480                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 481                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 482                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 483                         """)
 484                         pass
 485                     if self.module == "netgenplugin":
 486                         newlines.append("""
 487                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 488                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 489                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 490                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 491                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 492                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 493                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
 494                         """)
 495                         pass
 496                     if self.module == "blsurfplugin":
 497                         newlines.append("""
 498                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 499                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 500                         SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
 501                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 502                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 503                         INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
 504                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
 505                         """)
 506                         pass
 507                     if self.module == "visu":
 508                         newlines.append("""
 509                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 510                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 511                         """)
 512                         pass
 513                     pass
 514                 pass
 515             # --
 516             if self.module == "kernel":
 517                 newlines.append("""
 518                 SET(WITH_LOCAL 1)
 519                 SET(WITH_BATCH 1)
 520                 set(VERSION 5.1.2)
 521                 set(XVERSION 0x050102)
 522                 """)
 523             elif self.module == "gui":
 524                 newlines.append("""
 525                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 526                 SET(ENABLE_VTKVIEWER ON)
 527                 SET(ENABLE_SALOMEOBJECT ON)
 528                 SET(ENABLE_OCCVIEWER ON)
 529                 SET(ENABLE_GLVIEWER ON)
 530                 SET(ENABLE_PLOT2DVIEWER ON)
 531                 SET(ENABLE_PYCONSOLE ON)
 532                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 533                 # SET(ENABLE_QXGRAPHVIEWER ON)
 534                 set(VERSION 5.1.2)
 535                 set(XVERSION 0x050102)
 536                 """)
 537                 pass
 538             elif self.module == "geom":
 539                 newlines.append("""
 540                 SET(GEOM_ENABLE_GUI ON)
 541                 """)
 542                 pass
 543             elif self.module == "medfile":
 544                 newlines.append("""
 545                 SET(MED_NUM_MAJEUR 2)
 546                 SET(MED_NUM_MINEUR 3)
 547                 SET(MED_NUM_RELEASE 5)
 548                 SET(LONG_OR_INT int)
 549                 IF(NOT WINDOWS)
 550                 SET(FLIBS -lgfortranbegin -lgfortran)
 551                 ENDIF(NOT WINDOWS)
 552                 """)
 553                 pass
 554             elif self.module == "med":
 555                 newlines.append("""
 556                 SET(MED_ENABLE_KERNEL ON)
 557                 SET(MED_ENABLE_GUI ON)
 558                 """)
 559                 pass
 560             elif self.module == "smesh":
 561                 newlines.append("""
 562                 SET(SMESH_ENABLE_GUI ON)
 563                 """)
 564                 pass
 565             elif self.module == "netgenplugin":
 566                 newlines.append("""
 567                 SET(NETGENPLUGIN_ENABLE_GUI ON)
 568                 """)
 569                 pass
 570             elif self.module == "blsurfplugin":
 571                 newlines.append("""
 572                 SET(BLSURFPLUGIN_ENABLE_GUI ON)
 573                 """)
 574                 pass
 575             # --
 576             pass
 577         # --
 578         newlines.append("""
 579         SET(VERSION_INFO 0.0.0)
 580         SET(SOVERSION_INFO 0)
 581         SET(SUBDIRS)
 582         SET(AM_CPPFLAGS)
 583         SET(AM_CXXFLAGS)
 584         SET(LDADD)
 585         """)
 586         # --
 587         return
 588
 589     def treatLine(self, line, newlines, opened_ifs):
 590
 591         # --
 592         # Print the comment above the line itself
 593         # --
 594         if line.find('#') >= 0:
 595             fields = line.split('#')
 596             line = fields[0]
 597             comment = '#'.join([''] + fields[1:])
 598             newlines.append(comment)
 599             if len(line) == 0:
 600                 return
 601             pass
 602
 603         # --
 604         # If the line begins with 'include ', just comment it
 605         # --
 606         if line.find("include ") == 0:
 607             newlines.append("# " + line)
 608             return
 609
 610         # --
 611         # If the line begins with '-include', just comment it
 612         # --
 613         if line.find("-include") == 0:
 614             newlines.append("# " + line)
 615             return
 616
 617         # --
 618         # If the line is a definition of a make rule, just comment it
 619         # --
 620         if line.count(':') == 1:
 621             newlines.append("# " + line)
 622             return
 623
 624         # --
 625         # A particuliar case where there are two ":" on the same line
 626         # --
 627         if line.find('install-exec-local:') == 0:
 628             newlines.append("# " + line)
 629             return
 630
 631         # --
 632         # If the line begin by a tabulation, consider it's a makefile command and comment it
 633         # --
 634         if line.find("\t") == 0:
 635             newlines.append("# " + line)
 636             return
 637
 638         # --
 639         # --
 640         key = "-version-info"
 641         if line.find(key) >= 0:
 642             # --
 643             before = line.split(key)[0]
 644             after = line[len(before)+len(key):]
 645             sep = after[0]
 646             after = after[1:]
 647             version_info = after.split()[0]
 648             line = line.replace(key+sep+version_info, "")
 649             # --
 650             version_info = version_info.replace(':', '.')
 651             soversion_info = version_info.split('.')[0]
 652             newlines.append("SET(VERSION_INFO " + version_info + ")")
 653             newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
 654             # --
 655             pass
 656
 657         # --
 658         # Replace the $(TOTO) by ${TOTO}
 659         # Replace the @TOTO@  by ${TOTO}
 660         # --
 661         line = p_dollar.sub(r"${\1}", line)
 662         line = p_arobas.sub(r"${\1}", line)
 663
 664         # --
 665         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 666         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 667         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 668         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 669         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 670
 671         # --
 672         # Check if the line is a 'if' condition
 673         # If yes, replace it by a cmake grammar
 674         # --
 675         match = p_if.match(line)
 676         if match:
 677             theif = match.group("val")
 678             if theif[0] == "!":
 679                 theif = "NOT " + theif[1:]
 680                 pass
 681             line = p_if.sub(r"IF(%s)"%(theif), line)
 682             opened_ifs.append(theif)
 683             newlines.append(line)
 684             return
 685
 686         # --
 687         # Check if the line is a 'else' condition
 688         # If yes, replace it by a cmake grammar
 689         # --
 690         match = p_else.match(line)
 691         if match:
 692             line = "ELSE(%s)"%(opened_ifs[-1])
 693             newlines.append(line)
 694             return
 695
 696         # --
 697         # Check if the line is a 'endif' condition
 698         # If yes, replace it by a cmake grammar
 699         # --
 700         match = p_endif.match(line)
 701         if match:
 702             line = "ENDIF(%s)"%(opened_ifs[-1])
 703             opened_ifs[-1:] = []
 704             newlines.append(line)
 705             return
 706
 707         # --
 708         # Check if the line is an attribution '=' or '+='
 709         # --
 710         match = p_attribution.match(line)
 711         if match:
 712             self.treatAttribution(match, newlines)
 713             return
 714
 715         # --
 716         newlines.append(line)
 717
 718         # --
 719         return
 720
 721     def treatAttribution(self, match, newlines):
 722
 723         spaces = match.group("spaces")
 724         key = match.group("key")
 725         method = match.group("method")
 726         value = match.group("value")
 727         # print [spaces, key, method, value]
 728
 729         # --
 730         # Open cmake SET command
 731         # --
 732         newlines.append(spaces + "SET(" + key)
 733
 734         # --
 735         # If method is '+=', put the previous definition as first value
 736         # --
 737         if method == "+=":
 738             newlines.append("%s    ${%s}"%(spaces, key))
 739             pass
 740
 741         # --
 742         fields = value.split()
 743         for i in range(len(fields)):
 744             newlines.append("%s    %s"%(spaces, fields[i]))
 745             pass
 746
 747         # --
 748         if method == "+=":
 749             # --
 750             # The try: except KeyError is here if the +=
 751             # is an error which occurs in salome ...
 752             # --
 753             try:
 754                 self.__thedict__[key] += fields[:]
 755             except KeyError:
 756                 self.__thedict__[key] = fields[:]
 757                 pass
 758             pass
 759         else:
 760             self.__thedict__[key]  = fields[:]
 761             pass
 762
 763         # --
 764         # Close cmake SET command
 765         # --
 766
 767         newlines.append("%s)"%(spaces))
 768
 769         return
 770
 771     def finalize(self, newlines):
 772
 773         # --
 774         # Convert the .in files in build dir
 775         # --
 776         for f in self.files:
 777             if f[-3:] == ".in":
 778                 if f == "sstream.in":
 779                     continue
 780                 if f in ["runContainer.in", "stopContainer.in"]:
 781                     if self.module == "med":
 782                         if self.root[-3:] == "csh":
 783                             continue
 784                         pass
 785                     pass
 786                 if f == "SALOMEconfig.ref.in":
 787                     out = "SALOMEconfig.h"
 788                 else:
 789                     out = f[:-3]
 790                     pass
 791                 newlines.append(r'''
 792                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 793                 '''%(f))
 794                 newlines.append(r'''
 795                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 796                 '''%(out))
 797                 newlines.append(r'''
 798                 MESSAGE(STATUS "Creation of ${output}")
 799                 CONFIGURE_FILE(${input} ${output})
 800                 ''')
 801                 pass
 802             pass
 803
 804         # --
 805         # convert the SUBDIRS in cmake grammar
 806         # --
 807         if 1: # self.__thedict__.has_key("SUBDIRS"):
 808             newlines.append(r'''
 809             FOREACH(dir ${SUBDIRS})
 810             IF(NOT dir STREQUAL .)
 811             ADD_SUBDIRECTORY(${dir})
 812             ENDIF(NOT dir STREQUAL .)
 813             ENDFOREACH(dir ${SUBDIRS})
 814             ''')
 815             pass
 816
 817         # --
 818         # --
 819         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 820             if self.__thedict__.has_key(key):
 821                 self.addLibTarget(key, newlines)
 822                 pass
 823             pass
 824
 825         # --
 826         # --
 827         for key in ["bin_PROGRAMS"]:
 828             if self.__thedict__.has_key(key):
 829                 self.addBinTarget(key, newlines)
 830                 pass
 831             pass
 832
 833         # --
 834         # --
 835         if self.__thedict__.has_key("BASEIDL_FILES"):
 836             if not self.__thedict__.has_key("IDL_FILES"):
 837                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 838                 newlines.append('''
 839                 SET(IDL_FILES ${BASEIDL_FILES})
 840                 ''')
 841                 pass
 842             pass
 843
 844         # --
 845         # --
 846
 847         key = "IDL_FILES"
 848         if self.__thedict__.has_key(key):
 849             newlines.append('''
 850             FOREACH(input ${IDL_FILES})
 851             STRING(REGEX REPLACE ".idl" "" base ${input})
 852             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 853             SET(outputs ${src})
 854             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 855             SET(outputs ${outputs} ${dynsrc})
 856             ADD_CUSTOM_COMMAND(
 857             OUTPUT ${outputs}
 858             COMMAND ${OMNIORB_IDL} ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
 859             MAIN_DEPENDENCY ${input}
 860             )
 861             install(FILES ${input} DESTINATION idl/salome)
 862             SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 863             install(FILES ${IDL_HEADER} DESTINATION include/salome)
 864             INSTALL(CODE "SET(IDL_FILE ${input})")
 865             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 866             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 867             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 868             # --
 869             SET(flags)
 870             FOREACH(f ${IDLPYFLAGS})
 871             SET(flags "${flags} ${f}")
 872             ENDFOREACH(f ${IDLPYFLAGS})
 873             SET(IDLPYFLAGS ${flags})
 874             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 875             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 876             # --
 877             ''')
 878             if self.module == "kernel":
 879                 newlines.append('''
 880                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 881                 ''')
 882             else:
 883                 newlines.append('''
 884                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 885                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 886                 ''')
 887                 pass
 888             newlines.append('''
 889             ENDFOREACH(input ${IDL_FILES})
 890             ''')
 891             pass
 892
 893         # --
 894         # --
 895         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
 896             if self.__thedict__.has_key(key):
 897                 newlines.append('''
 898                 SET(SWIG_SOURCES ${%s})
 899                 '''%(key))
 900                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
 901                 pass
 902             pass
 903
 904         # --
 905         # --
 906         if self.__thedict__.has_key("SWIG_SOURCES"):
 907             newlines.append('''
 908             IF(SWIG_SOURCES MATCHES ";")
 909             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 910             ELSE(SWIG_SOURCES MATCHES ";")
 911             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 912             ENDIF(SWIG_SOURCES MATCHES ";")
 913             ADD_CUSTOM_COMMAND(
 914             OUTPUT ${build_srcs}
 915             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
 916             MAIN_DEPENDENCY ${SWIG_SOURCES}
 917             )
 918             ''')
 919             pass
 920
 921         # --
 922         # --
 923         key = "MOC_FILES"
 924         if self.__thedict__.has_key(key):
 925             newlines.append('''
 926             FOREACH(output ${MOC_FILES})
 927             STRING(REGEX REPLACE _moc.cxx .h input ${output})
 928             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 929             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 930             ADD_CUSTOM_COMMAND(
 931             OUTPUT ${output}
 932             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
 933             MAIN_DEPENDENCY ${input}
 934             )
 935             ENDFOREACH(output ${MOC_FILES})
 936             ''')
 937             pass
 938
 939         # --
 940         # --
 941         key = "UIC_FILES"
 942         if self.__thedict__.has_key(key):
 943             newlines.append('''
 944             FOREACH(output ${UIC_FILES})
 945             STRING(REPLACE "ui_" "" input ${output})
 946             STRING(REPLACE ".h" ".ui" input ${input})
 947             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 948             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 949             ADD_CUSTOM_COMMAND(
 950             OUTPUT ${output}
 951             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
 952             MAIN_DEPENDENCY ${input}
 953             )
 954             ENDFOREACH(output ${UIC_FILES})
 955             ''')
 956             pass
 957
 958         # --
 959         # --
 960         key = "QRC_FILES"
 961         if self.__thedict__.has_key(key):
 962             newlines.append('''
 963             FOREACH(output ${QRC_FILES})
 964             STRING(REGEX REPLACE "qrc_" "" input ${output})
 965             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
 966             STRING(REGEX REPLACE ".qrc" "" name ${input})
 967             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 968             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 969             ADD_CUSTOM_COMMAND(
 970             OUTPUT ${output}
 971             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
 972             MAIN_DEPENDENCY ${input}
 973             )
 974             ENDFOREACH(output ${QRC_FILES})
 975             ''')
 976             pass
 977
 978         # --
 979         # --
 980         key = "SIP_FILES"
 981         if self.__thedict__.has_key(key):
 982             newlines.append('''
 983             FOREACH(input ${SIP_FILES})
 984             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 985             SET(output)
 986             FOREACH(out ${SIP_SRC})
 987             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
 988             ENDFOREACH(out ${SIP_SRC})
 989             ADD_CUSTOM_COMMAND(
 990             OUTPUT ${output}
 991             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
 992             MAIN_DEPENDENCY ${input}
 993             )
 994             ENDFOREACH(input ${SIP_FILES})
 995             ''')
 996             pass
 997
 998         # --
 999         # Treat the install targets
1000         # --
1001         d = {
1002             "salomeadmux_DATA"            :  "salome_adm/unix",
1003             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
1004             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
1005             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
1006             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
1007             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
1008             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
1009             "salomeinclude_DATA"          :  "include/salome",
1010             "salomeinclude_HEADERS"       :  "include/salome",
1011             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
1012             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
1013             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
1014             "dist_salomescript_SCRIPTS"   :  "bin/salome",
1015             "dist_salomescript_DATA"      :  "bin/salome",
1016             "dist_salomescript_PYTHON"    :  "bin/salome",
1017             "nodist_salomescript_DATA"    :  "bin/salome",
1018             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1019             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
1020             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1021             }
1022         if self.module == "medfile":
1023             d = {
1024                 "include_HEADERS"        :  "include",
1025                 "nodist_include_HEADERS" :  "include",
1026                 "bin_SCRIPTS"            :  "bin",
1027                 "doc_DATA"               :  "${docdir}",
1028                 }
1029             pass
1030         for key, value in d.items():
1031             if self.__thedict__.has_key(key):
1032                 self.addInstallTarget(key, value, newlines)
1033                 pass
1034             pass
1035
1036         # --
1037         return
1038
1039     def setLibAdd(self, key, newlines):
1040         # --
1041         newlines.append(r'''
1042         SET(libadd)
1043         ''')
1044         # --
1045         newlines.append(r'''
1046         IF(WINDOWS)
1047         SET(targets)
1048         SET(targets ${targets} MEFISTO2D)
1049         FOREACH(target ${targets})
1050         IF(name STREQUAL ${target})
1051         SET(dir $ENV{F2CHOME})
1052         STRING(REPLACE "\\\\" "/" dir ${dir})
1053         SET(libadd ${libadd} ${dir}/LIBF77.lib)
1054         SET(libadd ${libadd} ${dir}/LIBI77.lib)
1055         ENDIF(name STREQUAL ${target})
1056         ENDFOREACH(target ${targets})
1057         ENDIF(WINDOWS)
1058         ''')
1059         # --
1060         newlines.append(r'''
1061         SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1062         IF(name STREQUAL SALOMEBasics)
1063         SET(libs ${libs} ${PTHREAD_LIBS})
1064         ENDIF(name STREQUAL SALOMEBasics)
1065         ''')
1066         if key == "bin_PROGRAMS":
1067             newlines.append(r'''
1068             SET(libs ${libs} ${LDADD})
1069             ''')
1070             pass
1071         # --
1072         newlines.append(r'''
1073         FOREACH(lib ${libs})
1074         GET_FILENAME_COMPONENT(ext ${lib} EXT)
1075         IF(ext STREQUAL .la)
1076         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1077         STRING(REPLACE "lib" "" lib ${lib})
1078         ENDIF(ext STREQUAL .la)
1079         SET(vars)
1080         SET(vars ${vars} -no-undefined)
1081         IF(WINDOWS)
1082         SET(vars ${vars} -module)
1083         SET(vars ${vars} -Wl,-E)
1084         SET(vars ${vars} -Xlinker)
1085         SET(vars ${vars} -export-dynamic)
1086         SET(vars ${vars} -lm)
1087         SET(vars ${vars} -lboost_thread)
1088         SET(vars ${vars} -lboost_signals)
1089         SET(vars ${vars} -lvtkWidgets)
1090         ENDIF(WINDOWS)
1091         FOREACH(v ${vars})
1092         IF(lib STREQUAL v)
1093         SET(lib)
1094         ENDIF(lib STREQUAL v)
1095         ENDFOREACH(v ${vars})
1096         SET(libadd ${libadd} ${lib})
1097         ENDFOREACH(lib ${libs})
1098         TARGET_LINK_LIBRARIES(${name} ${libadd})
1099         ''')
1100         # --
1101         newlines.append(r'''
1102         IF(WINDOWS)
1103         SET(targets)
1104         SET(targets ${targets} MEFISTO2D)
1105         FOREACH(target ${targets})
1106         IF(name STREQUAL ${target})
1107         IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1108         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1109         ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1110         ENDIF(name STREQUAL ${target})
1111         ENDFOREACH(target ${targets})
1112         ENDIF(WINDOWS)
1113         ''')
1114         # --
1115         return
1116
1117     def setCompilationFlags(self, key, newlines):
1118         newlines.append(r'''
1119         SET(var)
1120         IF(WINDOWS)
1121         SET(targets)
1122         SET(targets ${targets} SalomeIDLKernel)
1123         SET(targets ${targets} SalomeDS)
1124         SET(targets ${targets} SALOMEDSTest)
1125         SET(targets ${targets} SALOMEDS_Client_exe)
1126         SET(targets ${targets} SalomeIDLGEOM)
1127         SET(targets ${targets} GEOMEngine)
1128         SET(targets ${targets} MEDEngine)
1129         SET(targets ${targets} SMESHEngine)
1130         SET(targets ${targets} SMESH)
1131         FOREACH(target ${targets})
1132         IF(name STREQUAL ${target})
1133         SET(var ${var} -DNOGDI)
1134         ENDIF(name STREQUAL ${target})
1135         ENDFOREACH(target ${targets})
1136         ENDIF(WINDOWS)
1137         ''')
1138         # --
1139         newlines.append(r'''
1140         IF(WINDOWS)
1141         SET(targets)
1142         SET(targets ${targets} MEFISTO2D)
1143         FOREACH(target ${targets})
1144         IF(name STREQUAL ${target})
1145         SET(dir $ENV{F2CHOME})
1146         STRING(REPLACE "\\\\" "/" dir ${dir})
1147         SET(var ${var} -I${dir})
1148         ENDIF(name STREQUAL ${target})
1149         ENDFOREACH(target ${targets})
1150         ENDIF(WINDOWS)
1151         ''')
1152         # --
1153         if self.module in ["geom", "med"]:
1154             newlines.append(r'''
1155             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1156             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1157             ''')
1158             pass
1159         if key == "bin_PROGRAMS":
1160             newlines.append(r'''
1161             SET(var ${var} ${AM_CPPFLAGS})
1162             SET(var ${var} ${AM_CXXFLAGS})
1163             ''')
1164             pass
1165         newlines.append(r'''
1166         SET(var ${var} ${PLATFORM_CPPFLAGS})
1167         SET(var ${var} ${PTHREAD_CFLAGS})
1168         SET(var ${var} ${${amname}_CPPFLAGS})
1169         SET(var ${var} ${${amname}_CXXFLAGS})
1170         SET(var ${var} ${${amname}_CFLAGS})
1171         SET(vars)
1172         IF(WINDOWS)
1173         SET(vars ${vars} -include SALOMEconfig.h)
1174         SET(vars ${vars} -ftemplate-depth-32)
1175         ENDIF(WINDOWS)
1176         SET(flags)
1177         FOREACH(f ${var})
1178         FOREACH(v ${vars})
1179         IF(f STREQUAL v)
1180         SET(f)
1181         ENDIF(f STREQUAL v)
1182         ENDFOREACH(v ${vars})
1183         SET(flags "${flags} ${f}")
1184         ENDFOREACH(f ${var})
1185         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1186         ''')
1187         return
1188
1189     def addLibTarget(self, key, newlines):
1190         newlines.append(r'''
1191         FOREACH(amname ${%s})
1192         '''%(key))
1193         # --
1194         # Replace .la by _la ...
1195         # --
1196         newlines.append(r'''
1197         STRING(REPLACE .la _la amname ${amname})
1198         ''')
1199         # --
1200         # Remove the _la for the cmake name
1201         # --
1202         newlines.append(r'''
1203         STRING(LENGTH ${amname} len)
1204         MATH(EXPR newlen "${len}-3")
1205         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1206         ''')
1207         # --
1208         # Does the target begins with lib ??
1209         # If yes, remove lib at beginning for cmake name
1210         # --
1211         newlines.append(r'''
1212         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1213         IF(BEGIN_WITH_lib)
1214         STRING(LENGTH ${name} len)
1215         MATH(EXPR newlen "${len}-3")
1216         STRING(SUBSTRING ${name} 3 ${newlen} name)
1217         ENDIF(BEGIN_WITH_lib)
1218         ''')
1219         # --
1220         # Does the target is an idl library
1221         # --
1222         newlines.append(r'''
1223         STRING(REGEX MATCH "IDL" ISIDL ${name})
1224         ''')
1225         # --
1226         # Set the type of the library
1227         # --
1228         newlines.append(r'''
1229         IF(ISIDL)
1230         IF(WINDOWS)
1231         SET(type STATIC)
1232         ELSE(WINDOWS)
1233         SET(type SHARED)
1234         ENDIF(WINDOWS)
1235         ELSE(ISIDL)
1236         SET(type SHARED)
1237         ENDIF(ISIDL)
1238         ''')
1239         # --
1240         # Set sources for the library
1241         # --
1242         newlines.append(r'''
1243         SET(srcs)
1244         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1245         GET_FILENAME_COMPONENT(ext ${src} EXT)
1246         IF(ext STREQUAL .f)
1247         IF(src STREQUAL trte.f)
1248         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1249         STRING(REPLACE ".f" ".c" src ${src})
1250         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1251         SET(output ${src})
1252         ADD_CUSTOM_COMMAND(
1253         OUTPUT ${output}
1254         COMMAND f2c ${input}
1255         MAIN_DEPENDENCY ${input}
1256         )
1257         ELSE(src STREQUAL trte.f)
1258         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1259         STRING(REPLACE ".f" ".o" src ${src})
1260         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1261         SET(output ${src})
1262         IF(WINDOWS)
1263         SET(F77 g77)
1264         ELSE(WINDOWS)
1265         SET(F77 gfortran)
1266         ENDIF(WINDOWS)
1267         ADD_CUSTOM_COMMAND(
1268         OUTPUT ${output}
1269         COMMAND ${F77} -c -o ${output} ${input}
1270         MAIN_DEPENDENCY ${input}
1271         )
1272         ENDIF(src STREQUAL trte.f)
1273         ENDIF(ext STREQUAL .f)
1274         SET(srcs ${srcs} ${src})
1275         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1276         ''')
1277         newlines.append(r'''
1278         SET(build_srcs)
1279         ''')
1280         newlines.append(r'''
1281         SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1282         ''')
1283         newlines.append(r'''
1284         FOREACH(f ${l})
1285         GET_FILENAME_COMPONENT(ext ${f} EXT)
1286         IF(ext STREQUAL .py)
1287         ELSE(ext STREQUAL .py)
1288         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1289         ENDIF(ext STREQUAL .py)
1290         ENDFOREACH(f ${l})
1291         SET(srcs ${build_srcs} ${srcs})
1292         ''')
1293         # --
1294         # Add the library to cmake
1295         # --
1296         newlines.append(r'''
1297         ADD_LIBRARY(${name} ${type} ${srcs})
1298         ''')
1299         # --
1300         # The compilation flags
1301         # --
1302         self.setCompilationFlags(key, newlines)
1303         # --
1304         newlines.append(r'''
1305         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1306         ''')
1307         # --
1308         self.setLibAdd(key, newlines)
1309         # --
1310         if 1: # key != "noinst_LTLIBRARIES":
1311             if self.module == "medfile":
1312                 newlines.append(r'''
1313                 SET(DEST lib)
1314                 ''')
1315             else:
1316                 newlines.append(r'''
1317                 SET(DEST lib/salome)
1318                 ''')
1319                 pass
1320             newlines.append(r'''
1321             IF(BEGIN_WITH_lib)
1322             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1323             ''')
1324             if self.module == "geom":
1325                 newlines.append(r'''
1326                 IF(WINDOWS)
1327                 STRING(REGEX MATCH "Export" ISExport ${name})
1328                 IF(ISExport)
1329                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1330                 ENDIF(ISExport)
1331                 STRING(REGEX MATCH "Import" ISImport ${name})
1332                 IF(ISImport)
1333                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1334                 ENDIF(ISImport)
1335                 ENDIF(WINDOWS)
1336                 ''')
1337                 pass
1338             newlines.append(r'''
1339             # IF(name STREQUAL SalomePyQt)
1340             # INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1341             # ENDIF(name STREQUAL SalomePyQt)
1342             ''')
1343             newlines.append(r'''
1344             ELSE(BEGIN_WITH_lib)
1345             ''')
1346             newlines.append(r'''
1347             IF(WINDOWS)
1348             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1349             IF(CMAKE_BUILD_TYPE STREQUAL Release)
1350             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.pyd)
1351             ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1352             INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}_d.pyd)
1353             ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1354             ELSE(WINDOWS)
1355             GET_TARGET_PROPERTY(version ${name} VERSION)
1356             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1357             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1358             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1359             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1360             ENDIF(WINDOWS)
1361             ''')
1362             newlines.append(r'''
1363             ENDIF(BEGIN_WITH_lib)
1364             ''')
1365             pass
1366         # --
1367         newlines.append(r'''
1368         ENDFOREACH(amname ${%s})
1369         '''%(key))
1370         # --
1371         return
1372
1373     def addBinTarget(self, key, newlines):
1374         # --
1375         newlines.append(r'''
1376         FOREACH(amname ${bin_PROGRAMS})
1377         ''')
1378         # --
1379         newlines.append(r'''
1380         SET(name "${amname}_exe")
1381         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1382         LIST(LENGTH srcs nb)
1383         IF(nb)
1384         ADD_EXECUTABLE(${name} ${srcs})
1385         ''')
1386         # --
1387         self.setCompilationFlags(key, newlines)
1388         # --
1389         self.setLibAdd(key, newlines)
1390         # --
1391         if self.module == "medfile":
1392             newlines.append(r'''
1393             SET(DEST bin)
1394             ''')
1395         else:
1396             newlines.append(r'''
1397             SET(DEST bin/salome)
1398             ''')
1399             pass
1400         # --
1401         newlines.append(r'''
1402         IF(WINDOWS)
1403         INSTALL(TARGETS ${name} DESTINATION ${DEST})
1404         INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1405         INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1406         ELSE(WINDOWS)
1407         SET(PERMS)
1408         SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1409         SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1410         SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1411         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1412         ENDIF(WINDOWS)
1413         ''')
1414         # --
1415         newlines.append(r'''
1416         ENDIF(nb)
1417         ''')
1418         # --
1419         newlines.append(r'''
1420         ENDFOREACH(amname ${bin_PROGRAMS})
1421         ''')
1422         # --
1423         return
1424
1425     def addInstallTarget(self, key, destination, newlines):
1426         newlines.append(r"FOREACH(f ${%s})"%(key))
1427         newlines.append(r'''
1428         SET(DEST %s)
1429         '''%(destination))
1430         newlines.append(r'''
1431         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1432         IF(test_SALOMEconfig.h.in)
1433         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1434         ELSE(test_SALOMEconfig.h.in)
1435         SET(dummy dummy-NOTFOUND)
1436         MARK_AS_ADVANCED(dummy)
1437         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1438         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1439         IF(dummy)
1440         ''')
1441         if key in ['dist_salomescript_SCRIPTS']:
1442             newlines.append(r'''
1443             SET(PERMS)
1444             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1445             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1446             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1447             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1448             ''')
1449         else:
1450             newlines.append(r'''
1451             INSTALL(FILES ${f} DESTINATION ${DEST})
1452             ''')
1453             pass
1454         newlines.append(r'''
1455         ELSE(dummy)
1456         GET_FILENAME_COMPONENT(ext ${f} EXT)
1457         IF(ext STREQUAL .qm)
1458         STRING(REGEX REPLACE .qm .ts input ${f})
1459         ''')
1460         if self.module in ["kernel", "gui"]:
1461             newlines.append(r'''
1462             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1463             ''')
1464         else:
1465             newlines.append(r'''
1466             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1467             ''')
1468             pass
1469         newlines.append(r'''
1470         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1471         # ADD_CUSTOM_COMMAND(
1472         # OUTPUT ${output}
1473         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1474         # MAIN_DEPENDENCY ${input}
1475         # )
1476         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1477         ENDIF(ext STREQUAL .qm)
1478         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1479         ENDIF(dummy)
1480         ENDIF(test_SALOMEconfig.h.in)
1481         ''')
1482         newlines.append(r'''
1483         GET_FILENAME_COMPONENT(ext ${f} EXT)
1484         IF(ext STREQUAL .py)
1485         INSTALL(CODE "SET(PYTHON_FILE ${f})")
1486         INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1487         INSTALL(CODE "SET(DEST ${DEST})")
1488         INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1489         ''')
1490         if self.module == "kernel":
1491             newlines.append('''
1492             IF(f STREQUAL SALOME_ContainerPy.py)
1493             ELSE(f STREQUAL SALOME_ContainerPy.py)
1494             IF(f STREQUAL am2cmake.py)
1495             ELSE(f STREQUAL am2cmake.py)
1496             INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1497             ENDIF(f STREQUAL am2cmake.py)
1498             ENDIF(f STREQUAL SALOME_ContainerPy.py)
1499             ''')
1500         else:
1501             newlines.append('''
1502             STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1503             INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1504             ''')
1505             pass
1506         newlines.append(r'''
1507         ENDIF(ext STREQUAL .py)
1508         ''')
1509         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1510         return
1511
1512     def writeListsFile(self):
1513         f = open(self.listsFile, "w")
1514         f.write(self.content)
1515         f.close()
1516         return
1517
1518     pass
1519
1520 def convertAmFile(the_root, root, dirs, files, f, module):
1521     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1522     cmake.writeListsFile()
1523     return
1524
1525 def usage(exit_status):
1526     from sys import exit
1527     from sys import argv
1528     print "Usage: %s --module"%(argv[0])
1529     exit(exit_status)
1530     return
1531
1532 if __name__ == "__main__":
1533     #
1534     from sys import argv
1535     if len(argv) != 2:
1536         usage(1)
1537         pass
1538     #
1539     module = argv[1]
1540     if module.find('--') != 0:
1541         usage(1)
1542         pass
1543     module = module[2:]
1544     if len(module) == 0:
1545         usage(1)
1546         pass
1547     #
1548     from os import getcwd
1549     the_root = getcwd()
1550     #
1551     from os import walk
1552     for root, dirs, files in walk(the_root):
1553         # --
1554         # E.A. : Remove 'CVS' in dirs
1555         # E.A. : It allows to not recurse in CVS dirs
1556         # E.A. : See os module python documentation
1557         # --
1558         try:
1559             dirs.remove('CVS')
1560         except ValueError:
1561             pass
1562         # --
1563         for f in files:
1564             if f == "Makefile.am":
1565                 convertAmFile(the_root, root, dirs, files, f, module)
1566                 pass
1567             pass
1568         pass
1569     #
1570     pass