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