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