1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
24 # A set of regular expressions used ...
27 p_multiline = re.compile(r"""
33 p_dollar = re.compile(r"""
35 (?P<val> # open the group val
36 [^()]* # the group contain 0 or more non ) characters
41 p_arobas = re.compile(r"""
43 (?P<val> # open the group val
44 [^@]* # the group contain 0 or more non @ characters
49 p_if = re.compile(r"""
50 ^ # beginning of the string
54 (?P<val> # open the group val
55 .+ # the group contain 1 or more non space characters
59 p_else = re.compile(r"""
60 ^ # beginning of the line
66 p_endif = re.compile(r"""
67 ^ # beginning of the line
73 p_attribution = re.compile(r"""
74 ^ # beginning of the line
75 (?P<spaces> # open the group spaces
78 (?P<key> # open the group key
79 \w+ # the group contain 1 or more alphanumeric characters
82 (?P<method> # open the group method
86 (?P<value> # open the group value
87 .* # 0 or more any characters
93 class CMakeFile(object):
95 def __init__(self, the_root, root, dirs, files, f, module):
97 self.the_root = the_root
103 from os.path import join
104 self.amFile = join(root, f)
105 self.listsFile = join(root, "CMakeLists.txt")
114 # Read the Makefile.am file
117 stream = open(amFile)
118 content = stream.read()
122 # Replace the composed lines separated by "\\n" by an unique line
124 content = p_multiline.sub(r' ', content)
127 # Compatibility netgen plugin
129 content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
132 # Compatibility VTK 6.0
134 content = content.replace("VTK_LIBS", "VTK_LIBRARIES")
209 "vtkGraphicsPythonD",
218 "LifeCycleCORBATest",
225 "SalomeCommunication",
228 "SalomeDSCContainer",
230 "SalomeDSCSupervBasic",
240 "SalomeLifeCycleCORBA",
242 "SALOMELocalTraceTest",
243 "SalomeLoggerServer",
244 "SalomeMPIContainer",
245 "SalomeNotification",
247 "SalomeResourcesManager",
248 "SalomeTestComponentEngine",
249 "SalomeTestMPIComponentEngine",
250 "SALOMETraceCollectorTest",
253 "with_loggerTraceCollector",
254 "SalomeKernelHelpers",
279 "SalomePyQtGUILight",
317 "GEOMFiltersSelection",
351 "medcouplingremapper",
366 "paramedcouplingcorba",
375 "GeomSelectionTools",
389 "SMESHFiltersSelection",
398 full_list = cas_list + vtk_list
399 full_list += kernel_list + gui_list
400 full_list += geom_list + med_list + smesh_list
402 # E.A. : sort by len before substitution ...
403 # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
404 # And you understand ...
406 full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
408 for key in full_list:
409 content = content.replace("-l%s"%(key), "${%s}"%(key))
414 # Split content in lines to treat each one separately
416 lines = content.split('\n')
419 # newlines contains the lines of the future CMakeLists.txt file
424 # opened_ifs is used to deals with nested conditionnals
429 # the __thedict__ dictionnary contains key, val
430 # of the Makefile.am file
432 self.__thedict__ = {}
435 # Initialize file ... mainly includes other cmake files
437 self.initialize(newlines)
440 # Do the job for each line
443 self.treatLine(line, newlines, opened_ifs)
447 # Finalize file ... it is in here the cmake job is done
449 self.finalize(newlines)
452 # Concatenate newlines into content
454 content = '\n'.join(newlines)
457 # Add a CR at end if necessary
459 lines = content.split('\n')
460 # lines = [ l.strip() for l in lines ]
461 if len(lines[-1]) != 0:
464 content = '\n'.join(lines)
467 self.content = "# ---------------------------------------------------------------------\n"
468 self.content += "# This file was automatically generated by am2cmake (erwan.adam@cea.fr)\n"
469 self.content += "# ---------------------------------------------------------------------\n"
470 self.content += content
475 def initialize(self, newlines):
476 if self.root == self.the_root:
479 CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
480 IF(COMMAND cmake_policy)
481 cmake_policy(SET CMP0003 NEW)
482 ENDIF(COMMAND cmake_policy)
491 """%(self.module.upper()))
493 if self.module == "netgen":
495 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindPLATFORM.cmake)
496 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindCAS.cmake)
499 if self.module == "kernel":
501 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
502 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
503 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
504 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
505 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
506 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
507 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
508 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
509 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
510 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
511 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
512 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
513 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
517 if self.module == "med":
519 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
521 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
522 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
523 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
524 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
525 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
526 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
527 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
528 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
529 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
530 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
531 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
532 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
533 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
534 ELSE(KERNEL_ROOT_DIR)
535 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
536 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
537 ENDIF(KERNEL_ROOT_DIR)
541 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
542 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPLATFORM.cmake)
543 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPYTHON.cmake)
544 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindOMNIORB.cmake)
545 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPTHREADS.cmake)
546 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindMPI.cmake)
547 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindHDF5.cmake)
548 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindBOOST.cmake)
549 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindLIBXML2.cmake)
550 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindSWIG.cmake)
551 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
552 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindDOXYGEN.cmake)
553 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/SalomeMacros.cmake)
554 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
555 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindKERNEL.cmake)
558 if self.module == "gui":
560 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
561 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
562 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
563 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
564 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
565 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
569 SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
571 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindCAS.cmake)
572 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQT4.cmake)
573 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindOPENGL.cmake)
574 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindVTK.cmake)
575 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQWT.cmake)
576 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindSIPPYQT.cmake)
577 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindGUI.cmake)
580 if self.module == "med":
581 #METIS must be after PARMETIS to prevent to activate METIS if PARMETIS already exists
583 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindPARMETIS.cmake)
584 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMETIS.cmake)
585 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSCOTCH.cmake)
586 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSPLITTER.cmake)
587 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindRENUMBER.cmake)
588 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
590 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
594 if self.module == "smesh":
596 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
597 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
598 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQWT.cmake)
599 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
600 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/SalomeMacros.cmake)
602 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindSalomeMED.cmake)
603 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
606 if self.module == "geom":
608 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
612 if self.module == "netgenplugin":
614 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
615 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
616 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
617 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
618 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
619 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
620 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
623 if self.module == "blsurfplugin":
625 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
626 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
627 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
628 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
629 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
630 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
631 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCADSURF.cmake)
634 if self.module in ["ghs3dplugin", "hexoticplugin"]:
636 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
637 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
638 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
639 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
640 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
641 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
644 if self.module == "ghs3dprlplugin":
646 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
647 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
648 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
649 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
650 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
651 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
652 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
655 if self.module == "visu":
657 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
658 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
661 if self.module == "yacs":
663 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
664 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
665 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
667 SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SECURE_SCL=0)
668 SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_SECURE_SCL_THROWS=0)
669 SET(PLATFORM_CPPFLAGS ${PLATFORM_CPPFLAGS} -D_HAS_ITERATOR_DEBUGGING=0) # To avoid runtime error during checking iterators
672 if self.module == "jobmanager":
674 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
677 if self.module == "hxx2salome":
679 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
680 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
681 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
691 if self.module not in ['med']:
695 MESSAGE(STATUS "cppunit is disabled.")
700 if self.module == "kernel":
704 SET(CALCIUM_IDL_INT_F77 long)
705 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
708 elif self.module == "gui":
710 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
711 SET(ENABLE_VTKVIEWER ON)
712 SET(ENABLE_SALOMEOBJECT ON)
713 SET(ENABLE_OCCVIEWER ON)
714 SET(ENABLE_GLVIEWER ON)
715 SET(ENABLE_PLOT2DVIEWER ON)
716 SET(ENABLE_PYCONSOLE ON)
717 SET(ENABLE_SUPERVGRAPHVIEWER ON)
718 SET(ENABLE_QXGRAPHVIEWER ON)
721 elif self.module == "jobmanager":
728 elif self.module == "geom":
731 SET(GEOM_ENABLE_GUI ON)
735 elif self.module == "medfile":
737 SET(MED_NUM_MAJEUR 3)
738 SET(MED_NUM_MINEUR 0)
739 SET(MED_NUM_RELEASE 3)
742 SET(FLIBS -lgfortranbegin -lgfortran)
746 elif self.module == "med":
749 SET(MED_ENABLE_KERNEL ON)
751 SET(MED_ENABLE_SPLITTER ON)
753 ENDIF(KERNEL_ROOT_DIR)
755 SET(MED_ENABLE_GUI ON)
759 elif self.module == "smesh":
762 SET(SMESH_ENABLE_GUI ON)
766 elif self.module == "netgen":
768 SET(OCCFLAGS ${CAS_CPPFLAGS})
769 SET(OCCLIBS ${CAS_LDPATH})
770 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
771 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
772 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
775 elif self.module == "netgenplugin":
778 SET(NETGENPLUGIN_ENABLE_GUI ON)
782 elif self.module == "blsurfplugin":
785 SET(BLSURFPLUGIN_ENABLE_GUI ON)
789 elif self.module == "ghs3dplugin":
792 SET(GHS3DPLUGIN_ENABLE_GUI ON)
796 elif self.module == "hexoticplugin":
799 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
803 elif self.module == "ghs3dprlplugin":
806 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
810 elif self.module == "yacs":
812 SET(SALOME_KERNEL ON)
820 set(SHORT_VERSION 7.4)
821 set(XVERSION 0x070400)
827 SET(VERSION_INFO 0.0.0)
828 SET(SOVERSION_INFO 0)
831 SET(AM_CPPFLAGS -I${CMAKE_BINARY_DIR} )
832 SET(AM_CXXFLAGS -I${CMAKE_BINARY_DIR})
834 SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
835 SET(salomepythondir ${pythondir}/salome)
836 SET(salomepypkgdir ${salomepythondir}/salome)
839 if self.module == "smesh" and self.root[-len('SMESH_PY'):] == 'SMESH_PY':
841 SET(smeshpypkgdir ${salomepythondir}/salome/smesh)
844 if self.module == "netgen":
846 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_CURRENT_SOURCE_DIR})
848 elif self.module == "kernel":
850 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
851 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
854 if self.module not in ["yacs"]:
857 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
858 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
859 ENDIF(KERNEL_ROOT_DIR)
862 if self.module == "gui":
865 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
866 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
867 ENDIF(KERNEL_ROOT_DIR)
870 if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin", "hexoticplugin"]:
872 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
873 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
876 if self.module == "ghs3dplugin":
877 # TODO: Auto-detect TetGen-GHS3D version automatically
879 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DGHS3D_VERSION=42)
880 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DGHS3D_VERSION=42)
883 if self.module == "hxx2salome":
885 if self.the_root[-len(key):] != key:
886 msg = "Source dir must finished with %s !"%(key)
888 hxxmodule = self.the_root[:-len(key)]
889 from os.path import basename
890 hxxmodule = basename(hxxmodule)
891 hxxmodule = hxxmodule.lower()
892 self.hxxmodule = hxxmodule
894 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
895 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
896 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
897 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
898 '''%(hxxmodule.upper()))
904 def treatLine(self, line, newlines, opened_ifs):
907 # Print the comment above the line itself
909 if line.find('#') >= 0:
910 fields = line.split('#')
912 comment = '#'.join([''] + fields[1:])
913 newlines.append(comment)
919 # If the line begins with 'include ', just comment it
921 if line.find("include ") == 0:
922 if line.find("include $(top_srcdir)/config/automake.common") == 0:
924 "MAINTAINERCLEANFILES = Makefile.in",
925 "AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
926 "AM_FFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
927 "AM_FCFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
928 "AM_CPPFLAGS+=@HDF5_CPPFLAGS@",
929 "AM_LDFLAGS=@HDF5_LDFLAGS@",
931 self.treatLine(l, newlines, opened_ifs)
935 newlines.append("# " + line)
940 # If the line begins with '-include', just comment it
942 if line.find("-include") == 0:
943 newlines.append("# " + line)
947 # If the line is a definition of a make rule, just comment it
949 if line.count(':') == 1:
950 newlines.append("# " + line)
954 # A particuliar case where there are two ":" on the same line
956 if line.find('install-exec-local:') == 0:
957 newlines.append("# " + line)
961 # If the line begin by a tabulation, consider it's a makefile command and comment it
963 if line.find("\t") == 0:
964 newlines.append("# " + line)
969 key = "-version-info"
970 if line.find(key) >= 0:
972 before = line.split(key)[0]
973 after = line[len(before)+len(key):]
976 version_info = after.split()[0]
977 line = line.replace(key+sep+version_info, "")
979 version_info = version_info.replace(':', '.')
980 soversion_info = version_info.split('.')[0]
981 newlines.append("SET(VERSION_INFO " + version_info + ")")
982 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
987 # Replace the $(TOTO) by ${TOTO}
988 # Replace the @TOTO@ by ${TOTO}
990 # VSR 15.04.2013 - process nesting substitutions properly, e.g. $(aaa$(bbb))
991 #line = p_dollar.sub(r"${\1}", line)
992 m_dollar = p_dollar.search(line)
994 line = p_dollar.sub(r"${\1}", line)
995 m_dollar = p_dollar.search(line)
997 line = p_arobas.sub(r"${\1}", line)
1000 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
1001 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
1002 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
1003 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
1004 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
1007 # Check if the line is a 'if' condition
1008 # If yes, replace it by a cmake grammar
1010 match = p_if.match(line)
1012 theif = match.group("val")
1014 theif = "NOT " + theif[1:]
1016 line = p_if.sub(r"IF(%s)"%(theif), line)
1017 opened_ifs.append(theif)
1018 newlines.append(line)
1022 # Check if the line is a 'else' condition
1023 # If yes, replace it by a cmake grammar
1025 match = p_else.match(line)
1027 line = "ELSE(%s)"%(opened_ifs[-1])
1028 newlines.append(line)
1032 # Check if the line is a 'endif' condition
1033 # If yes, replace it by a cmake grammar
1035 match = p_endif.match(line)
1037 line = "ENDIF(%s)"%(opened_ifs[-1])
1038 opened_ifs[-1:] = []
1039 newlines.append(line)
1043 # Check if the line is an attribution '=' or '+='
1045 match = p_attribution.match(line)
1047 self.treatAttribution(match, newlines)
1051 newlines.append(line)
1056 def treatAttribution(self, match, newlines):
1058 spaces = match.group("spaces")
1059 key = match.group("key")
1060 method = match.group("method")
1061 value = match.group("value")
1062 # print [spaces, key, method, value]
1065 # Open cmake SET command
1067 newlines.append(spaces + "SET(" + key)
1070 # If method is '+=', put the previous definition as first value
1073 newlines.append("%s ${%s}"%(spaces, key))
1077 fields = value.split()
1079 for i in range(len(fields)):
1080 newlines.append("%s %s"%(spaces, fields[i]))
1086 # The try: except KeyError is here if the +=
1087 # is an error which occurs in salome ...
1090 self.__thedict__[key] += fields[:]
1092 self.__thedict__[key] = fields[:]
1096 self.__thedict__[key] = fields[:]
1100 # Close cmake SET command
1103 newlines.append("%s)"%(spaces))
1107 def finalize(self, newlines):
1110 # Convert the .in files in build dir
1113 if self.module == "hexoticplugin" :
1114 upmod = "HexoticPLUGIN"
1116 upmod = self.module.upper()
1120 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1121 newlines.append(r'''
1129 ${CMAKE_CURRENT_SOURCE_DIR}
1132 ${CMAKE_CURRENT_BINARY_DIR}
1135 ${CMAKE_INSTALL_PREFIX}/share
1138 ${datadir}/doc/salome
1141 self.files.append("static/header.html.in")
1142 elif self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc') or mod in ['kernel', 'gui', 'geom', 'med', 'smesh', 'visu', 'blsurfplugin'] and self.root[-len('tui'):] == 'tui' or operator.contains(self.root, 'doc') and mod in ['pyhello', 'yacs']:
1143 newlines.append(r'''
1151 ${CMAKE_CURRENT_SOURCE_DIR}
1154 ${CMAKE_CURRENT_BINARY_DIR}
1157 ${CMAKE_INSTALL_PREFIX}/share
1160 ${datadir}/doc/salome
1164 self.files.append("sources/header.html.in")
1166 self.files.append("static/header.html.in")
1167 if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1168 self.files.append("static/header_py.html.in")
1170 if self.module == "yacs":
1172 if self.root[-len(key):] == key:
1173 self.files.append("resources/YACSCatalog.xml.in")
1174 self.files.append("resources/SalomeApp.xml.in")
1178 if self.module == "jobmanager":
1180 if self.root[-len(key):] == key:
1181 self.files.append("resources/SalomeApp.xml.in")
1184 for f in self.files:
1186 if f == "sstream.in":
1188 if f in ["runContainer.in", "stopContainer.in"]:
1189 if self.module == "med":
1190 if self.root[-3:] == "csh":
1194 if f == "SALOMEconfig.ref.in":
1195 out = "SALOMEconfig.h"
1199 newlines.append(r'''
1200 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1202 newlines.append(r'''
1203 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1205 newlines.append(r'''
1206 MESSAGE(STATUS "Creation of ${output}")
1207 CONFIGURE_FILE(${input} ${output})
1213 # add commands for generating of user's documentation
1215 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1216 doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1217 doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1218 head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1220 prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1222 prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1223 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1225 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1226 input = "Doxyfile_med_user"
1228 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1230 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1231 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1233 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1234 )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1236 if mod in ['geom', 'smesh', 'visu', 'netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin','ghs3dprlplugin','pyhello'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc') or mod in ['pyhello'] and operator.contains(self.root, 'doc'):
1237 ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1241 input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1242 newlines.append(r"""
1244 STRING(REPLACE "/" "\\" f "%s")
1248 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1249 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1250 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1251 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1252 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''', r'''%s''', ignore=shutil.ignore_patterns(%s)); shutil.copy(r'''%s''', r'''%s''')"
1254 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1255 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, upmod, tmp, input, tmp, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1256 newlines.append(r"""ADD_DEPENDENCIES(usr_docs html_docs)""")
1260 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1261 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_py"
1262 extra_doc_dir = "%spy_doc"%(mod)
1263 elif mod not in ['pyhello']:
1264 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_idl"
1266 extra_doc_dir = "%sgen_doc"%(mod)
1267 inst_head_command = ""
1268 if extra_doc_dir != "":
1269 inst_head_command = "; shutil.copy(r'''%s''', r'''${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s/%s''')"%(head_source, upmod, extra_doc_dir)
1270 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs %s
1271 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1272 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''',True); shutil.copytree(r'''${CMAKE_CURRENT_BINARY_DIR}''',r'''%s''', ignore=shutil.ignore_patterns(%s)); shutil.copy(r'''%s''',r'''%s''')%s"
1274 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1275 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination, inst_head_command))
1276 elif mod in ['yacs', 'jobmanager'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1277 from sys import platform
1279 if platform == "win32":
1281 newlines.append(r"""
1282 ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1283 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1284 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1285 elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1286 from sys import platform
1290 if platform == "win32":
1294 cmd = "STRING(REPLACE \"/\" \"\\\\\" SCR"
1299 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1300 scr = self.writeEnvScript(upmod)
1301 newlines.append(r"""
1303 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1304 ADD_CUSTOM_TARGET(html_docs %s ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s && ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc/docutils -b html ${ALLSPHINXOPTS} html
1305 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1306 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(cmd, scr, ext, prf, ext, params, doc_gui_destination, doc_gui_destination))
1312 # add commands for generating of developer's documentation
1315 upmod = self.module.upper()
1316 if ( mod in ['kernel', 'gui', 'med', 'smesh', 'visu', 'blsurfplugin'] and self.root[-len('tui'):] == 'tui' ) or ( mod in ['yacs'] and self.root[-len('doc'):] == 'doc' ):
1318 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1319 COMMAND ${DOXYGEN_EXECUTABLE}
1320 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')" """
1323 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1325 tmp1= r"""\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/visuscreen.png''', r'''%s''')" """%(doc_tui_destination)
1326 elif mod == 'smesh':
1327 tmp1= """\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s''')" """%(doc_tui_destination)
1331 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/htmldev"
1333 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1334 inst_head_command=""
1335 inst_head_command = "; shutil.copy(r'''%s''', r'''%s''')"%(head_source, doc_tui_destination)
1336 newlines.append(tmp + """
1337 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s''')%s" """%(doc_tui_destination, doc_source, doc_tui_destination, inst_head_command) + tmp1 + """
1339 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1341 if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1343 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1344 newlines.append(r"""
1346 STRING(REPLACE "/" "\\" f "%s")
1350 ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%s.py
1351 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1352 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/%s.py''')"
1353 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s'''); shutil.copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/geomscreen.png''', r'''%s''')"
1355 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1356 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, upmod, tmp, tmp, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination, doc_tui_destination))
1359 # convert the SUBDIRS in cmake grammar
1361 if 1: # self.__thedict__.has_key("SUBDIRS"):
1362 newlines.append(r'''
1363 FOREACH(dir ${SUBDIRS})
1364 IF(NOT dir STREQUAL .)
1365 ADD_SUBDIRECTORY(${dir})
1366 ENDIF(NOT dir STREQUAL .)
1367 ENDFOREACH(dir ${SUBDIRS})
1373 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1374 if self.__thedict__.has_key(key):
1375 self.addLibTarget(key, newlines)
1381 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1382 if self.__thedict__.has_key(key):
1383 self.addBinTarget(key, newlines)
1389 if self.__thedict__.has_key("BASEIDL_FILES"):
1390 if not self.__thedict__.has_key("IDL_FILES"):
1391 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1393 SET(IDL_FILES ${BASEIDL_FILES})
1402 if self.__thedict__.has_key(key):
1403 if self.module == "kernel":
1405 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1409 FOREACH(input ${IDL_FILES})
1410 STRING(REGEX REPLACE ".idl" "" base ${input})
1411 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1413 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1414 SET(outputs ${outputs} ${dynsrc})
1415 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1416 SET(outputs ${outputs} ${inc})
1417 IF(input STREQUAL Calcium_Ports.idl)
1418 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1419 ELSE(input STREQUAL Calcium_Ports.idl)
1420 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1421 ENDIF(input STREQUAL Calcium_Ports.idl)
1422 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1423 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1425 SET(flags -bcxx ${flags})
1429 COMMAND ${OMNIORB_IDL} ${flags} ${input}
1430 MAIN_DEPENDENCY ${input}
1434 install(FILES ${input} DESTINATION idl/salome)
1436 if self.module not in ["pyhello"]:
1438 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1439 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1443 INSTALL(CODE "SET(IDL_FILE ${input})")
1444 INSTALL(CODE "SET(DIR ${salomepythondir})")
1446 INSTALL(CODE "SET(DIR bin/salome)")
1448 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1449 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1452 FOREACH(f ${IDLPYFLAGS})
1453 SET(flags "${flags} ${f}")
1454 ENDFOREACH(f ${IDLPYFLAGS})
1455 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1457 SET(flags "-bpython ${flags}")
1458 ENDIF(NOT ISBPYTHON)
1459 SET(IDLPYFLAGS ${flags})
1460 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1461 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1464 if self.module == "kernel":
1466 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1470 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1471 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_python_from_idl.cmake)
1475 ENDFOREACH(input ${IDL_FILES})
1481 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1482 if self.__thedict__.has_key(key):
1484 SET(SWIG_SOURCES ${%s})
1486 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1492 if self.__thedict__.has_key("SWIG_SOURCES"):
1494 IF(SWIG_SOURCES MATCHES ";")
1495 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1496 ELSE(SWIG_SOURCES MATCHES ";")
1497 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1498 ENDIF(SWIG_SOURCES MATCHES ";")
1500 FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1503 LIST(FIND flags ${f} index)
1504 IF(NOT index EQUAL -1)
1506 ENDIF(NOT index EQUAL -1)
1509 SET(flags ${flags} ${f})
1511 ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1513 OUTPUT ${build_srcs}
1514 COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1515 MAIN_DEPENDENCY ${SWIG_SOURCES}
1522 if self.__thedict__.has_key("BUILT_SOURCES"):
1524 FOREACH(f ${BUILT_SOURCES})
1525 IF(f MATCHES "WRAP.cxx$")
1526 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1527 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1529 OUTPUT ${f} # ${inc}
1530 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1531 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1533 ENDIF(f MATCHES "WRAP.cxx$")
1534 ENDFOREACH(f ${BUILT_SOURCES})
1541 if self.__thedict__.has_key(key):
1543 FOREACH(output ${MOC_FILES})
1545 if self.module in ["jobmanager", "yacs"]:
1547 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1551 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1555 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1556 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1559 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1560 MAIN_DEPENDENCY ${input}
1562 ENDFOREACH(output ${MOC_FILES})
1568 key = "MOC_FILES_HXX"
1569 if self.__thedict__.has_key(key):
1571 FOREACH(output ${MOC_FILES_HXX})
1574 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1577 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1578 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1581 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1582 MAIN_DEPENDENCY ${input}
1584 ENDFOREACH(output ${MOC_FILES_HXX})
1591 if self.__thedict__.has_key(key):
1593 FOREACH(output ${UIC_FILES})
1594 STRING(REPLACE "ui_" "" input ${output})
1595 STRING(REPLACE ".h" ".ui" input ${input})
1596 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1597 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1600 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1601 MAIN_DEPENDENCY ${input}
1603 ENDFOREACH(output ${UIC_FILES})
1610 if self.__thedict__.has_key(key):
1612 FOREACH(output ${PYUIC_FILES})
1613 STRING(REPLACE "_ui.py" ".ui" input ${output})
1614 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1615 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1618 COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1619 MAIN_DEPENDENCY ${input}
1621 ENDFOREACH(output ${PYUIC_FILES})
1622 ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1629 if self.__thedict__.has_key(key):
1631 FOREACH(output ${QRC_FILES})
1632 STRING(REGEX REPLACE "qrc_" "" input ${output})
1633 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1634 STRING(REGEX REPLACE ".qrc" "" name ${input})
1635 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1636 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1639 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1640 MAIN_DEPENDENCY ${input}
1642 ENDFOREACH(output ${QRC_FILES})
1649 if self.__thedict__.has_key(key):
1651 FOREACH(input ${SIP_FILES})
1652 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1654 FOREACH(out ${SIP_SRC})
1655 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1656 ENDFOREACH(out ${SIP_SRC})
1659 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1660 MAIN_DEPENDENCY ${input}
1662 ENDFOREACH(input ${SIP_FILES})
1667 # For GUI/tools/dlgfactory
1669 key = "UIC_FILES_QDIALOG"
1670 if self.__thedict__.has_key(key):
1672 FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1673 STRING(REPLACE "ui_" "" input ${output})
1674 STRING(REPLACE ".hxx" ".ui" input ${input})
1675 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1676 IF (NOT EXISTS ${input_path})
1677 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1678 ENDIF (NOT EXISTS ${input_path})
1681 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1682 MAIN_DEPENDENCY ${input}
1684 ENDFOREACH(output ${UIC_FILES})
1686 FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1687 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1688 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1689 IF (NOT EXISTS ${input_path})
1690 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1691 ENDIF (NOT EXISTS ${input_path})
1694 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1695 MAIN_DEPENDENCY ${input}
1697 ENDFOREACH(output ${MOC_FILES})
1700 OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1701 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1702 DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1706 OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1707 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1708 DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1716 for key in ["TESTS"]:
1717 if self.__thedict__.has_key(key):
1719 SET(UNIT_TEST_PROG ${%s})
1721 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1724 key = "UNIT_TEST_PROG"
1725 if self.__thedict__.has_key(key):
1727 FOREACH(input ${UNIT_TEST_PROG})
1728 GET_FILENAME_COMPONENT(ext ${input} EXT)
1729 IF(ext STREQUAL .py)
1730 SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1731 ELSE(ext STREQUAL .py)
1733 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1735 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1737 ENDIF(ext STREQUAL .py)
1738 ADD_TEST(${input} ${test})
1739 SET(fail_regex "KO")
1740 SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1742 # ADD_TEST(${input}_valgrind valgrind ${test})
1743 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1744 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1746 ENDFOREACH(input ${UNIT_TEST_PROG})
1751 # Treat the install targets
1753 resdir = self.module
1754 if resdir == "hxx2salome":
1755 resdir = self.hxxmodule
1758 "salomeadmux_DATA" : "salome_adm/unix",
1759 "dist_salomeadmux_DATA" : "salome_adm/unix",
1760 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1761 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1762 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1763 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1764 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1765 "salomeinclude_DATA" : "include/salome",
1766 "salomeinclude_HEADERS" : "include/salome",
1767 "nodist_salomeinclude_HEADERS" : "include/salome",
1768 "dist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1769 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1770 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(resdir),
1771 "dist_salomescript_SCRIPTS" : "bin/salome",
1772 "dist_salomescript_DATA" : "bin/salome",
1773 "dist_salomescript_PYTHON" : "bin/salome",
1774 "dist_appliskel_SCRIPTS" : "bin/salome/appliskel",
1775 "dist_appliskel_PYTHON" : "bin/salome/appliskel",
1776 "nodist_salomescript_DATA" : "bin/salome",
1777 "salomepython_PYTHON" : "${salomepythondir}",
1778 "nodist_salomepython_PYTHON" : "${salomepythondir}",
1779 "dist_salomepython_DATA" : "${salomepythondir}",
1780 "sharedpkgpython_PYTHON" : "${salomepythondir}/shared_modules",
1781 "salomepypkg_PYTHON" : "${salomepypkgdir}",
1782 "mypkgpython_PYTHON" : "${mypkgpythondir}",
1783 "stdpkgpython_PYTHON" : "${stdpkgpythondir}",
1784 "nodist_mypkgpython_PYTHON" : "${mypkgpythondir}",
1786 if self.module == "jobmanager":
1787 d["bin_SCRIPTS"] = "bin"
1789 if self.module == "medfile":
1791 "include_HEADERS" : "include",
1792 "nodist_include_HEADERS" : "include",
1793 "bin_SCRIPTS" : "bin",
1794 "doc_DATA" : "${docdir}",
1797 if self.module == "netgen":
1799 "include_HEADERS" : "include",
1800 "noinst_HEADERS" : "share/netgen/include",
1801 "dist_pkgdata_DATA" : "share/netgen",
1802 "dist_doc_DATA" : "share/doc/netgen",
1805 for key, value in d.items():
1806 if self.__thedict__.has_key(key):
1807 self.addInstallTarget(key, value, newlines)
1814 def setLibAdd(self, key, newlines):
1816 newlines.append(r'''
1820 newlines.append(r'''
1823 SET(targets ${targets} MEFISTO2D)
1824 FOREACH(target ${targets})
1825 IF(name STREQUAL ${target})
1826 SET(dir $ENV{F2CHOME})
1827 STRING(REPLACE "\\\\" "/" dir ${dir})
1828 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1829 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1830 ENDIF(name STREQUAL ${target})
1831 ENDFOREACH(target ${targets})
1834 SET(targets ${targets} MEFISTO2D)
1835 FOREACH(target ${targets})
1836 IF(name STREQUAL ${target})
1837 SET(libadd ${libadd} -lf2c)
1838 ENDIF(name STREQUAL ${target})
1839 ENDFOREACH(target ${targets})
1843 newlines.append(r'''
1844 STRING(REPLACE "-module" "" ${amname}_LDFLAGS "${${amname}_LDFLAGS}")
1845 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1846 FOREACH(lib SALOMEBasics SalomeBatch)
1847 IF(name STREQUAL lib)
1848 SET(libs ${libs} ${PTHREAD_LIBS})
1849 ENDIF(name STREQUAL lib)
1850 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1853 newlines.append(r'''
1854 FOREACH(lib ${libs})
1855 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1856 IF(ext STREQUAL .la)
1857 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1858 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1859 ENDIF(ext STREQUAL .la)
1861 SET(vars ${vars} -no-undefined)
1862 SET(vars ${vars} -lvtkWidgets)
1864 SET(vars ${vars} -module)
1865 SET(vars ${vars} -Wl,-E)
1866 SET(vars ${vars} -Xlinker)
1867 SET(vars ${vars} -export-dynamic)
1868 SET(vars ${vars} -lm)
1869 SET(vars ${vars} -lboost_thread)
1870 SET(vars ${vars} -lboost_signals)
1871 SET(vars ${vars} -pthread -lpthread -ldl)
1876 ENDIF(lib STREQUAL v)
1877 ENDFOREACH(v ${vars})
1880 STRING(REGEX MATCH "^-lQt" test ${lib})
1883 SET(libadd ${libadd} ${lib})
1885 ENDFOREACH(lib ${libs})
1886 TARGET_LINK_LIBRARIES(${name} ${libadd})
1889 newlines.append(r'''
1892 SET(targets ${targets} MEFISTO2D)
1893 FOREACH(target ${targets})
1894 IF(name STREQUAL ${target})
1895 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1896 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1897 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1898 ENDIF(name STREQUAL ${target})
1899 ENDFOREACH(target ${targets})
1905 def setCompilationFlags(self, key, newlines):
1906 newlines.append(r'''
1910 SET(targets ${targets} SalomeIDLKernel)
1911 SET(targets ${targets} SalomeDS)
1912 SET(targets ${targets} SALOMEDSTest)
1913 SET(targets ${targets} SALOMEDS_Client_exe)
1914 SET(targets ${targets} SalomeIDLGEOM)
1915 SET(targets ${targets} GEOMEngine)
1916 SET(targets ${targets} MEDEngine)
1917 SET(targets ${targets} SMESHEngine)
1918 SET(targets ${targets} SMESH)
1919 SET(targets ${targets} SalomeIDLSPADDER)
1920 SET(targets ${targets} MeshJobManagerEngine)
1921 SET(targets ${targets} StdMeshersEngine)
1922 SET(targets ${targets} VISUEngineImpl)
1923 FOREACH(target ${targets})
1924 IF(name STREQUAL ${target})
1925 SET(var ${var} -DNOGDI)
1926 ENDIF(name STREQUAL ${target})
1927 ENDFOREACH(target ${targets})
1931 if self.module in ["medfile", "yacs"]:
1932 newlines.append(r'''
1934 SET(var ${var} -DNOGDI)
1939 newlines.append(r'''
1942 SET(targets ${targets} MEFISTO2D)
1943 FOREACH(target ${targets})
1944 IF(name STREQUAL ${target})
1945 SET(dir $ENV{F2CHOME})
1946 STRING(REPLACE "\\\\" "/" dir ${dir})
1947 SET(var ${var} -I${dir})
1948 SET(var ${var} -DF2C_BUILD)
1949 ENDIF(name STREQUAL ${target})
1950 ENDFOREACH(target ${targets})
1954 if self.module in ["geom", "med", "hexoticplugin", "blsurfplugin"]:
1955 newlines.append(r'''
1956 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1957 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1960 newlines.append(r'''
1961 SET(var ${var} ${AM_CPPFLAGS})
1962 SET(var ${var} ${AM_CXXFLAGS})
1965 newlines.append(r'''
1966 IF(type STREQUAL STATIC)
1967 SET(var ${var} -fPIC)
1968 ENDIF(type STREQUAL STATIC)
1971 if self.module == "yacs":
1972 newlines.append(r'''
1973 SET(var ${var} -DYACS_PTHREAD)
1974 SET(var ${var} -DCMAKE_BUILD)
1975 SET(var ${var} -DSALOME_KERNEL)
1976 SET(var ${var} -DDSC_PORTS)
1977 SET(var ${var} -DOMNIORB)
1980 newlines.append(r'''
1981 SET(var ${var} ${PLATFORM_CPPFLAGS})
1982 SET(var ${var} ${PTHREAD_CFLAGS})
1983 SET(var ${var} ${${amname}_CPPFLAGS})
1984 SET(var ${var} ${${amname}_CXXFLAGS})
1985 SET(var ${var} ${${amname}_CFLAGS})
1988 SET(vars ${vars} -include SALOMEconfig.h)
1989 SET(vars ${vars} -ftemplate-depth-32)
1990 SET(vars ${vars} -fPIC)
1991 SET(vars ${vars} -g)
1992 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") # if platform is Windows 64 bit
1993 IF(name STREQUAL _pilot)
1994 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # to avoid error C1128
1995 ENDIF(name STREQUAL _pilot)
1996 ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
2004 ENDFOREACH(v ${vars})
2006 string(REGEX MATCH "^-I" test_include ${f})
2008 string(REGEX REPLACE "^-I" "" include_dir ${f})
2010 if(include_dir STREQUAL /usr/include)
2011 else(include_dir STREQUAL /usr/include)
2012 string(REGEX MATCH "^\\." test_dot ${include_dir})
2014 set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
2016 include_directories(${include_dir})
2017 endif(include_dir STREQUAL /usr/include)
2020 SET(flags "${flags} ${f}")
2023 ENDFOREACH(f ${var})
2024 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2028 def addLibTarget(self, key, newlines):
2029 newlines.append(r'''
2030 FOREACH(amname ${%s})
2033 # Replace .la by _la ...
2035 newlines.append(r'''
2036 STRING(REPLACE .la _la amname ${amname})
2039 # Remove the _la for the cmake name
2041 newlines.append(r'''
2042 STRING(LENGTH ${amname} len)
2043 MATH(EXPR newlen "${len}-3")
2044 STRING(SUBSTRING ${amname} 0 ${newlen} name)
2047 # Does the target begins with lib ??
2048 # If yes, remove lib at beginning for cmake name
2050 newlines.append(r'''
2051 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2053 STRING(LENGTH ${name} len)
2054 MATH(EXPR newlen "${len}-3")
2055 STRING(SUBSTRING ${name} 3 ${newlen} name)
2056 ENDIF(BEGIN_WITH_lib)
2059 # Does the target is an idl library
2061 newlines.append(r'''
2062 STRING(REGEX MATCH "IDL" ISIDL ${name})
2065 # Set the type of the library
2067 newlines.append(r'''
2078 if key == "noinst_LTLIBRARIES":
2079 newlines.append(r'''
2088 # Set sources for the library
2090 newlines.append(r'''
2092 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2093 GET_FILENAME_COMPONENT(ext ${src} EXT)
2095 IF(src STREQUAL trte.f)
2096 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2097 STRING(REPLACE ".f" ".c" src ${src})
2098 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2102 IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2103 SET(cmd valgrind f2c) # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2108 COMMAND ${cmd} ${input}
2109 MAIN_DEPENDENCY ${input}
2111 ELSE(src STREQUAL trte.f)
2112 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2113 STRING(REPLACE ".f" ".o" src ${src})
2114 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2123 COMMAND ${F77} -c -o ${output} ${input}
2124 MAIN_DEPENDENCY ${input}
2126 ENDIF(src STREQUAL trte.f)
2127 ENDIF(ext STREQUAL .f)
2128 SET(srcs ${srcs} ${src})
2129 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2131 newlines.append(r'''
2132 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2134 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2135 SET(srcs ${srcs} ${src})
2138 newlines.append(r'''
2140 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2142 GET_FILENAME_COMPONENT(ext ${f} EXT)
2143 IF(ext STREQUAL .py)
2145 ELSE(ext STREQUAL .py)
2146 SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2147 ENDIF(ext STREQUAL .py)
2150 LIST(FIND build_srcs ${fff} index)
2151 IF(NOT index EQUAL -1)
2153 ENDIF(NOT index EQUAL -1)
2157 SET(build_srcs ${build_srcs} ${fff})
2162 # Add the library to cmake
2164 newlines.append(r'''
2165 ADD_LIBRARY(${name} ${type} ${srcs})
2168 # The compilation flags
2170 self.setCompilationFlags(key, newlines)
2172 newlines.append(r'''
2173 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2176 self.setLibAdd(key, newlines)
2178 if 1: # key != "noinst_LTLIBRARIES":
2179 newlines.append(r'''
2182 newlines.append(r'''
2184 IF(${key} STREQUAL noinst_LTLIBRARIES)
2186 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2188 if self.module == "netgen" :
2189 newlines.append(r'''
2190 IF(${key} STREQUAL noinst_LTLIBRARIES)
2194 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2197 newlines.append(r'''
2200 if self.module in ["medfile", "netgen"]:
2201 newlines.append(r'''
2204 elif key == "libparaview_LTLIBRARIES":
2205 newlines.append(r'''
2206 SET(DEST lib/paraview)
2209 newlines.append(r'''
2210 SET(DEST lib/salome)
2213 newlines.append(r'''
2215 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2217 if self.module == "gui":
2218 newlines.append(r'''
2219 FOREACH(lib SalomePyQt)
2220 IF(name STREQUAL lib)
2222 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2223 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2224 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2225 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2226 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2228 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2230 ENDIF(name STREQUAL lib)
2231 ENDFOREACH(lib SalomePyQt)
2232 FOREACH(lib SalomePy)
2233 IF(name STREQUAL lib)
2235 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2236 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2237 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2238 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2239 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2241 ENDIF(name STREQUAL lib)
2242 ENDFOREACH(lib SalomePy)
2245 if self.module == "geom":
2246 newlines.append(r'''
2248 STRING(REGEX MATCH "Export" ISExport ${name})
2250 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2252 STRING(REGEX MATCH "Import" ISImport ${name})
2254 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2259 newlines.append(r'''
2260 ELSE(BEGIN_WITH_lib)
2262 newlines.append(r'''
2264 INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2265 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2266 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2267 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2268 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2269 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2271 GET_TARGET_PROPERTY(version ${name} VERSION)
2272 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2273 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2274 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2275 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2278 newlines.append(r'''
2279 ENDIF(BEGIN_WITH_lib)
2281 newlines.append(r'''
2286 newlines.append(r'''
2287 ENDFOREACH(amname ${%s})
2292 def addBinTarget(self, key, newlines):
2294 newlines.append(r'''
2295 FOREACH(amname ${%s})
2298 newlines.append(r'''
2301 if key == "check_PROGRAMS":
2302 newlines.append(r'''
2304 STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2311 newlines.append(r'''
2315 newlines.append(r'''
2316 SET(name "${amname}_exe")
2317 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2318 SET(l ${nodist_${amname}_SOURCES})
2320 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2321 SET(srcs ${srcs} ${src})
2323 LIST(LENGTH srcs nb)
2325 ADD_EXECUTABLE(${name} ${srcs})
2328 self.setCompilationFlags(key, newlines)
2330 self.setLibAdd(key, newlines)
2332 if self.module in ["jobmanager", "medfile", "netgen"]:
2333 newlines.append(r'''
2337 newlines.append(r'''
2338 SET(DEST bin/salome)
2342 if key == "bin_PROGRAMS":
2343 newlines.append(r'''
2345 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2346 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2347 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2350 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2351 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2352 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2353 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2358 newlines.append(r'''
2362 newlines.append(r'''
2365 newlines.append(r'''
2366 ENDFOREACH(amname ${%s})
2371 def addInstallTarget(self, key, destination, newlines):
2372 newlines.append(r"FOREACH(f ${%s})"%(key))
2373 newlines.append(r'''
2376 newlines.append(r'''
2377 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2378 IF(test_SALOMEconfig.h.in)
2379 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2380 ELSE(test_SALOMEconfig.h.in)
2381 SET(dummy dummy-NOTFOUND)
2382 MARK_AS_ADVANCED(dummy)
2383 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2384 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2387 if key in ['dist_salomescript_SCRIPTS',
2388 'dist_appliskel_SCRIPTS',
2389 'dist_appliskel_PYTHON']:
2390 newlines.append(r'''
2392 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2393 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2394 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2395 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2398 newlines.append(r'''
2399 GET_FILENAME_COMPONENT(ext ${f} EXT)
2400 IF(ext STREQUAL .py)
2401 IF(DEST STREQUAL bin/salome)
2403 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2404 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2405 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2406 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2407 ELSE(DEST STREQUAL bin/salome)
2408 INSTALL(FILES ${f} DESTINATION ${DEST})
2409 ENDIF(DEST STREQUAL bin/salome)
2410 ELSE(ext STREQUAL .py)
2411 INSTALL(FILES ${f} DESTINATION ${DEST})
2412 ENDIF(ext STREQUAL .py)
2415 newlines.append(r'''
2417 GET_FILENAME_COMPONENT(ext ${f} EXT)
2418 IF(ext STREQUAL .qm)
2419 STRING(REGEX REPLACE .qm .ts input ${f})
2421 if self.module in ["kernel", "gui", "yacs"]:
2422 newlines.append(r'''
2423 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2426 newlines.append(r'''
2427 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2430 newlines.append(r'''
2431 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2432 # ADD_CUSTOM_COMMAND(
2434 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2435 # MAIN_DEPENDENCY ${input}
2437 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2438 ENDIF(ext STREQUAL .qm)
2439 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2441 ENDIF(test_SALOMEconfig.h.in)
2443 newlines.append(r'''
2444 GET_FILENAME_COMPONENT(ext ${f} EXT)
2445 IF(ext STREQUAL .py)
2446 INSTALL(CODE "SET(PYTHON_FILE ${f})")
2447 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2448 INSTALL(CODE "SET(DEST ${DEST})")
2449 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2451 if self.module == "kernel":
2453 IF(f STREQUAL SALOME_ContainerPy.py)
2454 ELSE(f STREQUAL SALOME_ContainerPy.py)
2455 IF(f STREQUAL am2cmake.py)
2456 ELSE(f STREQUAL am2cmake.py)
2457 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2458 ENDIF(f STREQUAL am2cmake.py)
2459 ENDIF(f STREQUAL SALOME_ContainerPy.py)
2463 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2464 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_and_compile_python_file.cmake)
2467 newlines.append(r'''
2468 ENDIF(ext STREQUAL .py)
2470 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2473 def writeListsFile(self):
2474 f = open(self.listsFile, "w")
2475 f.write(self.content)
2479 def writeEnvScript(self, upmod, buildmod=True):
2481 p_version = sys.version[:3]
2482 python_path = "PYTHONPATH"
2483 root_dir = "%s_ROOT_DIR" % upmod
2484 if sys.platform == "win32":
2485 script_line = '@SET %(var)s=%(val)s;%%%(var)s%%\n'
2492 script_line = 'export %(var)s=%(val)s:\$%(var)s\n'
2494 lib_path = "LD_LIBRARY_PATH"
2496 omni_py = "/".join( ["python%s"%p_version , "site-packages"] )
2502 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2503 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "bin", "salome"] ) }
2504 script += script_line % { 'var':lib_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "salome"] ) }
2507 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2508 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "bin", "salome"] ) }
2509 script += script_line % { 'var':lib_path, 'val':"/".join( [var_line % root_dir, "lib", "salome"] ) }
2512 if upmod == "KERNEL" :
2515 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2516 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2519 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2520 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2522 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni_py] ) }
2525 if upmod == "GEOM" :
2526 script = self.writeEnvScript("KERNEL", False) + "\n" + script
2527 script = self.writeEnvScript("GUI", False) + "\n" + script
2530 if upmod == "SMESH" :
2531 script = self.writeEnvScript("GEOM", False) + "\n" + script
2537 def convertAmFile(the_root, root, dirs, files, f, module):
2538 cmake = CMakeFile(the_root, root, dirs, files, f, module)
2539 cmake.writeListsFile()
2542 def usage(exit_status):
2543 from sys import exit
2544 from sys import argv
2545 print "Usage: %s --module"%(argv[0])
2549 if __name__ == "__main__":
2551 from sys import argv
2557 if module.find('--') != 0:
2561 if len(module) == 0:
2565 from os import getcwd
2570 from os import getenv
2572 for root, dirs, files in walk(the_root):
2574 # E.A. : Remove 'CVS' in dirs
2575 # E.A. : It allows to not recurse in CVS dirs
2576 # E.A. : See os module python documentation
2583 if "Makefile.am.cmake" in files:
2584 if "Makefile.am" in files:
2585 files.remove("Makefile.am")
2590 if f in ["Makefile.am", "Makefile.am.cmake"]:
2591 convert = True # convert files by default
2592 forced = getenv("AM2CMAKE_FORCE_GENERATION", "0")=="1" or \
2593 getenv("AM2CMAKE_FORCE_%s_GENERATION"%module.upper(), "0")=="1"
2595 # detect if conversion should be done
2596 if "CMakeLists.txt" in files:
2597 from os.path import join
2598 ff = open(join(root, "CMakeLists.txt"))
2601 if content.find("generated by am2cmake") == -1:
2607 convertAmFile(the_root, root, dirs, files, f, module)
2613 from sys import stdout
2616 msg = "%s file has been converted to cmake"%(nok)
2618 msg = "%s files have been converted to cmake"%(nok)