1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2012 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.
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}")
204 "vtkGraphicsPythonD",
212 "LifeCycleCORBATest",
219 "SalomeCommunication",
222 "SalomeDSCContainer",
224 "SalomeDSCSupervBasic",
234 "SalomeLifeCycleCORBA",
236 "SALOMELocalTraceTest",
237 "SalomeLoggerServer",
238 "SalomeMPIContainer",
239 "SalomeNotification",
241 "SalomeResourcesManager",
242 "SalomeTestComponentEngine",
243 "SalomeTestMPIComponentEngine",
244 "SALOMETraceCollectorTest",
247 "with_loggerTraceCollector",
248 "SalomeKernelHelpers",
273 "SalomePyQtGUILight",
311 "GEOMFiltersSelection",
345 "medcouplingremapper",
360 "paramedcouplingcorba",
369 "GeomSelectionTools",
383 "SMESHFiltersSelection",
392 full_list = cas_list + vtk_list
393 full_list += kernel_list + gui_list
394 full_list += geom_list + med_list + smesh_list
396 # E.A. : sort by len before substitution ...
397 # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
398 # And you understand ...
400 full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
402 for key in full_list:
403 content = content.replace("-l%s"%(key), "${%s}"%(key))
408 # Split content in lines to treat each one separately
410 lines = content.split('\n')
413 # newlines contains the lines of the future CMakeLists.txt file
418 # opened_ifs is used to deals with nested conditionnals
423 # the __thedict__ dictionnary contains key, val
424 # of the Makefile.am file
426 self.__thedict__ = {}
429 # Initialize file ... mainly includes other cmake files
431 self.initialize(newlines)
434 # Do the job for each line
437 self.treatLine(line, newlines, opened_ifs)
441 # Finalize file ... it is in here the cmake job is done
443 self.finalize(newlines)
446 # Concatenate newlines into content
448 content = '\n'.join(newlines)
451 # Add a CR at end if necessary
453 lines = content.split('\n')
454 # lines = [ l.strip() for l in lines ]
455 if len(lines[-1]) != 0:
458 content = '\n'.join(lines)
461 self.content = "# ---------------------------------------------------------------------\n"
462 self.content += "# This file was automatically generated by am2cmake (erwan.adam@cea.fr)\n"
463 self.content += "# ---------------------------------------------------------------------\n"
464 self.content += content
469 def initialize(self, newlines):
470 if self.root == self.the_root:
473 CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
474 IF(COMMAND cmake_policy)
475 cmake_policy(SET CMP0003 NEW)
476 ENDIF(COMMAND cmake_policy)
485 """%(self.module.upper()))
487 if self.module == "netgen":
489 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindPLATFORM.cmake)
490 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindCAS.cmake)
493 if self.module == "kernel":
495 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
496 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
497 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
498 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
499 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
500 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
501 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
502 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
503 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
504 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
505 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
506 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
507 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
511 if self.module == "med":
513 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
515 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
516 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
517 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
518 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
519 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
520 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
521 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
522 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
523 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
524 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
525 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
526 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
527 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
528 ELSE(KERNEL_ROOT_DIR)
529 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
530 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
531 ENDIF(KERNEL_ROOT_DIR)
535 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
536 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPLATFORM.cmake)
537 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPYTHON.cmake)
538 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindOMNIORB.cmake)
539 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindPTHREADS.cmake)
540 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindMPI.cmake)
541 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindHDF5.cmake)
542 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindBOOST.cmake)
543 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindLIBXML2.cmake)
544 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindSWIG.cmake)
545 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
546 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindDOXYGEN.cmake)
547 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSalomeLIBBATCH.cmake)
548 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/FindKERNEL.cmake)
551 if self.module == "gui":
553 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
554 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
555 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
556 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
557 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
558 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
562 SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
564 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindCAS.cmake)
565 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQT4.cmake)
566 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindOPENGL.cmake)
567 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindVTK.cmake)
568 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindQWT.cmake)
569 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindSIPPYQT.cmake)
570 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/deprecated/FindGUI.cmake)
573 if self.module == "med":
574 #METIS must be after PARMETIS to prevent to activate METIS if PARMETIS already exists
576 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindPARMETIS.cmake)
577 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMETIS.cmake)
578 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSCOTCH.cmake)
579 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSPLITTER.cmake)
580 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindRENUMBER.cmake)
581 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
583 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
587 if self.module == "smesh":
589 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
590 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
591 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
592 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
593 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
594 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
597 if self.module == "geom":
599 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
603 if self.module == "netgenplugin":
605 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
606 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
607 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
608 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
609 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
610 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
611 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
614 if self.module == "blsurfplugin":
616 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
617 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
618 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
619 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
620 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
621 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
622 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCADSURF.cmake)
625 if self.module in ["ghs3dplugin", "hexoticplugin"]:
627 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
628 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
629 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
630 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
631 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
632 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
635 if self.module == "ghs3dprlplugin":
637 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
638 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
639 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
640 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
641 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
642 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
643 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
646 if self.module == "visu":
648 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
649 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
652 if self.module == "yacs":
654 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
655 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
656 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
659 if self.module == "jobmanager":
661 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
664 if self.module == "hxx2salome":
666 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
667 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
668 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
678 if self.module not in ['med']:
682 MESSAGE(STATUS "cppunit is disabled.")
687 if self.module == "kernel":
691 SET(CALCIUM_IDL_INT_F77 long)
692 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
695 elif self.module == "gui":
697 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
698 SET(ENABLE_VTKVIEWER ON)
699 SET(ENABLE_SALOMEOBJECT ON)
700 SET(ENABLE_OCCVIEWER ON)
701 SET(ENABLE_GLVIEWER ON)
702 SET(ENABLE_PLOT2DVIEWER ON)
703 SET(ENABLE_PYCONSOLE ON)
704 SET(ENABLE_SUPERVGRAPHVIEWER ON)
705 SET(ENABLE_QXGRAPHVIEWER ON)
708 elif self.module == "jobmanager":
715 elif self.module == "geom":
718 SET(GEOM_ENABLE_GUI ON)
722 elif self.module == "medfile":
724 SET(MED_NUM_MAJEUR 3)
725 SET(MED_NUM_MINEUR 0)
726 SET(MED_NUM_RELEASE 3)
729 SET(FLIBS -lgfortranbegin -lgfortran)
733 elif self.module == "med":
736 SET(MED_ENABLE_KERNEL ON)
738 SET(MED_ENABLE_SPLITTER ON)
740 ENDIF(KERNEL_ROOT_DIR)
742 SET(MED_ENABLE_GUI ON)
746 elif self.module == "smesh":
749 SET(SMESH_ENABLE_GUI ON)
753 elif self.module == "netgen":
755 SET(OCCFLAGS ${CAS_CPPFLAGS})
756 SET(OCCLIBS ${CAS_LDPATH})
757 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
758 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
759 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
762 elif self.module == "netgenplugin":
765 SET(NETGENPLUGIN_ENABLE_GUI ON)
769 elif self.module == "blsurfplugin":
772 SET(BLSURFPLUGIN_ENABLE_GUI ON)
776 elif self.module == "ghs3dplugin":
779 SET(GHS3DPLUGIN_ENABLE_GUI ON)
783 elif self.module == "hexoticplugin":
786 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
790 elif self.module == "ghs3dprlplugin":
793 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
797 elif self.module == "yacs":
799 SET(SALOME_KERNEL ON)
807 set(SHORT_VERSION 7.0)
808 set(XVERSION 0x070000)
814 SET(VERSION_INFO 0.0.0)
815 SET(SOVERSION_INFO 0)
818 SET(AM_CPPFLAGS -I${CMAKE_BINARY_DIR} )
819 SET(AM_CXXFLAGS -I${CMAKE_BINARY_DIR})
821 SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
822 SET(salomepythondir ${pythondir}/salome)
823 SET(salomepypkgdir ${salomepythondir}/salome)
826 if self.module == "smesh" and self.root[-len('SMESH_PY'):] == 'SMESH_PY':
828 SET(smeshpypkgdir ${salomepythondir}/salome/smesh)
831 if self.module == "netgen":
833 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_CURRENT_SOURCE_DIR})
835 elif self.module == "kernel":
837 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
838 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
841 if self.module not in ["yacs"]:
844 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
845 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
846 ENDIF(KERNEL_ROOT_DIR)
849 if self.module == "gui":
852 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
853 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
854 ENDIF(KERNEL_ROOT_DIR)
857 if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin", "hexoticplugin"]:
859 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
860 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
863 if self.module == "ghs3dplugin":
864 # TODO: Auto-detect TetGen-GHS3D version automatically
866 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DGHS3D_VERSION=42)
867 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DGHS3D_VERSION=42)
870 if self.module == "hxx2salome":
872 if self.the_root[-len(key):] != key:
873 msg = "Source dir must finished with %s !"%(key)
875 hxxmodule = self.the_root[:-len(key)]
876 from os.path import basename
877 hxxmodule = basename(hxxmodule)
878 hxxmodule = hxxmodule.lower()
879 self.hxxmodule = hxxmodule
881 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
882 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
883 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
884 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
885 '''%(hxxmodule.upper()))
891 def treatLine(self, line, newlines, opened_ifs):
894 # Print the comment above the line itself
896 if line.find('#') >= 0:
897 fields = line.split('#')
899 comment = '#'.join([''] + fields[1:])
900 newlines.append(comment)
906 # If the line begins with 'include ', just comment it
908 if line.find("include ") == 0:
909 if line.find("include $(top_srcdir)/config/automake.common") == 0:
911 "MAINTAINERCLEANFILES = Makefile.in",
912 "AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
913 "AM_FFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
914 "AM_FCFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
915 "AM_CPPFLAGS+=@HDF5_CPPFLAGS@",
916 "AM_LDFLAGS=@HDF5_LDFLAGS@",
918 self.treatLine(l, newlines, opened_ifs)
922 newlines.append("# " + line)
927 # If the line begins with '-include', just comment it
929 if line.find("-include") == 0:
930 newlines.append("# " + line)
934 # If the line is a definition of a make rule, just comment it
936 if line.count(':') == 1:
937 newlines.append("# " + line)
941 # A particuliar case where there are two ":" on the same line
943 if line.find('install-exec-local:') == 0:
944 newlines.append("# " + line)
948 # If the line begin by a tabulation, consider it's a makefile command and comment it
950 if line.find("\t") == 0:
951 newlines.append("# " + line)
956 key = "-version-info"
957 if line.find(key) >= 0:
959 before = line.split(key)[0]
960 after = line[len(before)+len(key):]
963 version_info = after.split()[0]
964 line = line.replace(key+sep+version_info, "")
966 version_info = version_info.replace(':', '.')
967 soversion_info = version_info.split('.')[0]
968 newlines.append("SET(VERSION_INFO " + version_info + ")")
969 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
974 # Replace the $(TOTO) by ${TOTO}
975 # Replace the @TOTO@ by ${TOTO}
977 line = p_dollar.sub(r"${\1}", line)
978 line = p_arobas.sub(r"${\1}", line)
981 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
982 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
983 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
984 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
985 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
988 # Check if the line is a 'if' condition
989 # If yes, replace it by a cmake grammar
991 match = p_if.match(line)
993 theif = match.group("val")
995 theif = "NOT " + theif[1:]
997 line = p_if.sub(r"IF(%s)"%(theif), line)
998 opened_ifs.append(theif)
999 newlines.append(line)
1003 # Check if the line is a 'else' condition
1004 # If yes, replace it by a cmake grammar
1006 match = p_else.match(line)
1008 line = "ELSE(%s)"%(opened_ifs[-1])
1009 newlines.append(line)
1013 # Check if the line is a 'endif' condition
1014 # If yes, replace it by a cmake grammar
1016 match = p_endif.match(line)
1018 line = "ENDIF(%s)"%(opened_ifs[-1])
1019 opened_ifs[-1:] = []
1020 newlines.append(line)
1024 # Check if the line is an attribution '=' or '+='
1026 match = p_attribution.match(line)
1028 self.treatAttribution(match, newlines)
1032 newlines.append(line)
1037 def treatAttribution(self, match, newlines):
1039 spaces = match.group("spaces")
1040 key = match.group("key")
1041 method = match.group("method")
1042 value = match.group("value")
1043 # print [spaces, key, method, value]
1046 # Open cmake SET command
1048 newlines.append(spaces + "SET(" + key)
1051 # If method is '+=', put the previous definition as first value
1054 newlines.append("%s ${%s}"%(spaces, key))
1058 fields = value.split()
1060 for i in range(len(fields)):
1061 newlines.append("%s %s"%(spaces, fields[i]))
1067 # The try: except KeyError is here if the +=
1068 # is an error which occurs in salome ...
1071 self.__thedict__[key] += fields[:]
1073 self.__thedict__[key] = fields[:]
1077 self.__thedict__[key] = fields[:]
1081 # Close cmake SET command
1084 newlines.append("%s)"%(spaces))
1088 def finalize(self, newlines):
1091 # Convert the .in files in build dir
1094 if self.module == "hexoticplugin" :
1095 upmod = "HexoticPLUGIN"
1097 upmod = self.module.upper()
1101 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1102 newlines.append(r'''
1110 ${CMAKE_CURRENT_SOURCE_DIR}
1113 ${CMAKE_CURRENT_BINARY_DIR}
1116 ${CMAKE_INSTALL_PREFIX}/share
1119 ${datadir}/doc/salome
1122 self.files.append("static/header.html.in")
1123 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']:
1124 newlines.append(r'''
1132 ${CMAKE_CURRENT_SOURCE_DIR}
1135 ${CMAKE_CURRENT_BINARY_DIR}
1138 ${CMAKE_INSTALL_PREFIX}/share
1141 ${datadir}/doc/salome
1144 if mod not in ['blsurfplugin']:
1145 self.files.append("static/header.html.in")
1146 if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1147 self.files.append("static/header_py.html.in")
1149 if self.module == "yacs":
1151 if self.root[-len(key):] == key:
1152 self.files.append("resources/YACSCatalog.xml.in")
1153 self.files.append("resources/SalomeApp.xml.in")
1157 if operator.contains(self.root, 'YACS_SRC'+path.sep+'doc'):
1158 newlines.append(r'''
1160 ${CMAKE_CURRENT_SOURCE_DIR}
1164 if self.module == "jobmanager":
1166 if self.root[-len(key):] == key:
1167 self.files.append("resources/SalomeApp.xml.in")
1170 for f in self.files:
1172 if self.module == 'yacs' and f == "Doxyfile.in":
1174 if f == "sstream.in":
1176 if f in ["runContainer.in", "stopContainer.in"]:
1177 if self.module == "med":
1178 if self.root[-3:] == "csh":
1182 if f == "SALOMEconfig.ref.in":
1183 out = "SALOMEconfig.h"
1187 newlines.append(r'''
1188 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1190 newlines.append(r'''
1191 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1193 newlines.append(r'''
1194 MESSAGE(STATUS "Creation of ${output}")
1195 CONFIGURE_FILE(${input} ${output})
1201 # add commands for generating of user's documentation
1203 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1204 doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1205 doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1206 head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1208 prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1210 prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1211 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1213 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1214 input = "Doxyfile_med_user"
1216 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1218 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1219 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1221 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1222 )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1224 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'):
1225 ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1226 if mod in ['geom', 'smesh']:
1229 input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1233 newlines.append(r"""
1235 STRING(REPLACE "/" "\\" f "%s")
1239 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} %s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1240 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1241 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1242 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1243 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''')"
1245 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1246 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, tmp, upmod, tmp, tmp, input, tmp, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1247 newlines.append(r"""ADD_DEPENDENCIES(usr_docs html_docs)""")
1250 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1251 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_py"
1252 elif mod not in ['pyhello']:
1253 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_idl"
1254 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs %s
1255 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1256 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''')"
1258 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1259 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1260 elif mod in ['yacs', 'jobmanager'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1261 from sys import platform
1263 if platform == "win32":
1265 newlines.append(r"""
1266 ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1267 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1268 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1269 elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1270 from sys import platform
1274 if platform == "win32":
1278 cmd = "STRING(REPLACE \"/\" \"\\\\\" SCR"
1283 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1284 scr = self.writeEnvScript(upmod)
1285 newlines.append(r"""
1287 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1288 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
1289 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1290 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(cmd, scr, ext, prf, ext, params, doc_gui_destination, doc_gui_destination))
1296 # add commands for generating of developer's documentation
1299 upmod = self.module.upper()
1300 if mod in ['kernel', 'gui', 'med', 'smesh', 'visu', 'blsurfplugin'] and self.root[-len('tui'):] == 'tui':
1302 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1303 COMMAND ${DOXYGEN_EXECUTABLE}
1304 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')" """
1307 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1309 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)
1310 elif mod == 'smesh':
1311 tmp1= """\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s''')" """%(doc_tui_destination)
1314 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1315 inst_head_command=""
1316 if mod not in ['blsurfplugin']:
1317 inst_head_command = "; shutil.copy(r'''%s''', r'''%s''')"%(head_source, doc_tui_destination)
1318 newlines.append(tmp + """
1319 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 + """
1321 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1323 if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1325 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1326 newlines.append(r"""
1328 STRING(REPLACE "/" "\\" f "%s")
1332 ADD_CUSTOM_TARGET(dev_docs ${PYTHON_EXECUTABLE} ${f} ${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1333 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1334 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1335 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''')"
1337 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1338 )"""%(prepare_generating_doc_src, prepare_generating_doc_src, upmod, tmp, upmod, tmp, tmp, upmod, tmp, doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination, doc_tui_destination))
1341 # convert the SUBDIRS in cmake grammar
1343 if 1: # self.__thedict__.has_key("SUBDIRS"):
1344 newlines.append(r'''
1345 FOREACH(dir ${SUBDIRS})
1346 IF(NOT dir STREQUAL .)
1347 ADD_SUBDIRECTORY(${dir})
1348 ENDIF(NOT dir STREQUAL .)
1349 ENDFOREACH(dir ${SUBDIRS})
1355 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1356 if self.__thedict__.has_key(key):
1357 self.addLibTarget(key, newlines)
1363 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1364 if self.__thedict__.has_key(key):
1365 self.addBinTarget(key, newlines)
1371 if self.__thedict__.has_key("BASEIDL_FILES"):
1372 if not self.__thedict__.has_key("IDL_FILES"):
1373 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1375 SET(IDL_FILES ${BASEIDL_FILES})
1384 if self.__thedict__.has_key(key):
1385 if self.module == "kernel":
1387 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1391 FOREACH(input ${IDL_FILES})
1392 STRING(REGEX REPLACE ".idl" "" base ${input})
1393 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1395 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1396 SET(outputs ${outputs} ${dynsrc})
1397 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1398 SET(outputs ${outputs} ${inc})
1399 IF(input STREQUAL Calcium_Ports.idl)
1400 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1401 ELSE(input STREQUAL Calcium_Ports.idl)
1402 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1403 ENDIF(input STREQUAL Calcium_Ports.idl)
1404 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1405 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1407 SET(flags -bcxx ${flags})
1411 COMMAND ${OMNIORB_IDL} ${flags} ${input}
1412 MAIN_DEPENDENCY ${input}
1416 install(FILES ${input} DESTINATION idl/salome)
1418 if self.module not in ["pyhello"]:
1420 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1421 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1425 INSTALL(CODE "SET(IDL_FILE ${input})")
1426 INSTALL(CODE "SET(DIR ${salomepythondir})")
1428 INSTALL(CODE "SET(DIR bin/salome)")
1430 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1431 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1434 FOREACH(f ${IDLPYFLAGS})
1435 SET(flags "${flags} ${f}")
1436 ENDFOREACH(f ${IDLPYFLAGS})
1437 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1439 SET(flags "-bpython ${flags}")
1440 ENDIF(NOT ISBPYTHON)
1441 SET(IDLPYFLAGS ${flags})
1442 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1443 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1446 if self.module == "kernel":
1448 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1452 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1453 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_python_from_idl.cmake)
1457 ENDFOREACH(input ${IDL_FILES})
1463 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1464 if self.__thedict__.has_key(key):
1466 SET(SWIG_SOURCES ${%s})
1468 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1474 if self.__thedict__.has_key("SWIG_SOURCES"):
1476 IF(SWIG_SOURCES MATCHES ";")
1477 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1478 ELSE(SWIG_SOURCES MATCHES ";")
1479 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1480 ENDIF(SWIG_SOURCES MATCHES ";")
1482 FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1485 LIST(FIND flags ${f} index)
1486 IF(NOT index EQUAL -1)
1488 ENDIF(NOT index EQUAL -1)
1491 SET(flags ${flags} ${f})
1493 ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1495 OUTPUT ${build_srcs}
1496 COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1497 MAIN_DEPENDENCY ${SWIG_SOURCES}
1504 if self.__thedict__.has_key("BUILT_SOURCES"):
1506 FOREACH(f ${BUILT_SOURCES})
1507 IF(f MATCHES "WRAP.cxx$")
1508 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1509 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1511 OUTPUT ${f} # ${inc}
1512 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1513 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1515 ENDIF(f MATCHES "WRAP.cxx$")
1516 ENDFOREACH(f ${BUILT_SOURCES})
1523 if self.__thedict__.has_key(key):
1525 FOREACH(output ${MOC_FILES})
1527 if self.module in ["jobmanager", "yacs"]:
1529 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1533 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1537 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1538 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1541 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1542 MAIN_DEPENDENCY ${input}
1544 ENDFOREACH(output ${MOC_FILES})
1550 key = "MOC_FILES_HXX"
1551 if self.__thedict__.has_key(key):
1553 FOREACH(output ${MOC_FILES_HXX})
1556 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1559 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1560 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1563 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1564 MAIN_DEPENDENCY ${input}
1566 ENDFOREACH(output ${MOC_FILES_HXX})
1573 if self.__thedict__.has_key(key):
1575 FOREACH(output ${UIC_FILES})
1576 STRING(REPLACE "ui_" "" input ${output})
1577 STRING(REPLACE ".h" ".ui" input ${input})
1578 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1579 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1582 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1583 MAIN_DEPENDENCY ${input}
1585 ENDFOREACH(output ${UIC_FILES})
1592 if self.__thedict__.has_key(key):
1594 FOREACH(output ${PYUIC_FILES})
1595 STRING(REPLACE "_ui.py" ".ui" input ${output})
1596 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1597 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1600 COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1601 MAIN_DEPENDENCY ${input}
1603 ENDFOREACH(output ${PYUIC_FILES})
1604 ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1611 if self.__thedict__.has_key(key):
1613 FOREACH(output ${QRC_FILES})
1614 STRING(REGEX REPLACE "qrc_" "" input ${output})
1615 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1616 STRING(REGEX REPLACE ".qrc" "" name ${input})
1617 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1618 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1621 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1622 MAIN_DEPENDENCY ${input}
1624 ENDFOREACH(output ${QRC_FILES})
1631 if self.__thedict__.has_key(key):
1633 FOREACH(input ${SIP_FILES})
1634 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1636 FOREACH(out ${SIP_SRC})
1637 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1638 ENDFOREACH(out ${SIP_SRC})
1641 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1642 MAIN_DEPENDENCY ${input}
1644 ENDFOREACH(input ${SIP_FILES})
1649 # For GUI/tools/dlgfactory
1651 key = "UIC_FILES_QDIALOG"
1652 if self.__thedict__.has_key(key):
1654 FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1655 STRING(REPLACE "ui_" "" input ${output})
1656 STRING(REPLACE ".hxx" ".ui" input ${input})
1657 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1658 IF (NOT EXISTS ${input_path})
1659 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1660 ENDIF (NOT EXISTS ${input_path})
1663 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1664 MAIN_DEPENDENCY ${input}
1666 ENDFOREACH(output ${UIC_FILES})
1668 FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1669 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1670 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1671 IF (NOT EXISTS ${input_path})
1672 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1673 ENDIF (NOT EXISTS ${input_path})
1676 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1677 MAIN_DEPENDENCY ${input}
1679 ENDFOREACH(output ${MOC_FILES})
1682 OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1683 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1684 DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1688 OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1689 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1690 DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1698 for key in ["TESTS"]:
1699 if self.__thedict__.has_key(key):
1701 SET(UNIT_TEST_PROG ${%s})
1703 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1706 key = "UNIT_TEST_PROG"
1707 if self.__thedict__.has_key(key):
1709 FOREACH(input ${UNIT_TEST_PROG})
1710 GET_FILENAME_COMPONENT(ext ${input} EXT)
1711 IF(ext STREQUAL .py)
1712 SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1713 ELSE(ext STREQUAL .py)
1715 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1717 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1719 ENDIF(ext STREQUAL .py)
1720 ADD_TEST(${input} ${test})
1721 SET(fail_regex "KO")
1722 SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1724 # ADD_TEST(${input}_valgrind valgrind ${test})
1725 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1726 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1728 ENDFOREACH(input ${UNIT_TEST_PROG})
1733 # Treat the install targets
1735 resdir = self.module
1736 if resdir == "hxx2salome":
1737 resdir = self.hxxmodule
1740 "salomeadmux_DATA" : "salome_adm/unix",
1741 "dist_salomeadmux_DATA" : "salome_adm/unix",
1742 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1743 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1744 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1745 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1746 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1747 "salomeinclude_DATA" : "include/salome",
1748 "salomeinclude_HEADERS" : "include/salome",
1749 "nodist_salomeinclude_HEADERS" : "include/salome",
1750 "dist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1751 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1752 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(resdir),
1753 "dist_salomescript_SCRIPTS" : "bin/salome",
1754 "dist_salomescript_DATA" : "bin/salome",
1755 "dist_salomescript_PYTHON" : "bin/salome",
1756 "dist_appliskel_SCRIPTS" : "bin/salome/appliskel",
1757 "dist_appliskel_PYTHON" : "bin/salome/appliskel",
1758 "nodist_salomescript_DATA" : "bin/salome",
1759 "salomepython_PYTHON" : "${salomepythondir}",
1760 "nodist_salomepython_PYTHON" : "${salomepythondir}",
1761 "dist_salomepython_DATA" : "${salomepythondir}",
1762 "sharedpkgpython_PYTHON" : "${salomepythondir}/shared_modules",
1763 "salomepypkg_PYTHON" : "${salomepypkgdir}",
1764 "mypkgpython_PYTHON" : "${mypkgpythondir}",
1765 "nodist_mypkgpython_PYTHON" : "${mypkgpythondir}",
1767 if self.module == "jobmanager":
1768 d["bin_SCRIPTS"] = "bin"
1770 if self.module == "medfile":
1772 "include_HEADERS" : "include",
1773 "nodist_include_HEADERS" : "include",
1774 "bin_SCRIPTS" : "bin",
1775 "doc_DATA" : "${docdir}",
1778 if self.module == "netgen":
1780 "include_HEADERS" : "include",
1781 "noinst_HEADERS" : "share/netgen/include",
1782 "dist_pkgdata_DATA" : "share/netgen",
1783 "dist_doc_DATA" : "share/doc/netgen",
1786 for key, value in d.items():
1787 if self.__thedict__.has_key(key):
1788 self.addInstallTarget(key, value, newlines)
1795 def setLibAdd(self, key, newlines):
1797 newlines.append(r'''
1801 newlines.append(r'''
1804 SET(targets ${targets} MEFISTO2D)
1805 FOREACH(target ${targets})
1806 IF(name STREQUAL ${target})
1807 SET(dir $ENV{F2CHOME})
1808 STRING(REPLACE "\\\\" "/" dir ${dir})
1809 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1810 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1811 ENDIF(name STREQUAL ${target})
1812 ENDFOREACH(target ${targets})
1815 SET(targets ${targets} MEFISTO2D)
1816 FOREACH(target ${targets})
1817 IF(name STREQUAL ${target})
1818 SET(libadd ${libadd} -lf2c)
1819 ENDIF(name STREQUAL ${target})
1820 ENDFOREACH(target ${targets})
1824 newlines.append(r'''
1825 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1826 FOREACH(lib SALOMEBasics SalomeBatch)
1827 IF(name STREQUAL lib)
1828 SET(libs ${libs} ${PTHREAD_LIBS})
1829 ENDIF(name STREQUAL lib)
1830 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1833 newlines.append(r'''
1834 FOREACH(lib ${libs})
1835 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1836 IF(ext STREQUAL .la)
1837 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1838 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1839 ENDIF(ext STREQUAL .la)
1841 SET(vars ${vars} -no-undefined)
1842 SET(vars ${vars} -lvtkWidgets)
1844 SET(vars ${vars} -module)
1845 SET(vars ${vars} -Wl,-E)
1846 SET(vars ${vars} -Xlinker)
1847 SET(vars ${vars} -export-dynamic)
1848 SET(vars ${vars} -lm)
1849 SET(vars ${vars} -lboost_thread)
1850 SET(vars ${vars} -lboost_signals)
1851 SET(vars ${vars} -pthread -lpthread -ldl)
1856 ENDIF(lib STREQUAL v)
1857 ENDFOREACH(v ${vars})
1860 STRING(REGEX MATCH "^-lQt" test ${lib})
1863 SET(libadd ${libadd} ${lib})
1865 ENDFOREACH(lib ${libs})
1866 TARGET_LINK_LIBRARIES(${name} ${libadd})
1869 newlines.append(r'''
1872 SET(targets ${targets} MEFISTO2D)
1873 FOREACH(target ${targets})
1874 IF(name STREQUAL ${target})
1875 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1876 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1877 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1878 ENDIF(name STREQUAL ${target})
1879 ENDFOREACH(target ${targets})
1885 def setCompilationFlags(self, key, newlines):
1886 newlines.append(r'''
1890 SET(targets ${targets} SalomeIDLKernel)
1891 SET(targets ${targets} SalomeDS)
1892 SET(targets ${targets} SALOMEDSTest)
1893 SET(targets ${targets} SALOMEDS_Client_exe)
1894 SET(targets ${targets} SalomeIDLGEOM)
1895 SET(targets ${targets} GEOMEngine)
1896 SET(targets ${targets} MEDEngine)
1897 SET(targets ${targets} SMESHEngine)
1898 SET(targets ${targets} SMESH)
1899 SET(targets ${targets} SalomeIDLSPADDER)
1900 SET(targets ${targets} MeshJobManagerEngine)
1901 SET(targets ${targets} StdMeshersEngine)
1902 SET(targets ${targets} VISUEngineImpl)
1903 FOREACH(target ${targets})
1904 IF(name STREQUAL ${target})
1905 SET(var ${var} -DNOGDI)
1906 ENDIF(name STREQUAL ${target})
1907 ENDFOREACH(target ${targets})
1911 if self.module in ["medfile", "yacs"]:
1912 newlines.append(r'''
1914 SET(var ${var} -DNOGDI)
1919 newlines.append(r'''
1922 SET(targets ${targets} MEFISTO2D)
1923 FOREACH(target ${targets})
1924 IF(name STREQUAL ${target})
1925 SET(dir $ENV{F2CHOME})
1926 STRING(REPLACE "\\\\" "/" dir ${dir})
1927 SET(var ${var} -I${dir})
1928 SET(var ${var} -DF2C_BUILD)
1929 ENDIF(name STREQUAL ${target})
1930 ENDFOREACH(target ${targets})
1934 if self.module in ["geom", "med", "hexoticplugin", "blsurfplugin"]:
1935 newlines.append(r'''
1936 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1937 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1940 newlines.append(r'''
1941 SET(var ${var} ${AM_CPPFLAGS})
1942 SET(var ${var} ${AM_CXXFLAGS})
1945 newlines.append(r'''
1946 IF(type STREQUAL STATIC)
1947 SET(var ${var} -fPIC)
1948 ENDIF(type STREQUAL STATIC)
1951 if self.module == "yacs":
1952 newlines.append(r'''
1953 SET(var ${var} -DYACS_PTHREAD)
1954 SET(var ${var} -DCMAKE_BUILD)
1955 SET(var ${var} -DSALOME_KERNEL)
1956 SET(var ${var} -DDSC_PORTS)
1957 SET(var ${var} -DOMNIORB)
1960 newlines.append(r'''
1961 SET(var ${var} ${PLATFORM_CPPFLAGS})
1962 SET(var ${var} ${PTHREAD_CFLAGS})
1963 SET(var ${var} ${${amname}_CPPFLAGS})
1964 SET(var ${var} ${${amname}_CXXFLAGS})
1965 SET(var ${var} ${${amname}_CFLAGS})
1968 SET(vars ${vars} -include SALOMEconfig.h)
1969 SET(vars ${vars} -ftemplate-depth-32)
1970 SET(vars ${vars} -fPIC)
1971 SET(vars ${vars} -g)
1972 IF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") # if platform is Windows 64 bit
1973 IF(name STREQUAL _pilot)
1974 SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # to avoid error C1128
1975 ENDIF(name STREQUAL _pilot)
1976 ENDIF("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
1984 ENDFOREACH(v ${vars})
1986 string(REGEX MATCH "^-I" test_include ${f})
1988 string(REGEX REPLACE "^-I" "" include_dir ${f})
1990 if(include_dir STREQUAL /usr/include)
1991 else(include_dir STREQUAL /usr/include)
1992 string(REGEX MATCH "^\\." test_dot ${include_dir})
1994 set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
1996 include_directories(${include_dir})
1997 endif(include_dir STREQUAL /usr/include)
2000 SET(flags "${flags} ${f}")
2003 ENDFOREACH(f ${var})
2004 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2008 def addLibTarget(self, key, newlines):
2009 newlines.append(r'''
2010 FOREACH(amname ${%s})
2013 # Replace .la by _la ...
2015 newlines.append(r'''
2016 STRING(REPLACE .la _la amname ${amname})
2019 # Remove the _la for the cmake name
2021 newlines.append(r'''
2022 STRING(LENGTH ${amname} len)
2023 MATH(EXPR newlen "${len}-3")
2024 STRING(SUBSTRING ${amname} 0 ${newlen} name)
2027 # Does the target begins with lib ??
2028 # If yes, remove lib at beginning for cmake name
2030 newlines.append(r'''
2031 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2033 STRING(LENGTH ${name} len)
2034 MATH(EXPR newlen "${len}-3")
2035 STRING(SUBSTRING ${name} 3 ${newlen} name)
2036 ENDIF(BEGIN_WITH_lib)
2039 # Does the target is an idl library
2041 newlines.append(r'''
2042 STRING(REGEX MATCH "IDL" ISIDL ${name})
2045 # Set the type of the library
2047 newlines.append(r'''
2058 if key == "noinst_LTLIBRARIES":
2059 newlines.append(r'''
2068 # Set sources for the library
2070 newlines.append(r'''
2072 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2073 GET_FILENAME_COMPONENT(ext ${src} EXT)
2075 IF(src STREQUAL trte.f)
2076 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2077 STRING(REPLACE ".f" ".c" src ${src})
2078 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2082 IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2083 SET(cmd valgrind f2c) # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2088 COMMAND ${cmd} ${input}
2089 MAIN_DEPENDENCY ${input}
2091 ELSE(src STREQUAL trte.f)
2092 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2093 STRING(REPLACE ".f" ".o" src ${src})
2094 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2103 COMMAND ${F77} -c -o ${output} ${input}
2104 MAIN_DEPENDENCY ${input}
2106 ENDIF(src STREQUAL trte.f)
2107 ENDIF(ext STREQUAL .f)
2108 SET(srcs ${srcs} ${src})
2109 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2111 newlines.append(r'''
2112 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2114 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2115 SET(srcs ${srcs} ${src})
2118 newlines.append(r'''
2120 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2122 GET_FILENAME_COMPONENT(ext ${f} EXT)
2123 IF(ext STREQUAL .py)
2125 ELSE(ext STREQUAL .py)
2126 SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2127 ENDIF(ext STREQUAL .py)
2130 LIST(FIND build_srcs ${fff} index)
2131 IF(NOT index EQUAL -1)
2133 ENDIF(NOT index EQUAL -1)
2137 SET(build_srcs ${build_srcs} ${fff})
2142 # Add the library to cmake
2144 newlines.append(r'''
2145 ADD_LIBRARY(${name} ${type} ${srcs})
2148 # The compilation flags
2150 self.setCompilationFlags(key, newlines)
2152 newlines.append(r'''
2153 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2156 self.setLibAdd(key, newlines)
2158 if 1: # key != "noinst_LTLIBRARIES":
2159 newlines.append(r'''
2162 newlines.append(r'''
2164 IF(${key} STREQUAL noinst_LTLIBRARIES)
2166 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2168 if self.module == "netgen" :
2169 newlines.append(r'''
2170 IF(${key} STREQUAL noinst_LTLIBRARIES)
2174 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2177 newlines.append(r'''
2180 if self.module in ["medfile", "netgen"]:
2181 newlines.append(r'''
2184 elif key == "libparaview_LTLIBRARIES":
2185 newlines.append(r'''
2186 SET(DEST lib/paraview)
2189 newlines.append(r'''
2190 SET(DEST lib/salome)
2193 newlines.append(r'''
2195 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2197 if self.module == "gui":
2198 newlines.append(r'''
2199 FOREACH(lib SalomePyQt)
2200 IF(name STREQUAL lib)
2202 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2203 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2204 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2205 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2206 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2208 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2210 ENDIF(name STREQUAL lib)
2211 ENDFOREACH(lib SalomePyQt)
2212 FOREACH(lib SalomePy)
2213 IF(name STREQUAL lib)
2215 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2216 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2217 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2218 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2219 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2221 ENDIF(name STREQUAL lib)
2222 ENDFOREACH(lib SalomePy)
2225 if self.module == "geom":
2226 newlines.append(r'''
2228 STRING(REGEX MATCH "Export" ISExport ${name})
2230 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2232 STRING(REGEX MATCH "Import" ISImport ${name})
2234 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2239 newlines.append(r'''
2240 ELSE(BEGIN_WITH_lib)
2242 newlines.append(r'''
2244 INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2245 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2246 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2247 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2248 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2249 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2251 GET_TARGET_PROPERTY(version ${name} VERSION)
2252 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2253 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2254 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2255 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2258 newlines.append(r'''
2259 ENDIF(BEGIN_WITH_lib)
2261 newlines.append(r'''
2266 newlines.append(r'''
2267 ENDFOREACH(amname ${%s})
2272 def addBinTarget(self, key, newlines):
2274 newlines.append(r'''
2275 FOREACH(amname ${%s})
2278 newlines.append(r'''
2281 if key == "check_PROGRAMS":
2282 newlines.append(r'''
2284 STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2291 newlines.append(r'''
2295 newlines.append(r'''
2296 SET(name "${amname}_exe")
2297 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2298 SET(l ${nodist_${amname}_SOURCES})
2300 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2301 SET(srcs ${srcs} ${src})
2303 LIST(LENGTH srcs nb)
2305 ADD_EXECUTABLE(${name} ${srcs})
2308 self.setCompilationFlags(key, newlines)
2310 self.setLibAdd(key, newlines)
2312 if self.module in ["jobmanager", "medfile", "netgen"]:
2313 newlines.append(r'''
2317 newlines.append(r'''
2318 SET(DEST bin/salome)
2322 if key == "bin_PROGRAMS":
2323 newlines.append(r'''
2325 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2326 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2327 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2330 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2331 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2332 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2333 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2338 newlines.append(r'''
2342 newlines.append(r'''
2345 newlines.append(r'''
2346 ENDFOREACH(amname ${%s})
2351 def addInstallTarget(self, key, destination, newlines):
2352 newlines.append(r"FOREACH(f ${%s})"%(key))
2353 newlines.append(r'''
2356 newlines.append(r'''
2357 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2358 IF(test_SALOMEconfig.h.in)
2359 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2360 ELSE(test_SALOMEconfig.h.in)
2361 SET(dummy dummy-NOTFOUND)
2362 MARK_AS_ADVANCED(dummy)
2363 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2364 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2367 if key in ['dist_salomescript_SCRIPTS',
2368 'dist_appliskel_SCRIPTS',
2369 'dist_appliskel_PYTHON']:
2370 newlines.append(r'''
2372 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2373 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2374 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2375 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2378 newlines.append(r'''
2379 GET_FILENAME_COMPONENT(ext ${f} EXT)
2380 IF(ext STREQUAL .py)
2381 IF(DEST STREQUAL bin/salome)
2383 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2384 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2385 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2386 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2387 ELSE(DEST STREQUAL bin/salome)
2388 INSTALL(FILES ${f} DESTINATION ${DEST})
2389 ENDIF(DEST STREQUAL bin/salome)
2390 ELSE(ext STREQUAL .py)
2391 INSTALL(FILES ${f} DESTINATION ${DEST})
2392 ENDIF(ext STREQUAL .py)
2395 newlines.append(r'''
2397 GET_FILENAME_COMPONENT(ext ${f} EXT)
2398 IF(ext STREQUAL .qm)
2399 STRING(REGEX REPLACE .qm .ts input ${f})
2401 if self.module in ["kernel", "gui", "yacs"]:
2402 newlines.append(r'''
2403 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2406 newlines.append(r'''
2407 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2410 newlines.append(r'''
2411 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2412 # ADD_CUSTOM_COMMAND(
2414 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2415 # MAIN_DEPENDENCY ${input}
2417 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2418 ENDIF(ext STREQUAL .qm)
2419 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2421 ENDIF(test_SALOMEconfig.h.in)
2423 newlines.append(r'''
2424 GET_FILENAME_COMPONENT(ext ${f} EXT)
2425 IF(ext STREQUAL .py)
2426 INSTALL(CODE "SET(PYTHON_FILE ${f})")
2427 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2428 INSTALL(CODE "SET(DEST ${DEST})")
2429 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2431 if self.module == "kernel":
2433 IF(f STREQUAL SALOME_ContainerPy.py)
2434 ELSE(f STREQUAL SALOME_ContainerPy.py)
2435 IF(f STREQUAL am2cmake.py)
2436 ELSE(f STREQUAL am2cmake.py)
2437 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2438 ENDIF(f STREQUAL am2cmake.py)
2439 ENDIF(f STREQUAL SALOME_ContainerPy.py)
2443 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2444 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_and_compile_python_file.cmake)
2447 newlines.append(r'''
2448 ENDIF(ext STREQUAL .py)
2450 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2453 def writeListsFile(self):
2454 f = open(self.listsFile, "w")
2455 f.write(self.content)
2459 def writeEnvScript(self, upmod, buildmod=True):
2461 p_version = sys.version[:3]
2462 python_path = "PYTHONPATH"
2463 root_dir = "%s_ROOT_DIR" % upmod
2464 if sys.platform == "win32":
2465 script_line = '@SET %(var)s=%(val)s;%%%(var)s%%\n'
2472 script_line = 'export %(var)s=%(val)s:\$%(var)s\n'
2474 lib_path = "LD_LIBRARY_PATH"
2476 omni_py = "/".join( ["python%s"%p_version , "site-packages"] )
2482 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2483 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "bin", "salome"] ) }
2484 script += script_line % { 'var':lib_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "salome"] ) }
2487 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2488 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "bin", "salome"] ) }
2489 script += script_line % { 'var':lib_path, 'val':"/".join( [var_line % root_dir, "lib", "salome"] ) }
2492 if upmod == "KERNEL" :
2495 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2496 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2499 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2500 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2502 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni_py] ) }
2505 if upmod == "GEOM" :
2506 script = self.writeEnvScript("KERNEL", False) + "\n" + script
2507 script = self.writeEnvScript("GUI", False) + "\n" + script
2510 if upmod == "SMESH" :
2511 script = self.writeEnvScript("GEOM", False) + "\n" + script
2517 def convertAmFile(the_root, root, dirs, files, f, module):
2518 cmake = CMakeFile(the_root, root, dirs, files, f, module)
2519 cmake.writeListsFile()
2522 def usage(exit_status):
2523 from sys import exit
2524 from sys import argv
2525 print "Usage: %s --module"%(argv[0])
2529 if __name__ == "__main__":
2531 from sys import argv
2537 if module.find('--') != 0:
2541 if len(module) == 0:
2545 from os import getcwd
2550 from os import getenv
2552 for root, dirs, files in walk(the_root):
2554 # E.A. : Remove 'CVS' in dirs
2555 # E.A. : It allows to not recurse in CVS dirs
2556 # E.A. : See os module python documentation
2563 if "Makefile.am.cmake" in files:
2564 if "Makefile.am" in files:
2565 files.remove("Makefile.am")
2570 if f in ["Makefile.am", "Makefile.am.cmake"]:
2571 convert = True # convert files by default
2572 forced = getenv("AM2CMAKE_FORCE_GENERATION", "0")=="1" or \
2573 getenv("AM2CMAKE_FORCE_%s_GENERATION"%module.upper(), "0")=="1"
2575 # detect if conversion should be done
2576 if "CMakeLists.txt" in files:
2577 from os.path import join
2578 ff = open(join(root, "CMakeLists.txt"))
2581 if content.find("generated by am2cmake") == -1:
2587 convertAmFile(the_root, root, dirs, files, f, module)
2593 from sys import stdout
2596 msg = "%s file has been converted to cmake"%(nok)
2598 msg = "%s files have been converted to cmake"%(nok)