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         content = content.replace("-no-undefined -version-info=0:0:0", "")
 129         content = content.replace("-include SALOMEconfig.h", "")
 130
 131         # --
 132         # Compatibility medfile
 133         # --
 134         content = content.replace("-no-undefined -version-info 0:0:0", "")
 135         content = content.replace("-no-undefined -version-info 2:5:1", "")
 136
 137         # --
 138         cas_list = [
 139             "BinLPlugin",
 140             "BinPlugin",
 141             "BinTObjPlugin",
 142             "BinXCAFPlugin",
 143             "FWOSPlugin",
 144             "PTKernel",
 145             "StdLPlugin",
 146             "StdPlugin",
 147             "TKAdvTools",
 148             "TKBin",
 149             "TKBinL",
 150             "TKBinTObj",
 151             "TKBinXCAF",
 152             "TKBO",
 153             "TKBool",
 154             "TKBRep",
 155             "TKCAF",
 156             "TKCDF",
 157             "TKernel",
 158             "TKFeat",
 159             "TKFillet",
 160             "TKG2d",
 161             "TKG3d",
 162             "TKGeomAlgo",
 163             "TKGeomBase",
 164             "TKHLR",
 165             "TKIGES",
 166             "TKLCAF",
 167             "TKMath",
 168             "TKMesh",
 169             "TKMeshVS",
 170             "TKNIS",
 171             "TKOffset",
 172             "TKOpenGl",
 173             "TKPCAF",
 174             "TKPLCAF",
 175             "TKPrim",
 176             "TKPShape",
 177             "TKService",
 178             "TKShapeSchema",
 179             "TKShHealing",
 180             "TKStdLSchema",
 181             "TKStdSchema",
 182             "TKSTEP",
 183             "TKSTEP209",
 184             "TKSTEPAttr",
 185             "TKSTEPBase",
 186             "TKSTL",
 187             "TKTObj",
 188             "TKTopAlgo",
 189             "TKV2d",
 190             "TKV3d",
 191             "TKVRML",
 192             "TKXCAF",
 193             "TKXCAFSchema",
 194             "TKXDEIGES",
 195             "TKXDESTEP",
 196             "TKXMesh",
 197             "TKXml",
 198             "TKXmlL",
 199             "TKXmlTObj",
 200             "TKXmlXCAF",
 201             "TKXSBase",
 202             "XCAFPlugin",
 203             "XmlLPlugin",
 204             "XmlPlugin",
 205             "XmlTObjPlugin",
 206             "XmlXCAFPlugin",
 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             "interpkernel",
 311             "InterpKernelTest",
 312             "MEDMEMCppTest",
 313             "medmem",
 314             "med_V2_1",
 315             "MEDWrapperBase",
 316             "MEDWrapper",
 317             "MEDWrapper_V2_1",
 318             "MEDWrapper_V2_2",
 319             "SalomeIDLMED",
 320             ]
 321         full_list = cas_list + kernel_list + gui_list
 322         full_list += geom_list + med_list
 323         # --
 324         full_list += [
 325             "boost_thread",
 326             ]
 327         # --
 328         # E.A. : sort by len before substitution ...
 329         # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
 330         # And you understand ...
 331         # --
 332         full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
 333         # --
 334         for key in full_list:
 335             content = content.replace("-l%s"%(key), "${%s}"%(key))
 336             pass
 337
 338         # --
 339         # Split content in lines to treat each one separately
 340         # --
 341         lines = content.split('\n')
 342
 343         # --
 344         # newlines contains the lines of the future CMakeLists.txt file
 345         # --
 346         newlines = []
 347
 348         # --
 349         # opened_ifs is used to deals with nested conditionnals
 350         # --
 351         opened_ifs = []
 352
 353         # --
 354         # the __thedict__ dictionnary contains key, val
 355         # of the Makefile.am file
 356         # --
 357         self.__thedict__ = {}
 358
 359         # --
 360         # Initialize file ... mainly includes other cmake files
 361         # --
 362         self.initialize(newlines)
 363
 364         # --
 365         # Do the job for each line
 366         # --
 367         for line in lines:
 368             self.treatLine(line, newlines, opened_ifs)
 369             pass
 370
 371         # --
 372         # Finalize file ... it is in here the cmake job is done
 373         # --
 374         self.finalize(newlines)
 375
 376         # --
 377         # Add a last CR at the end of the file
 378         # --
 379         newlines.append('\n')
 380
 381         # --
 382         # Concatenate newlines into content
 383         # --
 384         content = '\n'.join(newlines)
 385
 386         # --
 387         self.content = content
 388
 389         # --
 390         return
 391
 392     def initialize(self, newlines):
 393         if self.root == self.the_root:
 394             # --
 395             newlines.append("""
 396             CMAKE_MINIMUM_REQUIRED(VERSION 2.4)
 397             IF(COMMAND cmake_policy)
 398             cmake_policy(SET CMP0003 NEW)
 399             ENDIF(COMMAND cmake_policy)
 400             """)
 401             # --
 402             if self.module == "kernel":
 403                 newlines.append("""
 404                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 405                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 406                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 407                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 408                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 409                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 410                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 411                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 412                 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 413                 """)
 414                 pass
 415             else:
 416                 newlines.append("""
 417                 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
 418                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
 419                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
 420                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
 421                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
 422                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
 423                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
 424                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
 425                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
 426                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
 427                 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
 428                 """)
 429                 if self.module == "gui":
 430                     newlines.append("""
 431                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
 432                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
 433                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 434                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
 435                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
 436                     INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 437                     """)
 438                 else:
 439                     newlines.append("""
 440                     SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
 441                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
 442                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
 443                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
 444                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
 445                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
 446                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
 447                     INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
 448                     """)
 449                     if self.module == "med":
 450                         newlines.append("""
 451                         INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 452                         """)
 453                         pass
 454                     if self.module == "smesh":
 455                         newlines.append("""
 456                         SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
 457                         SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
 458                         INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
 459                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
 460                         INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
 461                         """)
 462                         pass
 463                     pass
 464                 pass
 465             # --
 466             if self.module == "kernel":
 467                 newlines.append("""
 468                 SET(WITH_LOCAL 1)
 469                 SET(WITH_BATCH 1)
 470                 set(VERSION 4.1.3)
 471                 set(XVERSION 0x040103)
 472                 """)
 473             elif self.module == "gui":
 474                 newlines.append("""
 475                 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
 476                 SET(ENABLE_VTKVIEWER ON)
 477                 SET(ENABLE_SALOMEOBJECT ON)
 478                 SET(ENABLE_OCCVIEWER ON)
 479                 SET(ENABLE_GLVIEWER ON)
 480                 SET(ENABLE_PLOT2DVIEWER ON)
 481                 SET(ENABLE_PYCONSOLE ON)
 482                 SET(ENABLE_SUPERVGRAPHVIEWER ON)
 483                 # SET(ENABLE_QXGRAPHVIEWER ON)
 484                 """)
 485                 pass
 486             elif self.module == "geom":
 487                 newlines.append("""
 488                 SET(GEOM_ENABLE_GUI ON)
 489                 """)
 490                 pass
 491             elif self.module == "medfile":
 492                 newlines.append("""
 493                 SET(MED_NUM_MAJEUR 2)
 494                 SET(MED_NUM_MINEUR 3)
 495                 SET(MED_NUM_RELEASE 5)
 496                 SET(LONG_OR_INT int)
 497                 IF(NOT WINDOWS)
 498                 SET(FLIBS -lgfortranbegin -lgfortran)
 499                 ENDIF(NOT WINDOWS)
 500                 """)
 501                 pass
 502             elif self.module == "med":
 503                 newlines.append("""
 504                 SET(MED_ENABLE_KERNEL ON)
 505                 SET(MED_ENABLE_GUI ON)
 506                 """)
 507                 pass
 508             # --
 509             pass
 510         # --
 511         newlines.append("""
 512         SET(SUBDIRS)
 513         SET(AM_CPPFLAGS)
 514         SET(AM_CXXFLAGS)
 515         SET(LDADD)
 516         """)
 517         # --
 518         return
 519
 520     def treatLine(self, line, newlines, opened_ifs):
 521
 522         # --
 523         # Print the comment above the line itself
 524         # --
 525         if line.find('#') >= 0:
 526             fields = line.split('#')
 527             line = fields[0]
 528             comment = '#'.join([''] + fields[1:])
 529             newlines.append(comment)
 530             if len(line) == 0:
 531                 return
 532             pass
 533
 534         # --
 535         # If the line begins with 'include ', just comment it
 536         # --
 537         if line.find("include ") == 0:
 538             newlines.append("# " + line)
 539             return
 540
 541         # --
 542         # If the line begins with '-include', just comment it
 543         # --
 544         if line.find("-include") == 0:
 545             newlines.append("# " + line)
 546             return
 547
 548         # --
 549         # If the line is a definition of a make rule, just comment it
 550         # --
 551         if line.count(':') == 1:
 552             newlines.append("# " + line)
 553             return
 554
 555         # --
 556         # A particuliar case
 557         # --
 558         if line.find('install-exec-local:') == 0:
 559             newlines.append("# " + line)
 560             return
 561
 562         # --
 563         # If the line begin by a tabulation, consider it's a makefile command and comment it
 564         # --
 565         if line.find("\t") == 0:
 566             newlines.append("# " + line)
 567             return
 568
 569         # --
 570         # Replace the $(TOTO) by ${TOTO}
 571         # Replace the @TOTO@  by ${TOTO}
 572         # --
 573         line = p_dollar.sub(r"${\1}", line)
 574         line = p_arobas.sub(r"${\1}", line)
 575
 576         # --
 577         line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
 578         line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
 579         line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
 580         line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
 581         line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
 582
 583         # --
 584         # Check if the line is a 'if' condition
 585         # If yes, replace it by a cmake grammar
 586         # --
 587         match = p_if.match(line)
 588         if match:
 589             theif = match.group("val")
 590             if theif[0] == "!":
 591                 theif = "NOT " + theif[1:]
 592                 pass
 593             line = p_if.sub(r"IF(%s)"%(theif), line)
 594             opened_ifs.append(theif)
 595             newlines.append(line)
 596             return
 597
 598         # --
 599         # Check if the line is a 'else' condition
 600         # If yes, replace it by a cmake grammar
 601         # --
 602         match = p_else.match(line)
 603         if match:
 604             line = "ELSE(%s)"%(opened_ifs[-1])
 605             newlines.append(line)
 606             return
 607
 608         # --
 609         # Check if the line is a 'endif' condition
 610         # If yes, replace it by a cmake grammar
 611         # --
 612         match = p_endif.match(line)
 613         if match:
 614             line = "ENDIF(%s)"%(opened_ifs[-1])
 615             opened_ifs[-1:] = []
 616             newlines.append(line)
 617             return
 618
 619         # --
 620         # Check if the line is an attribution '=' or '+='
 621         # --
 622         match = p_attribution.match(line)
 623         if match:
 624             self.treatAttribution(match, newlines)
 625             return
 626
 627         # --
 628         newlines.append(line)
 629
 630         # --
 631         return
 632
 633     def treatAttribution(self, match, newlines):
 634
 635         spaces = match.group("spaces")
 636         key = match.group("key")
 637         method = match.group("method")
 638         value = match.group("value")
 639         # print [spaces, key, method, value]
 640
 641         # --
 642         # Open cmake SET command
 643         # --
 644         newlines.append(spaces + "SET(" + key)
 645
 646         # --
 647         # If method is '+=', put the previous definition as first value
 648         # --
 649         if method == "+=":
 650             newlines.append("%s    ${%s}"%(spaces, key))
 651             pass
 652
 653         # --
 654         fields = value.split()
 655         for i in range(len(fields)):
 656             newlines.append("%s    %s"%(spaces, fields[i]))
 657             pass
 658
 659         # --
 660         if method == "+=":
 661             # --
 662             # The try: except KeyError is here if the +=
 663             # is an error which occurs in salome ...
 664             # --
 665             try:
 666                 self.__thedict__[key] += fields[:]
 667             except KeyError:
 668                 self.__thedict__[key] = fields[:]
 669                 pass
 670             pass
 671         else:
 672             self.__thedict__[key]  = fields[:]
 673             pass
 674
 675         # --
 676         # Close cmake SET command
 677         # --
 678
 679         newlines.append("%s)"%(spaces))
 680
 681         return
 682
 683     def finalize(self, newlines):
 684
 685         # --
 686         # Convert the .in files in build dir
 687         # --
 688         for f in self.files:
 689             if f[-3:] == ".in":
 690                 if f == "sstream.in":
 691                     continue
 692                 if f == "SALOMEconfig.ref.in":
 693                     out = "SALOMEconfig.h"
 694                 else:
 695                     out = f[:-3]
 696                     pass
 697                 newlines.append(r'''
 698                 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
 699                 '''%(f))
 700                 newlines.append(r'''
 701                 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
 702                 '''%(out))
 703                 newlines.append(r'''
 704                 MESSAGE(STATUS "Creation of ${output}")
 705                 CONFIGURE_FILE(${input} ${output})
 706                 ''')
 707                 pass
 708             pass
 709
 710         # --
 711         # convert the SUBDIRS in cmake grammar
 712         # --
 713         if 1: # self.__thedict__.has_key("SUBDIRS"):
 714             newlines.append(r'''
 715             FOREACH(dir ${SUBDIRS})
 716             IF(NOT dir STREQUAL .)
 717             ADD_SUBDIRECTORY(${dir})
 718             ENDIF(NOT dir STREQUAL .)
 719             ENDFOREACH(dir ${SUBDIRS})
 720             ''')
 721             pass
 722
 723         # --
 724         # --
 725         for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
 726             if self.__thedict__.has_key(key):
 727                 self.addLibTarget(key, newlines)
 728                 pass
 729             pass
 730
 731         # --
 732         # --
 733         for key in ["bin_PROGRAMS"]:
 734             if self.__thedict__.has_key(key):
 735                 self.addBinTarget(key, newlines)
 736                 pass
 737             pass
 738
 739         # --
 740         # --
 741         if self.__thedict__.has_key("BASEIDL_FILES"):
 742             if not self.__thedict__.has_key("IDL_FILES"):
 743                 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
 744                 newlines.append('''
 745                 SET(IDL_FILES ${BASEIDL_FILES})
 746                 ''')
 747                 pass
 748             pass
 749
 750         # --
 751         # --
 752
 753         key = "IDL_FILES"
 754         if self.__thedict__.has_key(key):
 755             newlines.append('''
 756             FOREACH(input ${IDL_FILES})
 757             STRING(REGEX REPLACE ".idl" "" base ${input})
 758             SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
 759             SET(outputs ${src})
 760             SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
 761             SET(outputs ${outputs} ${dynsrc})
 762             ADD_CUSTOM_COMMAND(
 763             OUTPUT ${outputs}
 764             COMMAND ${OMNIORB_IDL} ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
 765             MAIN_DEPENDENCY ${input}
 766             )
 767             install(FILES ${input} DESTINATION idl/salome)
 768             SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
 769             install(FILES ${IDL_HEADER} DESTINATION include/salome)
 770             INSTALL(CODE "SET(IDL_FILE ${input})")
 771             INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
 772             INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
 773             INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
 774             # --
 775             SET(flags)
 776             FOREACH(f ${IDLPYFLAGS})
 777             SET(flags "${flags} ${f}")
 778             ENDFOREACH(f ${IDLPYFLAGS})
 779             SET(IDLPYFLAGS ${flags})
 780             STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
 781             INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
 782             # --
 783             ''')
 784             if self.module == "kernel":
 785                 newlines.append('''
 786                 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 787                 ''')
 788             else:
 789                 newlines.append('''
 790                 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
 791                 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
 792                 ''')
 793                 pass
 794             newlines.append('''
 795             ENDFOREACH(input ${IDL_FILES})
 796             ''')
 797             pass
 798
 799         # --
 800         # --
 801         for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
 802             if self.__thedict__.has_key(key):
 803                 newlines.append('''
 804                 SET(SWIG_SOURCES ${%s})
 805                 '''%(key))
 806                 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
 807                 pass
 808             pass
 809
 810         # --
 811         # --
 812         if self.__thedict__.has_key("SWIG_SOURCES"):
 813             newlines.append('''
 814             IF(SWIG_SOURCES MATCHES ";")
 815             STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 816             ELSE(SWIG_SOURCES MATCHES ";")
 817             SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
 818             ENDIF(SWIG_SOURCES MATCHES ";")
 819             ADD_CUSTOM_COMMAND(
 820             OUTPUT ${build_srcs}
 821             COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
 822             MAIN_DEPENDENCY ${SWIG_SOURCES}
 823             )
 824             ''')
 825             pass
 826
 827         # --
 828         # --
 829         key = "MOC_FILES"
 830         if self.__thedict__.has_key(key):
 831             newlines.append('''
 832             FOREACH(output ${MOC_FILES})
 833             STRING(REGEX REPLACE _moc.cxx .h input ${output})
 834             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 835             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 836             ADD_CUSTOM_COMMAND(
 837             OUTPUT ${output}
 838             COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
 839             MAIN_DEPENDENCY ${input}
 840             )
 841             ENDFOREACH(output ${MOC_FILES})
 842             ''')
 843             pass
 844
 845         # --
 846         # --
 847         key = "UIC_FILES"
 848         if self.__thedict__.has_key(key):
 849             newlines.append('''
 850             FOREACH(output ${UIC_FILES})
 851             STRING(REPLACE "ui_" "" input ${output})
 852             STRING(REPLACE ".h" ".ui" input ${input})
 853             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 854             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 855             ADD_CUSTOM_COMMAND(
 856             OUTPUT ${output}
 857             COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
 858             MAIN_DEPENDENCY ${input}
 859             )
 860             ENDFOREACH(output ${UIC_FILES})
 861             ''')
 862             pass
 863
 864         # --
 865         # --
 866         key = "QRC_FILES"
 867         if self.__thedict__.has_key(key):
 868             newlines.append('''
 869             FOREACH(output ${QRC_FILES})
 870             STRING(REGEX REPLACE "qrc_" "" input ${output})
 871             STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
 872             STRING(REGEX REPLACE ".qrc" "" name ${input})
 873             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 874             SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
 875             ADD_CUSTOM_COMMAND(
 876             OUTPUT ${output}
 877             COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
 878             MAIN_DEPENDENCY ${input}
 879             )
 880             ENDFOREACH(output ${QRC_FILES})
 881             ''')
 882             pass
 883
 884         # --
 885         # --
 886         key = "SIP_FILES"
 887         if self.__thedict__.has_key(key):
 888             newlines.append('''
 889             FOREACH(input ${SIP_FILES})
 890             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
 891             SET(output)
 892             FOREACH(out ${SIP_SRC})
 893             SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
 894             ENDFOREACH(out ${SIP_SRC})
 895             ADD_CUSTOM_COMMAND(
 896             OUTPUT ${output}
 897             COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
 898             MAIN_DEPENDENCY ${input}
 899             )
 900             ENDFOREACH(input ${SIP_FILES})
 901             ''')
 902             pass
 903
 904         # --
 905         # Treat the install targets
 906         # --
 907         d = {
 908             "salomeadmux_DATA"            :  "salome_adm/unix",
 909             "dist_salomeadmux_DATA"       :  "salome_adm/unix",
 910             "dist_salome_cmake_DATA"      :  "salome_adm/cmake_files",
 911             "dist_salomem4_DATA"          :  "salome_adm/unix/config_files",
 912             "dist_salome4depr_DATA"       :  "salome_adm/unix/config_files/DEPRECATED",
 913             "dist_admlocalm4_DATA"        :  "adm_local/unix/config_files",
 914             "dist_admlocal_cmake_DATA"    :  "adm_local/cmake_files",
 915             "salomeinclude_DATA"          :  "include/salome",
 916             "salomeinclude_HEADERS"       :  "include/salome",
 917             "dist_salomeres_DATA"         :  "share/salome/resources/%s"%(self.module),
 918             "nodist_salomeres_DATA"       :  "share/salome/resources/%s"%(self.module),
 919             "nodist_salomeres_SCRIPTS"    :  "share/salome/resources/%s"%(self.module),
 920             "dist_salomescript_SCRIPTS"   :  "bin/salome",
 921             "dist_salomescript_DATA"      :  "bin/salome",
 922             "dist_salomescript_PYTHON"    :  "bin/salome",
 923             "nodist_salomescript_DATA"    :  "bin/salome",
 924             "salomepython_PYTHON"         :  "lib/python${PYTHON_VERSION}/site-packages/salome",
 925             "nodist_salomepython_PYTHON"  :  "lib/python${PYTHON_VERSION}/site-packages/salome",
 926             "sharedpkgpython_PYTHON"      :  "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
 927             }
 928         if self.module == "medfile":
 929             d = {
 930                 "include_HEADERS"        :  "include",
 931                 "nodist_include_HEADERS" :  "include",
 932                 "bin_SCRIPTS"            :  "bin",
 933                 "doc_DATA"               :  "${docdir}",
 934                 }
 935             pass
 936         for key, value in d.items():
 937             if self.__thedict__.has_key(key):
 938                 self.addInstallTarget(key, value, newlines)
 939                 pass
 940             pass
 941
 942         # --
 943         return
 944
 945     def setLibAdd(self, key, newlines):
 946         # --
 947         newlines.append(r'''
 948         SET(libadd)
 949         ''')
 950         # --
 951         newlines.append(r'''
 952         IF(WINDOWS)
 953         SET(libadd ${libadd} Userenv.lib Ws2_32.lib)
 954         ELSE(WINDOWS)
 955         SET(libadd ${libadd} -ldl -lpthread)
 956         ENDIF(WINDOWS)
 957         ''')
 958         # --
 959         newlines.append(r'''
 960         SET(libs ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
 961         ''')
 962         if key == "bin_PROGRAMS":
 963             newlines.append(r'''
 964             SET(libs ${libs} ${LDADD})
 965             ''')
 966             pass
 967         # --
 968         newlines.append(r'''
 969         FOREACH(lib ${libs})
 970         GET_FILENAME_COMPONENT(ext ${lib} EXT)
 971         IF(ext STREQUAL .la)
 972         GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
 973         STRING(REPLACE "lib" "" lib ${lib})
 974         ENDIF(ext STREQUAL .la)
 975         IF(WINDOWS)
 976         SET(vars -Xlinker -export-dynamic -module -Wl,-E)
 977         SET(vars ${vars} -lutil -lm)
 978         FOREACH(v ${vars})
 979         IF(lib STREQUAL v)
 980         SET(lib)
 981         ENDIF(lib STREQUAL v)
 982         ENDFOREACH(v ${vars})
 983         ENDIF(WINDOWS)
 984         SET(libadd ${libadd} ${lib})
 985         ENDFOREACH(lib ${libs})
 986         TARGET_LINK_LIBRARIES(${name} ${PTHREADS_LIBRARY} ${libadd})
 987         ''')
 988         # --
 989         newlines.append(r'''
 990         IF(WINDOWS)
 991         SET(targets)
 992         SET(targets ${targets} SalomeHDFPersist)
 993         SET(targets ${targets} medC)
 994         SET(targets ${targets} medimport)
 995         SET(targets ${targets} medimportcxx)
 996         FOREACH(target ${targets})
 997         IF(name STREQUAL ${target})
 998         SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:LIBCMTD")
 999         ENDIF(name STREQUAL ${target})
1000         ENDFOREACH(target ${targets})
1001         ENDIF(WINDOWS)
1002         ''')
1003         # --
1004         if self.module == "med":
1005             newlines.append(r'''
1006             IF(WINDOWS)
1007             SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:LIBCMTD")
1008             ENDIF(WINDOWS)
1009             ''')
1010             pass
1011         # --
1012         return
1013
1014     def setCompilationFlags(self, key, newlines):
1015         newlines.append(r'''
1016         SET(var)
1017         IF(WINDOWS)
1018         SET(targets)
1019         SET(targets ${targets} SalomeIDLKernel)
1020         SET(targets ${targets} SalomeDS)
1021         SET(targets ${targets} SALOMEDS_Client_exe)
1022         SET(targets ${targets} SalomeIDLGEOM)
1023         SET(targets ${targets} GEOMEngine)
1024         SET(targets ${targets} MEDEngine)
1025         SET(targets ${targets} SMESHEngine)
1026         FOREACH(target ${targets})
1027         IF(name STREQUAL ${target})
1028         SET(var ${var} -DNOGDI)
1029         ENDIF(name STREQUAL ${target})
1030         ENDFOREACH(target ${targets})
1031         ENDIF(WINDOWS)
1032         ''')
1033         # --
1034         newlines.append(r'''
1035         IF(WINDOWS)
1036         SET(var ${var} -D_USE_MATH_DEFINES)
1037         ENDIF(WINDOWS)
1038         ''')
1039         # --
1040         if self.module in ["geom", "med"]:
1041             newlines.append(r'''
1042             SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1043             SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1044             ''')
1045             pass
1046         if key == "bin_PROGRAMS":
1047             newlines.append(r'''
1048             SET(var ${var} ${AM_CPPFLAGS})
1049             SET(var ${var} ${AM_CXXFLAGS})
1050             ''')
1051             pass
1052         newlines.append(r'''
1053         SET(var ${var} ${PLATFORM_CPPFLAGS})
1054         SET(var ${var} ${PTHREADS_INCLUDES})
1055         SET(var ${var} ${${amname}_CPPFLAGS})
1056         SET(var ${var} ${${amname}_CXXFLAGS})
1057         SET(var ${var} ${${amname}_CFLAGS})
1058         SET(flags)
1059         FOREACH(f ${var})
1060         SET(flags "${flags} ${f}")
1061         ENDFOREACH(f ${var})
1062         SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1063         ''')
1064         return
1065
1066     def addLibTarget(self, key, newlines):
1067         newlines.append(r'''
1068         FOREACH(amname ${%s})
1069         '''%(key))
1070         # --
1071         # Replace .la by _la ...
1072         # --
1073         newlines.append(r'''
1074         STRING(REPLACE .la _la amname ${amname})
1075         ''')
1076         # --
1077         # Remove the _la for the cmake name
1078         # --
1079         newlines.append(r'''
1080         STRING(LENGTH ${amname} len)
1081         MATH(EXPR newlen "${len}-3")
1082         STRING(SUBSTRING ${amname} 0 ${newlen} name)
1083         ''')
1084         # --
1085         # Does the target begins with lib ??
1086         # If yes, remove lib at beginning for cmake name
1087         # --
1088         newlines.append(r'''
1089         STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1090         IF(BEGIN_WITH_lib)
1091         STRING(LENGTH ${name} len)
1092         MATH(EXPR newlen "${len}-3")
1093         STRING(SUBSTRING ${name} 3 ${newlen} name)
1094         ENDIF(BEGIN_WITH_lib)
1095         ''')
1096         # --
1097         # Does the target is an idl library
1098         # --
1099         newlines.append(r'''
1100         STRING(REGEX MATCH "IDL" ISIDL ${name})
1101         ''')
1102         # --
1103         # Set the type of the library
1104         # --
1105         newlines.append(r'''
1106         IF(ISIDL)
1107         IF(WINDOWS)
1108         SET(type STATIC)
1109         ELSE(WINDOWS)
1110         SET(type SHARED)
1111         ENDIF(WINDOWS)
1112         ELSE(ISIDL)
1113         SET(type SHARED)
1114         ENDIF(ISIDL)
1115         ''')
1116         # --
1117         # Set sources for the library
1118         # --
1119         newlines.append(r'''
1120         SET(srcs)
1121         FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1122         GET_FILENAME_COMPONENT(ext ${src} EXT)
1123         IF(ext STREQUAL .f)
1124         SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1125         STRING(REPLACE ".f" ".o" src ${src})
1126         SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1127         SET(output ${src})
1128         IF(WINDOWS)
1129         SET(F77 g77)
1130         ELSE(WINDOWS)
1131         SET(F77 gfortran)
1132         ENDIF(WINDOWS)
1133         ADD_CUSTOM_COMMAND(
1134         OUTPUT ${output}
1135         COMMAND ${F77} -c -o ${output} ${input}
1136         MAIN_DEPENDENCY ${input}
1137         )
1138         ENDIF(ext STREQUAL .f)
1139         SET(srcs ${srcs} ${src})
1140         ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1141         SET(build_srcs)
1142         FOREACH(f ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1143         GET_FILENAME_COMPONENT(ext ${f} EXT)
1144         IF(ext STREQUAL .py)
1145         ELSE(ext STREQUAL .py)
1146         SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1147         ENDIF(ext STREQUAL .py)
1148         ENDFOREACH(f ${nodist_${amname}_SOURCES})
1149         SET(srcs ${build_srcs} ${srcs})
1150         ''')
1151         # --
1152         # Add the library to cmake
1153         # --
1154         newlines.append(r'''
1155         ADD_LIBRARY(${name} ${type} ${srcs})
1156         ''')
1157         # --
1158         # The compilation flags
1159         # --
1160         self.setCompilationFlags(key, newlines)
1161         # --
1162         newlines.append(r'''
1163         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION 0.0.0 SOVERSION 0)
1164         FOREACH(lib medC med)
1165         IF(lib STREQUAL ${name})
1166         SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION 1.1.5 SOVERSION 1)
1167         ENDIF(lib STREQUAL ${name})
1168         ENDFOREACH(lib medC med)
1169         ''')
1170         # --
1171         from os.path import basename
1172         upper_name = basename(self.root).upper()
1173         # --
1174         if upper_name in ["2.1.X", "2.3.1"]:
1175             upper_name = "D_" + upper_name
1176             pass
1177         # --
1178         newlines.append(r'''
1179         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL %s_EXPORTS)
1180         '''%(upper_name))
1181         newlines.append(r'''
1182         IF(name STREQUAL SalomeLauncher)
1183         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL SALOME%s_EXPORTS)
1184         ENDIF(name STREQUAL SalomeLauncher)
1185         '''%(upper_name))
1186         newlines.append(r'''
1187         IF(name STREQUAL SalomeResourcesManager)
1188         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL SALOME%s_EXPORTS)
1189         ENDIF(name STREQUAL SalomeResourcesManager)
1190         '''%(upper_name))
1191         newlines.append(r'''
1192         IF(name STREQUAL GEOMObject)
1193         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL GEOM_%s_EXPORTS)
1194         ENDIF(name STREQUAL GEOMObject)
1195         '''%(upper_name))
1196         newlines.append(r'''
1197         IF(name STREQUAL medC)
1198         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDC_DLL_EXPORTS)
1199         ENDIF(name STREQUAL medC)
1200         ''')
1201         newlines.append(r'''
1202         IF(name STREQUAL med)
1203         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MED_DLL_EXPORTS)
1204         ENDIF(name STREQUAL med)
1205         ''')
1206         newlines.append(r'''
1207         IF(name STREQUAL medimport)
1208         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDIMPORT_DLL_EXPORTS)
1209         ENDIF(name STREQUAL medimport)
1210         ''')
1211         newlines.append(r'''
1212         IF(name STREQUAL medimportcxx)
1213         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDIMPORTCXX_DLL_EXPORTS)
1214         ENDIF(name STREQUAL medimportcxx)
1215         ''')
1216         newlines.append(r'''
1217         IF(name STREQUAL MEDWrapperBase)
1218         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDWRAPPER_BASE_EXPORTS)
1219         ENDIF(name STREQUAL MEDWrapperBase)
1220         ''')
1221         newlines.append(r'''
1222         IF(name STREQUAL MEDWrapper_V2_1)
1223         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDWRAPPER_V2_1_EXPORTS)
1224         ENDIF(name STREQUAL MEDWrapper_V2_1)
1225         ''')
1226         newlines.append(r'''
1227         IF(name STREQUAL med_V2_1)
1228         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDWRAPPER_V2_1_CORE_EXPORTS)
1229         ENDIF(name STREQUAL med_V2_1)
1230         ''')
1231         newlines.append(r'''
1232         IF(name STREQUAL MEDWrapper_V2_2)
1233         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDWRAPPER_V2_2_EXPORTS)
1234         ENDIF(name STREQUAL MEDWrapper_V2_2)
1235         ''')
1236         newlines.append(r'''
1237         IF(name STREQUAL MEDWrapper)
1238         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEDWRAPPER_FACTORY_EXPORTS)
1239         ENDIF(name STREQUAL MEDWrapper)
1240         ''')
1241         newlines.append(r'''
1242         IF(name STREQUAL interpkernel)
1243         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL INTERPKERNEL_EXPORTS)
1244         ENDIF(name STREQUAL interpkernel)
1245         ''')
1246         newlines.append(r'''
1247         IF(name STREQUAL SMESHControls)
1248         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL SMESHCONTROLS_EXPORTS)
1249         ENDIF(name STREQUAL SMESHControls)
1250         ''')
1251         newlines.append(r'''
1252         IF(name STREQUAL MeshDriver)
1253         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MESHDRIVER_EXPORTS)
1254         ENDIF(name STREQUAL MeshDriver)
1255         ''')
1256         newlines.append(r'''
1257         IF(name STREQUAL MeshDriverMED)
1258         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MESHDRIVERMED_EXPORTS)
1259         ENDIF(name STREQUAL MeshDriverMED)
1260         ''')
1261         newlines.append(r'''
1262         IF(name STREQUAL MeshDriverDAT)
1263         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MESHDRIVERDAT_EXPORTS)
1264         ENDIF(name STREQUAL MeshDriverDAT)
1265         ''')
1266         newlines.append(r'''
1267         IF(name STREQUAL MeshDriverUNV)
1268         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MESHDRIVERUNV_EXPORTS)
1269         ENDIF(name STREQUAL MeshDriverUNV)
1270         ''')
1271         newlines.append(r'''
1272         IF(name STREQUAL MeshDriverSTL)
1273         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MESHDRIVERSTL_EXPORTS)
1274         ENDIF(name STREQUAL MeshDriverSTL)
1275         ''')
1276         newlines.append(r'''
1277         IF(name STREQUAL MEFISTO2D)
1278         SET_TARGET_PROPERTIES(${name} PROPERTIES DEFINE_SYMBOL MEFISTO2D_EXPORTS)
1279         ENDIF(name STREQUAL MEFISTO2D)
1280         ''')
1281         # --
1282         self.setLibAdd(key, newlines)
1283         # --
1284         if 1: # key != "noinst_LTLIBRARIES":
1285             if self.module == "medfile":
1286                 newlines.append(r'''
1287                 SET(DEST lib)
1288                 ''')
1289             else:
1290                 newlines.append(r'''
1291                 SET(DEST lib/salome)
1292                 ''')
1293                 pass
1294             newlines.append(r'''
1295             IF(BEGIN_WITH_lib)
1296             INSTALL(TARGETS ${name} DESTINATION ${DEST})
1297             ''')
1298             if self.module == "geom":
1299                 newlines.append(r'''
1300                 IF(WINDOWS)
1301                 STRING(REGEX MATCH "Export" ISExport ${name})
1302                 IF(ISExport)
1303                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1304                 ENDIF(ISExport)
1305                 STRING(REGEX MATCH "Import" ISImport ${name})
1306                 IF(ISImport)
1307                 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1308                 ENDIF(ISImport)
1309                 ENDIF(WINDOWS)
1310                 ''')
1311                 pass
1312             newlines.append(r'''
1313             IF(name STREQUAL SalomePyQt)
1314             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1315             ENDIF(name STREQUAL SalomePyQt)
1316             ELSE(BEGIN_WITH_lib)
1317             IF(WINDOWS)
1318             INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1319             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)
1320             ELSE(WINDOWS)
1321             GET_TARGET_PROPERTY(version ${name} VERSION)
1322             GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1323             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1324             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1325             INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1326             ENDIF(WINDOWS)
1327             ENDIF(BEGIN_WITH_lib)
1328             ''')
1329             pass
1330         # --
1331         newlines.append(r'''
1332         ENDFOREACH(amname ${%s})
1333         '''%(key))
1334         # --
1335         return
1336
1337     def addBinTarget(self, key, newlines):
1338         # --
1339         newlines.append(r'''
1340         FOREACH(amname ${bin_PROGRAMS})
1341         ''')
1342         # --
1343         newlines.append(r'''
1344         SET(name "${amname}_exe")
1345         SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1346         LIST(LENGTH srcs nb)
1347         IF(nb)
1348         ADD_EXECUTABLE(${name} ${srcs})
1349         ''')
1350         # --
1351         self.setCompilationFlags(key, newlines)
1352         # --
1353         self.setLibAdd(key, newlines)
1354         # --
1355         if self.module == "medfile":
1356             newlines.append(r'''
1357             SET(DEST bin)
1358             ''')
1359         else:
1360             newlines.append(r'''
1361             SET(DEST bin/salome)
1362             ''')
1363             pass
1364         # --
1365         newlines.append(r'''
1366         IF(WINDOWS)
1367         INSTALL(TARGETS ${name} DESTINATION ${DEST})
1368         INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1369         INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1370         ELSE(WINDOWS)
1371         SET(PERMS)
1372         SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1373         SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1374         SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1375         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1376         ENDIF(WINDOWS)
1377         ''')
1378         # --
1379         newlines.append(r'''
1380         ENDIF(nb)
1381         ''')
1382         # --
1383         newlines.append(r'''
1384         ENDFOREACH(amname ${bin_PROGRAMS})
1385         ''')
1386         # --
1387         return
1388
1389     def addInstallTarget(self, key, destination, newlines):
1390         newlines.append(r"FOREACH(f ${%s})"%(key))
1391         newlines.append(r'''
1392         SET(DEST %s)
1393         '''%(destination))
1394         newlines.append(r'''
1395         STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1396         IF(test_SALOMEconfig.h.in)
1397         INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1398         ELSE(test_SALOMEconfig.h.in)
1399         SET(dummy dummy-NOTFOUND)
1400         MARK_AS_ADVANCED(dummy)
1401         # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1402         FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1403         IF(dummy)
1404         ''')
1405         if key in ['dist_salomescript_SCRIPTS']:
1406             newlines.append(r'''
1407             SET(PERMS)
1408             SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1409             SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1410             SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1411             INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1412             ''')
1413         else:
1414             newlines.append(r'''
1415             INSTALL(FILES ${f} DESTINATION ${DEST})
1416             ''')
1417             pass
1418         newlines.append(r'''
1419         ELSE(dummy)
1420         GET_FILENAME_COMPONENT(ext ${f} EXT)
1421         IF(ext STREQUAL .qm)
1422         STRING(REGEX REPLACE .qm .ts input ${f})
1423         ''')
1424         if self.module in ["kernel", "gui"]:
1425             newlines.append(r'''
1426             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1427             ''')
1428         else:
1429             newlines.append(r'''
1430             SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1431             ''')
1432             pass
1433         newlines.append(r'''
1434         SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1435         # ADD_CUSTOM_COMMAND(
1436         # OUTPUT ${output}
1437         # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1438         # MAIN_DEPENDENCY ${input}
1439         # )
1440         EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1441         ENDIF(ext STREQUAL .qm)
1442         INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1443         ENDIF(dummy)
1444         ENDIF(test_SALOMEconfig.h.in)
1445         ''')
1446         newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1447         return
1448
1449     def writeListsFile(self):
1450         f = open(self.listsFile, "w")
1451         f.write(self.content)
1452         f.close()
1453         return
1454
1455     pass
1456
1457 def convertAmFile(the_root, root, dirs, files, f, module):
1458     cmake = CMakeFile(the_root, root, dirs, files, f, module)
1459     cmake.writeListsFile()
1460     return
1461
1462 def usage(exit_status):
1463     from sys import exit
1464     from sys import argv
1465     print "Usage: %s --module"%(argv[0])
1466     exit(exit_status)
1467     return
1468
1469 if __name__ == "__main__":
1470     #
1471     from sys import argv
1472     if len(argv) != 2:
1473         usage(1)
1474         pass
1475     #
1476     module = argv[1]
1477     if module.find('--') != 0:
1478         usage(1)
1479         pass
1480     module = module[2:]
1481     if len(module) == 0:
1482         usage(1)
1483         pass
1484     #
1485     from os import getcwd
1486     the_root = getcwd()
1487     #
1488     from os import walk
1489     for root, dirs, files in walk(the_root):
1490         from os.path import basename
1491         if basename(root) == "CVS": continue
1492         for f in files:
1493             from os.path import basename
1494             if basename(f) == "Makefile.am":
1495                 convertAmFile(the_root, root, dirs, files, f, module)
1496                 pass
1497             pass
1498         pass
1499     #
1500     pass