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",
382 "SMESHFiltersSelection",
391 full_list = cas_list + vtk_list
392 full_list += kernel_list + gui_list
393 full_list += geom_list + med_list + smesh_list
395 # E.A. : sort by len before substitution ...
396 # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
397 # And you understand ...
399 full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
401 for key in full_list:
402 content = content.replace("-l%s"%(key), "${%s}"%(key))
407 # Split content in lines to treat each one separately
409 lines = content.split('\n')
412 # newlines contains the lines of the future CMakeLists.txt file
417 # opened_ifs is used to deals with nested conditionnals
422 # the __thedict__ dictionnary contains key, val
423 # of the Makefile.am file
425 self.__thedict__ = {}
428 # Initialize file ... mainly includes other cmake files
430 self.initialize(newlines)
433 # Do the job for each line
436 self.treatLine(line, newlines, opened_ifs)
440 # Finalize file ... it is in here the cmake job is done
442 self.finalize(newlines)
445 # Concatenate newlines into content
447 content = '\n'.join(newlines)
450 # Add a CR at end if necessary
452 lines = content.split('\n')
453 # lines = [ l.strip() for l in lines ]
454 if len(lines[-1]) != 0:
457 content = '\n'.join(lines)
460 self.content = "# ---------------------------------------------------------------------\n"
461 self.content += "# This file was automatically generated by am2cmake (erwan.adam@cea.fr)\n"
462 self.content += "# ---------------------------------------------------------------------\n"
463 self.content += content
468 def initialize(self, newlines):
469 if self.root == self.the_root:
472 CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
473 IF(COMMAND cmake_policy)
474 cmake_policy(SET CMP0003 NEW)
475 ENDIF(COMMAND cmake_policy)
484 """%(self.module.upper()))
486 if self.module == "netgen":
488 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindPLATFORM.cmake)
489 INCLUDE(${CMAKE_SOURCE_DIR}/cmake/FindCAS.cmake)
492 if self.module == "kernel":
494 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
495 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
496 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
497 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
498 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
499 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
500 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
501 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
502 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
503 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
504 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
505 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
506 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
510 if self.module == "med":
512 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
514 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
515 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
516 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
517 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
518 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
519 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
520 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
521 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
522 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
523 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
524 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
525 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
526 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
527 ELSE(KERNEL_ROOT_DIR)
528 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
529 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
530 ENDIF(KERNEL_ROOT_DIR)
534 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
535 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
536 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
537 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
538 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
539 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
540 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
541 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
542 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
543 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
544 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
545 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
546 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBBATCH.cmake)
547 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
550 if self.module == "gui":
552 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
553 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
554 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
555 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
556 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
557 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
561 SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
563 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
564 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
565 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
566 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
567 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
568 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
569 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
572 if self.module == "med":
573 #METIS must be after PARMETIS to prevent to activate METIS if PARMETIS already exists
575 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindPARMETIS.cmake)
576 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMETIS.cmake)
577 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSCOTCH.cmake)
578 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSPLITTER.cmake)
579 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindRENUMBER.cmake)
580 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
582 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
586 if self.module == "smesh":
588 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
589 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
590 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
591 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
592 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
593 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
596 if self.module == "geom":
598 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
602 if self.module == "netgenplugin":
604 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
605 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
606 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
607 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
608 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
609 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
610 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
613 if self.module == "blsurfplugin":
615 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
616 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
617 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
618 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
619 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
620 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
621 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
624 if self.module in ["ghs3dplugin", "hexoticplugin"]:
626 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
627 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
628 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
629 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
630 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
631 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
634 if self.module == "ghs3dprlplugin":
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/FindMEDFILE.cmake)
641 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
642 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
645 if self.module == "visu":
647 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
648 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
651 if self.module == "yacs":
653 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
654 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
655 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSPHINX.cmake)
658 if self.module == "hxx2salome":
660 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
661 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
662 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
672 if self.module not in ['med']:
680 if self.module == "kernel":
684 SET(CALCIUM_IDL_INT_F77 long)
685 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
688 elif self.module == "gui":
690 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
691 SET(ENABLE_VTKVIEWER ON)
692 SET(ENABLE_SALOMEOBJECT ON)
693 SET(ENABLE_OCCVIEWER ON)
694 SET(ENABLE_GLVIEWER ON)
695 SET(ENABLE_PLOT2DVIEWER ON)
696 SET(ENABLE_PYCONSOLE ON)
697 SET(ENABLE_SUPERVGRAPHVIEWER ON)
698 SET(ENABLE_QXGRAPHVIEWER ON)
701 elif self.module == "jobmanager":
708 elif self.module == "geom":
711 SET(GEOM_ENABLE_GUI ON)
715 elif self.module == "medfile":
717 SET(MED_NUM_MAJEUR 3)
718 SET(MED_NUM_MINEUR 0)
719 SET(MED_NUM_RELEASE 3)
722 SET(FLIBS -lgfortranbegin -lgfortran)
726 elif self.module == "med":
729 SET(MED_ENABLE_KERNEL ON)
731 SET(MED_ENABLE_SPLITTER ON)
733 ENDIF(KERNEL_ROOT_DIR)
735 SET(MED_ENABLE_GUI ON)
739 elif self.module == "smesh":
742 SET(SMESH_ENABLE_GUI ON)
746 elif self.module == "netgen":
748 SET(OCCFLAGS ${CAS_CPPFLAGS})
749 SET(OCCLIBS ${CAS_LDPATH})
750 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
751 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
752 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
755 elif self.module == "netgenplugin":
758 SET(NETGENPLUGIN_ENABLE_GUI ON)
762 elif self.module == "blsurfplugin":
765 SET(BLSURFPLUGIN_ENABLE_GUI ON)
769 elif self.module == "ghs3dplugin":
772 SET(GHS3DPLUGIN_ENABLE_GUI ON)
776 elif self.module == "hexoticplugin":
779 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
783 elif self.module == "ghs3dprlplugin":
786 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
790 elif self.module == "yacs":
792 SET(SALOME_KERNEL ON)
800 set(SHORT_VERSION 6.5)
801 set(XVERSION 0x060500)
806 SET(VERSION_INFO 0.0.0)
807 SET(SOVERSION_INFO 0)
810 SET(AM_CPPFLAGS -I${CMAKE_BINARY_DIR} )
811 SET(AM_CXXFLAGS -I${CMAKE_BINARY_DIR})
813 SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
814 SET(salomepythondir ${pythondir}/salome)
815 SET(salomepypkgdir ${salomepythondir}/salome)
818 if self.module == "smesh" and self.root[-len('SMESH_PY'):] == 'SMESH_PY':
820 SET(smeshpypkgdir ${salomepythondir}/salome/smesh)
823 if self.module == "netgen":
825 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_CURRENT_SOURCE_DIR})
827 elif self.module == "kernel":
829 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
830 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
833 if self.module not in ["yacs"]:
836 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
837 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
838 ENDIF(KERNEL_ROOT_DIR)
841 if self.module == "gui":
844 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
845 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
846 ENDIF(KERNEL_ROOT_DIR)
849 if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin", "hexoticplugin"]:
851 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
852 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
855 if self.module == "ghs3dplugin":
856 # TODO: Auto-detect TetGen-GHS3D version automatically
858 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DGHS3D_VERSION=42)
859 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DGHS3D_VERSION=42)
862 if self.module == "hxx2salome":
864 if self.the_root[-len(key):] != key:
865 msg = "Source dir must finished with %s !"%(key)
867 hxxmodule = self.the_root[:-len(key)]
868 from os.path import basename
869 hxxmodule = basename(hxxmodule)
870 hxxmodule = hxxmodule.lower()
871 self.hxxmodule = hxxmodule
873 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
874 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
875 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
876 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
877 '''%(hxxmodule.upper()))
883 def treatLine(self, line, newlines, opened_ifs):
886 # Print the comment above the line itself
888 if line.find('#') >= 0:
889 fields = line.split('#')
891 comment = '#'.join([''] + fields[1:])
892 newlines.append(comment)
898 # If the line begins with 'include ', just comment it
900 if line.find("include ") == 0:
901 if line.find("include $(top_srcdir)/config/automake.common") == 0:
903 "MAINTAINERCLEANFILES = Makefile.in",
904 "AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
905 "AM_FFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
906 "AM_FCFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
907 "AM_CPPFLAGS+=@HDF5_CPPFLAGS@",
908 "AM_LDFLAGS=@HDF5_LDFLAGS@",
910 self.treatLine(l, newlines, opened_ifs)
914 newlines.append("# " + line)
919 # If the line begins with '-include', just comment it
921 if line.find("-include") == 0:
922 newlines.append("# " + line)
926 # If the line is a definition of a make rule, just comment it
928 if line.count(':') == 1:
929 newlines.append("# " + line)
933 # A particuliar case where there are two ":" on the same line
935 if line.find('install-exec-local:') == 0:
936 newlines.append("# " + line)
940 # If the line begin by a tabulation, consider it's a makefile command and comment it
942 if line.find("\t") == 0:
943 newlines.append("# " + line)
948 key = "-version-info"
949 if line.find(key) >= 0:
951 before = line.split(key)[0]
952 after = line[len(before)+len(key):]
955 version_info = after.split()[0]
956 line = line.replace(key+sep+version_info, "")
958 version_info = version_info.replace(':', '.')
959 soversion_info = version_info.split('.')[0]
960 newlines.append("SET(VERSION_INFO " + version_info + ")")
961 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
966 # Replace the $(TOTO) by ${TOTO}
967 # Replace the @TOTO@ by ${TOTO}
969 line = p_dollar.sub(r"${\1}", line)
970 line = p_arobas.sub(r"${\1}", line)
973 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
974 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
975 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
976 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
977 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
980 # Check if the line is a 'if' condition
981 # If yes, replace it by a cmake grammar
983 match = p_if.match(line)
985 theif = match.group("val")
987 theif = "NOT " + theif[1:]
989 line = p_if.sub(r"IF(%s)"%(theif), line)
990 opened_ifs.append(theif)
991 newlines.append(line)
995 # Check if the line is a 'else' condition
996 # If yes, replace it by a cmake grammar
998 match = p_else.match(line)
1000 line = "ELSE(%s)"%(opened_ifs[-1])
1001 newlines.append(line)
1005 # Check if the line is a 'endif' condition
1006 # If yes, replace it by a cmake grammar
1008 match = p_endif.match(line)
1010 line = "ENDIF(%s)"%(opened_ifs[-1])
1011 opened_ifs[-1:] = []
1012 newlines.append(line)
1016 # Check if the line is an attribution '=' or '+='
1018 match = p_attribution.match(line)
1020 self.treatAttribution(match, newlines)
1024 newlines.append(line)
1029 def treatAttribution(self, match, newlines):
1031 spaces = match.group("spaces")
1032 key = match.group("key")
1033 method = match.group("method")
1034 value = match.group("value")
1035 # print [spaces, key, method, value]
1038 # Open cmake SET command
1040 newlines.append(spaces + "SET(" + key)
1043 # If method is '+=', put the previous definition as first value
1046 newlines.append("%s ${%s}"%(spaces, key))
1050 fields = value.split()
1052 for i in range(len(fields)):
1053 newlines.append("%s %s"%(spaces, fields[i]))
1059 # The try: except KeyError is here if the +=
1060 # is an error which occurs in salome ...
1063 self.__thedict__[key] += fields[:]
1065 self.__thedict__[key] = fields[:]
1069 self.__thedict__[key] = fields[:]
1073 # Close cmake SET command
1076 newlines.append("%s)"%(spaces))
1080 def finalize(self, newlines):
1083 # Convert the .in files in build dir
1086 if self.module == "hexoticplugin" :
1087 upmod = "HexoticPLUGIN"
1089 upmod = self.module.upper()
1093 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1094 newlines.append(r'''
1102 ${CMAKE_CURRENT_SOURCE_DIR}
1105 ${CMAKE_CURRENT_BINARY_DIR}
1108 ${CMAKE_INSTALL_PREFIX}/share
1111 ${datadir}/doc/salome
1114 self.files.append("static/header.html.in")
1115 elif self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc') or mod in ['kernel', 'gui', 'geom', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1116 newlines.append(r'''
1124 ${CMAKE_CURRENT_SOURCE_DIR}
1127 ${CMAKE_CURRENT_BINARY_DIR}
1130 ${CMAKE_INSTALL_PREFIX}/share
1133 ${datadir}/doc/salome
1136 self.files.append("static/header.html.in")
1137 if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1138 self.files.append("static/header_py.html.in")
1140 if self.module == "yacs":
1142 if self.root[-len(key):] == key:
1143 self.files.append("resources/YACSCatalog.xml.in")
1144 self.files.append("resources/SalomeApp.xml.in")
1148 if operator.contains(self.root, 'YACS_SRC'+path.sep+'doc'):
1149 newlines.append(r'''
1151 ${CMAKE_CURRENT_SOURCE_DIR}
1155 if self.module == "jobmanager":
1157 if self.root[-len(key):] == key:
1158 self.files.append("resources/SalomeApp.xml.in")
1161 for f in self.files:
1163 if self.module == 'yacs' and f == "Doxyfile.in":
1165 if f == "sstream.in":
1167 if f in ["runContainer.in", "stopContainer.in"]:
1168 if self.module == "med":
1169 if self.root[-3:] == "csh":
1173 if f == "SALOMEconfig.ref.in":
1174 out = "SALOMEconfig.h"
1178 newlines.append(r'''
1179 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1181 newlines.append(r'''
1182 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1184 newlines.append(r'''
1185 MESSAGE(STATUS "Creation of ${output}")
1186 CONFIGURE_FILE(${input} ${output})
1192 # add commands for generating of user's documentation
1194 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1195 doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1196 doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1197 head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1199 prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1201 prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1202 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1204 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1205 input = "Doxyfile_med_user"
1207 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1209 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1210 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1212 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1213 )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1215 if mod in ['geom', 'smesh', 'visu', 'netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin','ghs3dprlplugin'] and self.root[-len(mod):] == upmod and operator.contains(self.root, 'doc'):
1216 ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1217 if mod in ['geom', 'smesh']:
1220 input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1224 newlines.append(r"""
1226 STRING(REPLACE "/" "\\" f "%s")
1230 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} %s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1231 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1232 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1233 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1234 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''')"
1236 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1237 )"""%(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))
1240 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1241 config_f = "doxyfile_py"
1243 config_f = "doxyfile_idl"
1244 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1245 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1246 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''')"
1248 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1249 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1250 elif mod == 'yacs' and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1251 from sys import platform
1253 if platform == "win32":
1255 newlines.append(r"""
1256 ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1257 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1258 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1259 elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1260 from sys import platform
1264 if platform == "win32":
1271 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1272 scr = self.writeEnvScript(upmod)
1273 newlines.append(r"""
1275 STRING(REPLACE "/" "\\" SCR "%s")
1279 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1280 ADD_CUSTOM_TARGET(html_docs %s ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s && ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc/docutils -W -b html ${ALLSPHINXOPTS} html
1281 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1282 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(scr,scr,ext,prf,ext,params, doc_gui_destination, doc_gui_destination))
1288 # add commands for generating of developer's documentation
1291 upmod = self.module.upper()
1292 if mod in ['kernel', 'gui', 'med', 'smesh', 'visu'] and self.root[-len('tui'):] == 'tui':
1294 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1295 COMMAND ${DOXYGEN_EXECUTABLE}
1296 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')" """
1299 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1301 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)
1302 elif mod == 'smesh':
1303 extra_srcdir = "${CMAKE_CURRENT_SOURCE_DIR}/extra"
1304 tmp1= """\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.pdf''', r'''%s'''); copy(r'''%s/PluginMeshers.html''', r'''%s''')"
1305 COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''%s/AddNetgenInSalome2.ps''', r'''%s'''); copy(r'''%s/AddNetgenInSalome2.sxw''', r'''%s''')" """%(doc_tui_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination, extra_srcdir,doc_destination,extra_srcdir,doc_destination)
1308 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1309 newlines.append(tmp + """
1310 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')" """%(doc_tui_destination, doc_source, doc_tui_destination, head_source, doc_tui_destination) + tmp1 + """
1312 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1314 if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1316 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1317 newlines.append(r"""
1319 STRING(REPLACE "/" "\\" f "%s")
1323 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
1324 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1325 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1326 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''')"
1328 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1329 )"""%(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))
1332 # convert the SUBDIRS in cmake grammar
1334 if 1: # self.__thedict__.has_key("SUBDIRS"):
1335 newlines.append(r'''
1336 FOREACH(dir ${SUBDIRS})
1337 IF(NOT dir STREQUAL .)
1338 ADD_SUBDIRECTORY(${dir})
1339 ENDIF(NOT dir STREQUAL .)
1340 ENDFOREACH(dir ${SUBDIRS})
1346 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1347 if self.__thedict__.has_key(key):
1348 self.addLibTarget(key, newlines)
1354 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1355 if self.__thedict__.has_key(key):
1356 self.addBinTarget(key, newlines)
1362 if self.__thedict__.has_key("BASEIDL_FILES"):
1363 if not self.__thedict__.has_key("IDL_FILES"):
1364 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1366 SET(IDL_FILES ${BASEIDL_FILES})
1375 if self.__thedict__.has_key(key):
1376 if self.module == "kernel":
1378 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1382 FOREACH(input ${IDL_FILES})
1383 STRING(REGEX REPLACE ".idl" "" base ${input})
1384 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1386 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1387 SET(outputs ${outputs} ${dynsrc})
1388 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1389 SET(outputs ${outputs} ${inc})
1390 IF(input STREQUAL Calcium_Ports.idl)
1391 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1392 ELSE(input STREQUAL Calcium_Ports.idl)
1393 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1394 ENDIF(input STREQUAL Calcium_Ports.idl)
1395 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1396 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1398 SET(flags -bcxx ${flags})
1402 COMMAND ${OMNIORB_IDL} ${flags} ${input}
1403 MAIN_DEPENDENCY ${input}
1407 install(FILES ${input} DESTINATION idl/salome)
1409 if self.module not in ["pyhello"]:
1411 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1412 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1416 INSTALL(CODE "SET(IDL_FILE ${input})")
1417 INSTALL(CODE "SET(DIR ${salomepythondir})")
1419 INSTALL(CODE "SET(DIR bin/salome)")
1421 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1422 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1425 FOREACH(f ${IDLPYFLAGS})
1426 SET(flags "${flags} ${f}")
1427 ENDFOREACH(f ${IDLPYFLAGS})
1428 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1430 SET(flags "-bpython ${flags}")
1431 ENDIF(NOT ISBPYTHON)
1432 SET(IDLPYFLAGS ${flags})
1433 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1434 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1437 if self.module == "kernel":
1439 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1443 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1444 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1448 ENDFOREACH(input ${IDL_FILES})
1454 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1455 if self.__thedict__.has_key(key):
1457 SET(SWIG_SOURCES ${%s})
1459 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1465 if self.__thedict__.has_key("SWIG_SOURCES"):
1467 IF(SWIG_SOURCES MATCHES ";")
1468 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1469 ELSE(SWIG_SOURCES MATCHES ";")
1470 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1471 ENDIF(SWIG_SOURCES MATCHES ";")
1473 FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1476 LIST(FIND flags ${f} index)
1477 IF(NOT index EQUAL -1)
1479 ENDIF(NOT index EQUAL -1)
1482 SET(flags ${flags} ${f})
1484 ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1486 OUTPUT ${build_srcs}
1487 COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1488 MAIN_DEPENDENCY ${SWIG_SOURCES}
1495 if self.__thedict__.has_key("BUILT_SOURCES"):
1497 FOREACH(f ${BUILT_SOURCES})
1498 IF(f MATCHES "WRAP.cxx$")
1499 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1500 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1502 OUTPUT ${f} # ${inc}
1503 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1504 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1506 ENDIF(f MATCHES "WRAP.cxx$")
1507 ENDFOREACH(f ${BUILT_SOURCES})
1514 if self.__thedict__.has_key(key):
1516 FOREACH(output ${MOC_FILES})
1518 if self.module in ["jobmanager", "yacs"]:
1520 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1524 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1528 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1529 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1532 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1533 MAIN_DEPENDENCY ${input}
1535 ENDFOREACH(output ${MOC_FILES})
1541 key = "MOC_FILES_HXX"
1542 if self.__thedict__.has_key(key):
1544 FOREACH(output ${MOC_FILES_HXX})
1547 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1550 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1551 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1554 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1555 MAIN_DEPENDENCY ${input}
1557 ENDFOREACH(output ${MOC_FILES_HXX})
1564 if self.__thedict__.has_key(key):
1566 FOREACH(output ${UIC_FILES})
1567 STRING(REPLACE "ui_" "" input ${output})
1568 STRING(REPLACE ".h" ".ui" input ${input})
1569 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1570 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1573 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1574 MAIN_DEPENDENCY ${input}
1576 ENDFOREACH(output ${UIC_FILES})
1583 if self.__thedict__.has_key(key):
1585 FOREACH(output ${PYUIC_FILES})
1586 STRING(REPLACE "_ui.py" ".ui" input ${output})
1587 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1588 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1591 COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1592 MAIN_DEPENDENCY ${input}
1594 ENDFOREACH(output ${PYUIC_FILES})
1595 ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1602 if self.__thedict__.has_key(key):
1604 FOREACH(output ${QRC_FILES})
1605 STRING(REGEX REPLACE "qrc_" "" input ${output})
1606 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1607 STRING(REGEX REPLACE ".qrc" "" name ${input})
1608 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1609 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1612 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1613 MAIN_DEPENDENCY ${input}
1615 ENDFOREACH(output ${QRC_FILES})
1622 if self.__thedict__.has_key(key):
1624 FOREACH(input ${SIP_FILES})
1625 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1627 FOREACH(out ${SIP_SRC})
1628 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1629 ENDFOREACH(out ${SIP_SRC})
1632 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1633 MAIN_DEPENDENCY ${input}
1635 ENDFOREACH(input ${SIP_FILES})
1640 # For GUI/tools/dlgfactory
1642 key = "UIC_FILES_QDIALOG"
1643 if self.__thedict__.has_key(key):
1645 FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1646 STRING(REPLACE "ui_" "" input ${output})
1647 STRING(REPLACE ".hxx" ".ui" input ${input})
1648 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1649 IF (NOT EXISTS ${input_path})
1650 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1651 ENDIF (NOT EXISTS ${input_path})
1654 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1655 MAIN_DEPENDENCY ${input}
1657 ENDFOREACH(output ${UIC_FILES})
1659 FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1660 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1661 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1662 IF (NOT EXISTS ${input_path})
1663 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1664 ENDIF (NOT EXISTS ${input_path})
1667 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1668 MAIN_DEPENDENCY ${input}
1670 ENDFOREACH(output ${MOC_FILES})
1673 OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1674 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1675 DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1679 OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1680 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1681 DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1689 for key in ["TESTS"]:
1690 if self.__thedict__.has_key(key):
1692 SET(UNIT_TEST_PROG ${%s})
1694 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1697 key = "UNIT_TEST_PROG"
1698 if self.__thedict__.has_key(key):
1700 FOREACH(input ${UNIT_TEST_PROG})
1701 GET_FILENAME_COMPONENT(ext ${input} EXT)
1702 IF(ext STREQUAL .py)
1703 SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1704 ELSE(ext STREQUAL .py)
1706 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1708 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1710 ENDIF(ext STREQUAL .py)
1711 ADD_TEST(${input} ${test})
1712 SET(fail_regex "KO")
1713 SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1715 # ADD_TEST(${input}_valgrind valgrind ${test})
1716 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1717 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1719 ENDFOREACH(input ${UNIT_TEST_PROG})
1724 # Treat the install targets
1726 resdir = self.module
1727 if resdir == "hxx2salome":
1728 resdir = self.hxxmodule
1731 "salomeadmux_DATA" : "salome_adm/unix",
1732 "dist_salomeadmux_DATA" : "salome_adm/unix",
1733 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1734 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1735 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1736 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1737 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1738 "salomeinclude_DATA" : "include/salome",
1739 "salomeinclude_HEADERS" : "include/salome",
1740 "nodist_salomeinclude_HEADERS" : "include/salome",
1741 "dist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1742 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1743 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(resdir),
1744 "dist_salomescript_SCRIPTS" : "bin/salome",
1745 "dist_salomescript_DATA" : "bin/salome",
1746 "dist_salomescript_PYTHON" : "bin/salome",
1747 "dist_appliskel_SCRIPTS" : "bin/salome/appliskel",
1748 "dist_appliskel_PYTHON" : "bin/salome/appliskel",
1749 "nodist_salomescript_DATA" : "bin/salome",
1750 "salomepython_PYTHON" : "${salomepythondir}",
1751 "nodist_salomepython_PYTHON" : "${salomepythondir}",
1752 "dist_salomepython_DATA" : "${salomepythondir}",
1753 "sharedpkgpython_PYTHON" : "${salomepythondir}/shared_modules",
1754 "salomepypkg_PYTHON" : "${salomepypkgdir}",
1755 "mypkgpython_PYTHON" : "${mypkgpythondir}",
1756 "nodist_mypkgpython_PYTHON" : "${mypkgpythondir}",
1758 if self.module == "jobmanager":
1759 d["bin_SCRIPTS"] = "bin"
1761 if self.module == "medfile":
1763 "include_HEADERS" : "include",
1764 "nodist_include_HEADERS" : "include",
1765 "bin_SCRIPTS" : "bin",
1766 "doc_DATA" : "${docdir}",
1769 if self.module == "netgen":
1771 "include_HEADERS" : "include",
1772 "noinst_HEADERS" : "share/netgen/include",
1773 "dist_pkgdata_DATA" : "share/netgen",
1774 "dist_doc_DATA" : "share/doc/netgen",
1777 for key, value in d.items():
1778 if self.__thedict__.has_key(key):
1779 self.addInstallTarget(key, value, newlines)
1786 def setLibAdd(self, key, newlines):
1788 newlines.append(r'''
1792 newlines.append(r'''
1795 SET(targets ${targets} MEFISTO2D)
1796 FOREACH(target ${targets})
1797 IF(name STREQUAL ${target})
1798 SET(dir $ENV{F2CHOME})
1799 STRING(REPLACE "\\\\" "/" dir ${dir})
1800 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1801 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1802 ENDIF(name STREQUAL ${target})
1803 ENDFOREACH(target ${targets})
1806 SET(targets ${targets} MEFISTO2D)
1807 FOREACH(target ${targets})
1808 IF(name STREQUAL ${target})
1809 SET(libadd ${libadd} -lf2c)
1810 ENDIF(name STREQUAL ${target})
1811 ENDFOREACH(target ${targets})
1815 newlines.append(r'''
1816 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1817 FOREACH(lib SALOMEBasics SalomeBatch)
1818 IF(name STREQUAL lib)
1819 SET(libs ${libs} ${PTHREAD_LIBS})
1820 ENDIF(name STREQUAL lib)
1821 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1824 newlines.append(r'''
1825 FOREACH(lib ${libs})
1826 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1827 IF(ext STREQUAL .la)
1828 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1829 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1830 ENDIF(ext STREQUAL .la)
1832 SET(vars ${vars} -no-undefined)
1833 SET(vars ${vars} -lvtkWidgets)
1835 SET(vars ${vars} -module)
1836 SET(vars ${vars} -Wl,-E)
1837 SET(vars ${vars} -Xlinker)
1838 SET(vars ${vars} -export-dynamic)
1839 SET(vars ${vars} -lm)
1840 SET(vars ${vars} -lboost_thread)
1841 SET(vars ${vars} -lboost_signals)
1842 SET(vars ${vars} -pthread -lpthread -ldl)
1847 ENDIF(lib STREQUAL v)
1848 ENDFOREACH(v ${vars})
1851 STRING(REGEX MATCH "^-lQt" test ${lib})
1854 SET(libadd ${libadd} ${lib})
1856 ENDFOREACH(lib ${libs})
1857 TARGET_LINK_LIBRARIES(${name} ${libadd})
1860 newlines.append(r'''
1863 SET(targets ${targets} MEFISTO2D)
1864 FOREACH(target ${targets})
1865 IF(name STREQUAL ${target})
1866 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1867 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1868 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1869 ENDIF(name STREQUAL ${target})
1870 ENDFOREACH(target ${targets})
1876 def setCompilationFlags(self, key, newlines):
1877 newlines.append(r'''
1881 SET(targets ${targets} SalomeIDLKernel)
1882 SET(targets ${targets} SalomeDS)
1883 SET(targets ${targets} SALOMEDSTest)
1884 SET(targets ${targets} SALOMEDS_Client_exe)
1885 SET(targets ${targets} SalomeIDLGEOM)
1886 SET(targets ${targets} GEOMEngine)
1887 SET(targets ${targets} MEDEngine)
1888 SET(targets ${targets} SMESHEngine)
1889 SET(targets ${targets} SMESH)
1890 SET(targets ${targets} SalomeIDLSPADDER)
1891 SET(targets ${targets} MeshJobManagerEngine)
1892 SET(targets ${targets} StdMeshersEngine)
1893 SET(targets ${targets} VISUEngineImpl)
1894 FOREACH(target ${targets})
1895 IF(name STREQUAL ${target})
1896 SET(var ${var} -DNOGDI)
1897 ENDIF(name STREQUAL ${target})
1898 ENDFOREACH(target ${targets})
1902 if self.module in ["medfile", "yacs"]:
1903 newlines.append(r'''
1905 SET(var ${var} -DNOGDI)
1910 newlines.append(r'''
1913 SET(targets ${targets} MEFISTO2D)
1914 FOREACH(target ${targets})
1915 IF(name STREQUAL ${target})
1916 SET(dir $ENV{F2CHOME})
1917 STRING(REPLACE "\\\\" "/" dir ${dir})
1918 SET(var ${var} -I${dir})
1919 SET(var ${var} -DF2C_BUILD)
1920 ENDIF(name STREQUAL ${target})
1921 ENDFOREACH(target ${targets})
1925 if self.module in ["geom", "med"]:
1926 newlines.append(r'''
1927 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1928 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1931 newlines.append(r'''
1932 SET(var ${var} ${AM_CPPFLAGS})
1933 SET(var ${var} ${AM_CXXFLAGS})
1936 newlines.append(r'''
1937 IF(type STREQUAL STATIC)
1938 SET(var ${var} -fPIC)
1939 ENDIF(type STREQUAL STATIC)
1942 if self.module == "yacs":
1943 newlines.append(r'''
1944 SET(var ${var} -DYACS_PTHREAD)
1945 SET(var ${var} -DCMAKE_BUILD)
1946 SET(var ${var} -DSALOME_KERNEL)
1947 SET(var ${var} -DDSC_PORTS)
1948 SET(var ${var} -DOMNIORB)
1951 newlines.append(r'''
1952 SET(var ${var} ${PLATFORM_CPPFLAGS})
1953 SET(var ${var} ${PTHREAD_CFLAGS})
1954 SET(var ${var} ${${amname}_CPPFLAGS})
1955 SET(var ${var} ${${amname}_CXXFLAGS})
1956 SET(var ${var} ${${amname}_CFLAGS})
1959 SET(vars ${vars} -include SALOMEconfig.h)
1960 SET(vars ${vars} -ftemplate-depth-32)
1961 SET(vars ${vars} -fPIC)
1962 SET(vars ${vars} -g)
1970 ENDFOREACH(v ${vars})
1972 string(REGEX MATCH "^-I" test_include ${f})
1974 string(REGEX REPLACE "^-I" "" include_dir ${f})
1976 if(include_dir STREQUAL /usr/include)
1977 else(include_dir STREQUAL /usr/include)
1978 string(REGEX MATCH "^\\." test_dot ${include_dir})
1980 set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
1982 include_directories(${include_dir})
1983 endif(include_dir STREQUAL /usr/include)
1986 SET(flags "${flags} ${f}")
1989 ENDFOREACH(f ${var})
1990 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1994 def addLibTarget(self, key, newlines):
1995 newlines.append(r'''
1996 FOREACH(amname ${%s})
1999 # Replace .la by _la ...
2001 newlines.append(r'''
2002 STRING(REPLACE .la _la amname ${amname})
2005 # Remove the _la for the cmake name
2007 newlines.append(r'''
2008 STRING(LENGTH ${amname} len)
2009 MATH(EXPR newlen "${len}-3")
2010 STRING(SUBSTRING ${amname} 0 ${newlen} name)
2013 # Does the target begins with lib ??
2014 # If yes, remove lib at beginning for cmake name
2016 newlines.append(r'''
2017 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2019 STRING(LENGTH ${name} len)
2020 MATH(EXPR newlen "${len}-3")
2021 STRING(SUBSTRING ${name} 3 ${newlen} name)
2022 ENDIF(BEGIN_WITH_lib)
2025 # Does the target is an idl library
2027 newlines.append(r'''
2028 STRING(REGEX MATCH "IDL" ISIDL ${name})
2031 # Set the type of the library
2033 newlines.append(r'''
2044 if key == "noinst_LTLIBRARIES":
2045 newlines.append(r'''
2054 # Set sources for the library
2056 newlines.append(r'''
2058 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2059 GET_FILENAME_COMPONENT(ext ${src} EXT)
2061 IF(src STREQUAL trte.f)
2062 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2063 STRING(REPLACE ".f" ".c" src ${src})
2064 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2068 IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2069 SET(cmd valgrind f2c) # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2074 COMMAND ${cmd} ${input}
2075 MAIN_DEPENDENCY ${input}
2077 ELSE(src STREQUAL trte.f)
2078 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2079 STRING(REPLACE ".f" ".o" src ${src})
2080 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2089 COMMAND ${F77} -c -o ${output} ${input}
2090 MAIN_DEPENDENCY ${input}
2092 ENDIF(src STREQUAL trte.f)
2093 ENDIF(ext STREQUAL .f)
2094 SET(srcs ${srcs} ${src})
2095 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2097 newlines.append(r'''
2098 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2100 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2101 SET(srcs ${srcs} ${src})
2104 newlines.append(r'''
2106 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2108 GET_FILENAME_COMPONENT(ext ${f} EXT)
2109 IF(ext STREQUAL .py)
2111 ELSE(ext STREQUAL .py)
2112 SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2113 ENDIF(ext STREQUAL .py)
2116 LIST(FIND build_srcs ${fff} index)
2117 IF(NOT index EQUAL -1)
2119 ENDIF(NOT index EQUAL -1)
2123 SET(build_srcs ${build_srcs} ${fff})
2128 # Add the library to cmake
2130 newlines.append(r'''
2131 ADD_LIBRARY(${name} ${type} ${srcs})
2134 # The compilation flags
2136 self.setCompilationFlags(key, newlines)
2138 newlines.append(r'''
2139 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2142 self.setLibAdd(key, newlines)
2144 if 1: # key != "noinst_LTLIBRARIES":
2145 newlines.append(r'''
2148 newlines.append(r'''
2150 IF(${key} STREQUAL noinst_LTLIBRARIES)
2152 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2154 if self.module == "netgen" :
2155 newlines.append(r'''
2156 IF(${key} STREQUAL noinst_LTLIBRARIES)
2160 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2163 newlines.append(r'''
2166 if self.module in ["medfile", "netgen"]:
2167 newlines.append(r'''
2170 elif key == "libparaview_LTLIBRARIES":
2171 newlines.append(r'''
2172 SET(DEST lib/paraview)
2175 newlines.append(r'''
2176 SET(DEST lib/salome)
2179 newlines.append(r'''
2181 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2183 if self.module == "gui":
2184 newlines.append(r'''
2185 FOREACH(lib SalomePyQt)
2186 IF(name STREQUAL lib)
2188 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2189 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2190 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2191 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2192 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2194 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2196 ENDIF(name STREQUAL lib)
2197 ENDFOREACH(lib SalomePyQt)
2198 FOREACH(lib SalomePy)
2199 IF(name STREQUAL lib)
2201 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2202 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2203 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2204 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2205 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2207 ENDIF(name STREQUAL lib)
2208 ENDFOREACH(lib SalomePy)
2211 if self.module == "geom":
2212 newlines.append(r'''
2214 STRING(REGEX MATCH "Export" ISExport ${name})
2216 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2218 STRING(REGEX MATCH "Import" ISImport ${name})
2220 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2225 newlines.append(r'''
2226 ELSE(BEGIN_WITH_lib)
2228 newlines.append(r'''
2230 INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2231 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2232 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2233 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2234 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2235 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2237 GET_TARGET_PROPERTY(version ${name} VERSION)
2238 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2239 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2240 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2241 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2244 newlines.append(r'''
2245 ENDIF(BEGIN_WITH_lib)
2247 newlines.append(r'''
2252 newlines.append(r'''
2253 ENDFOREACH(amname ${%s})
2258 def addBinTarget(self, key, newlines):
2260 newlines.append(r'''
2261 FOREACH(amname ${%s})
2264 newlines.append(r'''
2267 if key == "check_PROGRAMS":
2268 newlines.append(r'''
2270 STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2277 newlines.append(r'''
2281 newlines.append(r'''
2282 SET(name "${amname}_exe")
2283 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2284 SET(l ${nodist_${amname}_SOURCES})
2286 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2287 SET(srcs ${srcs} ${src})
2289 LIST(LENGTH srcs nb)
2291 ADD_EXECUTABLE(${name} ${srcs})
2294 self.setCompilationFlags(key, newlines)
2296 self.setLibAdd(key, newlines)
2298 if self.module in ["jobmanager", "medfile", "netgen"]:
2299 newlines.append(r'''
2303 newlines.append(r'''
2304 SET(DEST bin/salome)
2308 if key == "bin_PROGRAMS":
2309 newlines.append(r'''
2311 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2312 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2313 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2316 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2317 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2318 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2319 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2324 newlines.append(r'''
2328 newlines.append(r'''
2331 newlines.append(r'''
2332 ENDFOREACH(amname ${%s})
2337 def addInstallTarget(self, key, destination, newlines):
2338 newlines.append(r"FOREACH(f ${%s})"%(key))
2339 newlines.append(r'''
2342 newlines.append(r'''
2343 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2344 IF(test_SALOMEconfig.h.in)
2345 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2346 ELSE(test_SALOMEconfig.h.in)
2347 SET(dummy dummy-NOTFOUND)
2348 MARK_AS_ADVANCED(dummy)
2349 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2350 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2353 if key in ['dist_salomescript_SCRIPTS',
2354 'dist_appliskel_SCRIPTS',
2355 'dist_appliskel_PYTHON']:
2356 newlines.append(r'''
2358 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2359 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2360 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2361 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2364 newlines.append(r'''
2365 GET_FILENAME_COMPONENT(ext ${f} EXT)
2366 IF(ext STREQUAL .py)
2367 IF(DEST STREQUAL bin/salome)
2369 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2370 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2371 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2372 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2373 ELSE(DEST STREQUAL bin/salome)
2374 INSTALL(FILES ${f} DESTINATION ${DEST})
2375 ENDIF(DEST STREQUAL bin/salome)
2376 ELSE(ext STREQUAL .py)
2377 INSTALL(FILES ${f} DESTINATION ${DEST})
2378 ENDIF(ext STREQUAL .py)
2381 newlines.append(r'''
2383 GET_FILENAME_COMPONENT(ext ${f} EXT)
2384 IF(ext STREQUAL .qm)
2385 STRING(REGEX REPLACE .qm .ts input ${f})
2387 if self.module in ["kernel", "gui", "yacs"]:
2388 newlines.append(r'''
2389 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2392 newlines.append(r'''
2393 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2396 newlines.append(r'''
2397 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2398 # ADD_CUSTOM_COMMAND(
2400 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2401 # MAIN_DEPENDENCY ${input}
2403 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2404 ENDIF(ext STREQUAL .qm)
2405 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2407 ENDIF(test_SALOMEconfig.h.in)
2409 newlines.append(r'''
2410 GET_FILENAME_COMPONENT(ext ${f} EXT)
2411 IF(ext STREQUAL .py)
2412 INSTALL(CODE "SET(PYTHON_FILE ${f})")
2413 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2414 INSTALL(CODE "SET(DEST ${DEST})")
2415 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2417 if self.module == "kernel":
2419 IF(f STREQUAL SALOME_ContainerPy.py)
2420 ELSE(f STREQUAL SALOME_ContainerPy.py)
2421 IF(f STREQUAL am2cmake.py)
2422 ELSE(f STREQUAL am2cmake.py)
2423 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2424 ENDIF(f STREQUAL am2cmake.py)
2425 ENDIF(f STREQUAL SALOME_ContainerPy.py)
2429 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2430 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2433 newlines.append(r'''
2434 ENDIF(ext STREQUAL .py)
2436 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2439 def writeListsFile(self):
2440 f = open(self.listsFile, "w")
2441 f.write(self.content)
2445 def writeEnvScript(self, upmod):
2446 from sys import platform, version_info
2447 p_version = """%s.%s"""%(version_info[0],version_info[1])
2448 python_path ="PYTHONPATH"
2457 if platform == "win32" :
2467 path = "LD_LIBRARY_PATH"
2472 omni_py = "/python" + p_version + "/" + "site-packages"
2476 path_ = begin + path + end
2477 root_dir_ = begin + upmod + "_ROOT_DIR" + end
2478 python_path_ = begin + python_path + end
2479 _python_path_ = delim + python_path_+ "\n"
2480 _path_ = delim + path_+ "\n"
2481 _pdir = begin + pdir + end
2484 script = cmd + " " + python_path + "=" + root_dir_+"/lib/python" + p_version \
2485 + "/site-packages/salome" + _python_path_
2487 script = script + cmd + " " + python_path + "=" + root_dir_+"/bin/salome" + \
2490 script = script + cmd + " "+ path + "=" + root_dir_+"/lib/salome"+ _path_
2492 if upmod == "KERNEL" :
2493 script = script + cmd + " " + python_path + "=" + _pdir + \
2494 "/omniORB-4.1.5/lib" + omni + _python_path_
2496 script = script + cmd + " " + python_path + "=" + _pdir + \
2497 "/omniORB-4.1.5/lib" + omni_py + _python_path_
2499 script = script + cmd + " "+ path + "=" + _pdir+ "/omniORB-4.1.5/lib" + \
2502 if upmod == "GEOM" :
2503 script = self.writeEnvScript("KERNEL") + script
2504 script = self.writeEnvScript("GUI") + script
2506 if upmod == "SMESH" :
2507 script = self.writeEnvScript("GEOM") + script
2512 def convertAmFile(the_root, root, dirs, files, f, module):
2513 cmake = CMakeFile(the_root, root, dirs, files, f, module)
2514 cmake.writeListsFile()
2517 def usage(exit_status):
2518 from sys import exit
2519 from sys import argv
2520 print "Usage: %s --module"%(argv[0])
2524 if __name__ == "__main__":
2526 from sys import argv
2532 if module.find('--') != 0:
2536 if len(module) == 0:
2540 from os import getcwd
2545 from os import getenv
2547 for root, dirs, files in walk(the_root):
2549 # E.A. : Remove 'CVS' in dirs
2550 # E.A. : It allows to not recurse in CVS dirs
2551 # E.A. : See os module python documentation
2558 if "Makefile.am.cmake" in files:
2559 if "Makefile.am" in files:
2560 files.remove("Makefile.am")
2565 if f in ["Makefile.am", "Makefile.am.cmake"]:
2567 if getenv("AM2CMAKE_FORCE_GENERATION", "0")=="0":
2568 # detect if conversion should be done
2569 if "CMakeLists.txt" in files:
2570 from os.path import join
2571 ff = open(join(root, "CMakeLists.txt"))
2574 if content.find("generated by am2cmake") == -1:
2580 convertAmFile(the_root, root, dirs, files, f, module)
2586 from sys import stdout
2589 msg = "%s file has been converted to cmake"%(nok)
2591 msg = "%s files have been converted to cmake"%(nok)