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']:
686 if self.module == "kernel":
690 SET(CALCIUM_IDL_INT_F77 long)
691 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
694 elif self.module == "gui":
696 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
697 SET(ENABLE_VTKVIEWER ON)
698 SET(ENABLE_SALOMEOBJECT ON)
699 SET(ENABLE_OCCVIEWER ON)
700 SET(ENABLE_GLVIEWER ON)
701 SET(ENABLE_PLOT2DVIEWER ON)
702 SET(ENABLE_PYCONSOLE ON)
703 SET(ENABLE_SUPERVGRAPHVIEWER ON)
704 SET(ENABLE_QXGRAPHVIEWER ON)
707 elif self.module == "jobmanager":
714 elif self.module == "geom":
717 SET(GEOM_ENABLE_GUI ON)
721 elif self.module == "medfile":
723 SET(MED_NUM_MAJEUR 3)
724 SET(MED_NUM_MINEUR 0)
725 SET(MED_NUM_RELEASE 3)
728 SET(FLIBS -lgfortranbegin -lgfortran)
732 elif self.module == "med":
735 SET(MED_ENABLE_KERNEL ON)
737 SET(MED_ENABLE_SPLITTER ON)
739 ENDIF(KERNEL_ROOT_DIR)
741 SET(MED_ENABLE_GUI ON)
745 elif self.module == "smesh":
748 SET(SMESH_ENABLE_GUI ON)
752 elif self.module == "netgen":
754 SET(OCCFLAGS ${CAS_CPPFLAGS})
755 SET(OCCLIBS ${CAS_LDPATH})
756 SET(OCCLIBS ${OCCLIBS} ${TKernel} ${TKGeomBase} ${TKMath} ${TKG2d} ${TKG3d} ${TKXSBase} ${TKOffset} ${TKFillet} ${TKShHealing})
757 SET(OCCLIBS ${OCCLIBS} ${TKMesh} ${TKMeshVS} ${TKTopAlgo} ${TKGeomAlgo} ${TKBool} ${TKPrim} ${TKBO} ${TKIGES} ${TKBRep})
758 SET(OCCLIBS ${OCCLIBS} ${TKSTEPBase} ${TKSTEP} ${TKSTL} ${TKSTEPAttr} ${TKSTEP209} ${TKXDESTEP} ${TKXDEIGES} ${TKXCAF} ${TKLCAF} ${FWOSPlugin})
761 elif self.module == "netgenplugin":
764 SET(NETGENPLUGIN_ENABLE_GUI ON)
768 elif self.module == "blsurfplugin":
771 SET(BLSURFPLUGIN_ENABLE_GUI ON)
775 elif self.module == "ghs3dplugin":
778 SET(GHS3DPLUGIN_ENABLE_GUI ON)
782 elif self.module == "hexoticplugin":
785 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
789 elif self.module == "ghs3dprlplugin":
792 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
796 elif self.module == "yacs":
798 SET(SALOME_KERNEL ON)
806 set(SHORT_VERSION 7.0)
807 set(XVERSION 0x070000)
813 SET(VERSION_INFO 0.0.0)
814 SET(SOVERSION_INFO 0)
817 SET(AM_CPPFLAGS -I${CMAKE_BINARY_DIR} )
818 SET(AM_CXXFLAGS -I${CMAKE_BINARY_DIR})
820 SET(pythondir lib/python${PYTHON_VERSION}/site-packages)
821 SET(salomepythondir ${pythondir}/salome)
822 SET(salomepypkgdir ${salomepythondir}/salome)
825 if self.module == "smesh" and self.root[-len('SMESH_PY'):] == 'SMESH_PY':
827 SET(smeshpypkgdir ${salomepythondir}/salome/smesh)
830 if self.module == "netgen":
832 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DNO_PARALLEL_THREADS -DOCCGEOMETRY -I${CMAKE_CURRENT_SOURCE_DIR})
834 elif self.module == "kernel":
836 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
837 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm -include SALOMEconfig.h)
840 if self.module not in ["yacs"]:
843 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
844 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
845 ENDIF(KERNEL_ROOT_DIR)
848 if self.module == "gui":
851 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
852 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SALOMEDS_OBSERVER -DSUIT_ENABLE_PYTHON)
853 ENDIF(KERNEL_ROOT_DIR)
856 if self.module in ["smesh", "netgenplugin", "blsurfplugin", "ghs3dplugin", "hexoticplugin"]:
858 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
859 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DWITH_SMESH_CANCEL_COMPUTE)
862 if self.module == "ghs3dplugin":
863 # TODO: Auto-detect TetGen-GHS3D version automatically
865 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DGHS3D_VERSION=42)
866 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DGHS3D_VERSION=42)
869 if self.module == "hxx2salome":
871 if self.the_root[-len(key):] != key:
872 msg = "Source dir must finished with %s !"%(key)
874 hxxmodule = self.the_root[:-len(key)]
875 from os.path import basename
876 hxxmodule = basename(hxxmodule)
877 hxxmodule = hxxmodule.lower()
878 self.hxxmodule = hxxmodule
880 SET(HXXCPP_ROOT_DIR $ENV{%sCPP_ROOT_DIR})
881 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -I${HXXCPP_ROOT_DIR}/include)
882 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -I${HXXCPP_ROOT_DIR}/include)
883 SET(LDADD ${LDADD} -L${HXXCPP_ROOT_DIR}/lib)
884 '''%(hxxmodule.upper()))
890 def treatLine(self, line, newlines, opened_ifs):
893 # Print the comment above the line itself
895 if line.find('#') >= 0:
896 fields = line.split('#')
898 comment = '#'.join([''] + fields[1:])
899 newlines.append(comment)
905 # If the line begins with 'include ', just comment it
907 if line.find("include ") == 0:
908 if line.find("include $(top_srcdir)/config/automake.common") == 0:
910 "MAINTAINERCLEANFILES = Makefile.in",
911 "AM_CPPFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
912 "AM_FFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
913 "AM_FCFLAGS=-I$(top_srcdir)/include -I$(top_builddir)/include",
914 "AM_CPPFLAGS+=@HDF5_CPPFLAGS@",
915 "AM_LDFLAGS=@HDF5_LDFLAGS@",
917 self.treatLine(l, newlines, opened_ifs)
921 newlines.append("# " + line)
926 # If the line begins with '-include', just comment it
928 if line.find("-include") == 0:
929 newlines.append("# " + line)
933 # If the line is a definition of a make rule, just comment it
935 if line.count(':') == 1:
936 newlines.append("# " + line)
940 # A particuliar case where there are two ":" on the same line
942 if line.find('install-exec-local:') == 0:
943 newlines.append("# " + line)
947 # If the line begin by a tabulation, consider it's a makefile command and comment it
949 if line.find("\t") == 0:
950 newlines.append("# " + line)
955 key = "-version-info"
956 if line.find(key) >= 0:
958 before = line.split(key)[0]
959 after = line[len(before)+len(key):]
962 version_info = after.split()[0]
963 line = line.replace(key+sep+version_info, "")
965 version_info = version_info.replace(':', '.')
966 soversion_info = version_info.split('.')[0]
967 newlines.append("SET(VERSION_INFO " + version_info + ")")
968 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
973 # Replace the $(TOTO) by ${TOTO}
974 # Replace the @TOTO@ by ${TOTO}
976 line = p_dollar.sub(r"${\1}", line)
977 line = p_arobas.sub(r"${\1}", line)
980 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
981 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
982 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
983 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
984 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
987 # Check if the line is a 'if' condition
988 # If yes, replace it by a cmake grammar
990 match = p_if.match(line)
992 theif = match.group("val")
994 theif = "NOT " + theif[1:]
996 line = p_if.sub(r"IF(%s)"%(theif), line)
997 opened_ifs.append(theif)
998 newlines.append(line)
1002 # Check if the line is a 'else' condition
1003 # If yes, replace it by a cmake grammar
1005 match = p_else.match(line)
1007 line = "ELSE(%s)"%(opened_ifs[-1])
1008 newlines.append(line)
1012 # Check if the line is a 'endif' condition
1013 # If yes, replace it by a cmake grammar
1015 match = p_endif.match(line)
1017 line = "ENDIF(%s)"%(opened_ifs[-1])
1018 opened_ifs[-1:] = []
1019 newlines.append(line)
1023 # Check if the line is an attribution '=' or '+='
1025 match = p_attribution.match(line)
1027 self.treatAttribution(match, newlines)
1031 newlines.append(line)
1036 def treatAttribution(self, match, newlines):
1038 spaces = match.group("spaces")
1039 key = match.group("key")
1040 method = match.group("method")
1041 value = match.group("value")
1042 # print [spaces, key, method, value]
1045 # Open cmake SET command
1047 newlines.append(spaces + "SET(" + key)
1050 # If method is '+=', put the previous definition as first value
1053 newlines.append("%s ${%s}"%(spaces, key))
1057 fields = value.split()
1059 for i in range(len(fields)):
1060 newlines.append("%s %s"%(spaces, fields[i]))
1066 # The try: except KeyError is here if the +=
1067 # is an error which occurs in salome ...
1070 self.__thedict__[key] += fields[:]
1072 self.__thedict__[key] = fields[:]
1076 self.__thedict__[key] = fields[:]
1080 # Close cmake SET command
1083 newlines.append("%s)"%(spaces))
1087 def finalize(self, newlines):
1090 # Convert the .in files in build dir
1093 if self.module == "hexoticplugin" :
1094 upmod = "HexoticPLUGIN"
1096 upmod = self.module.upper()
1100 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1101 newlines.append(r'''
1109 ${CMAKE_CURRENT_SOURCE_DIR}
1112 ${CMAKE_CURRENT_BINARY_DIR}
1115 ${CMAKE_INSTALL_PREFIX}/share
1118 ${datadir}/doc/salome
1121 self.files.append("static/header.html.in")
1122 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']:
1123 newlines.append(r'''
1131 ${CMAKE_CURRENT_SOURCE_DIR}
1134 ${CMAKE_CURRENT_BINARY_DIR}
1137 ${CMAKE_INSTALL_PREFIX}/share
1140 ${datadir}/doc/salome
1143 if mod not in ['blsurfplugin']:
1144 self.files.append("static/header.html.in")
1145 if mod in ['geom', 'smesh', 'visu','netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin',"ghs3dprlplugin"] and self.root[-len(mod):] == upmod:
1146 self.files.append("static/header_py.html.in")
1148 if self.module == "yacs":
1150 if self.root[-len(key):] == key:
1151 self.files.append("resources/YACSCatalog.xml.in")
1152 self.files.append("resources/SalomeApp.xml.in")
1156 if operator.contains(self.root, 'YACS_SRC'+path.sep+'doc'):
1157 newlines.append(r'''
1159 ${CMAKE_CURRENT_SOURCE_DIR}
1163 if self.module == "jobmanager":
1165 if self.root[-len(key):] == key:
1166 self.files.append("resources/SalomeApp.xml.in")
1169 for f in self.files:
1171 if self.module == 'yacs' and f == "Doxyfile.in":
1173 if f == "sstream.in":
1175 if f in ["runContainer.in", "stopContainer.in"]:
1176 if self.module == "med":
1177 if self.root[-3:] == "csh":
1181 if f == "SALOMEconfig.ref.in":
1182 out = "SALOMEconfig.h"
1186 newlines.append(r'''
1187 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
1189 newlines.append(r'''
1190 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
1192 newlines.append(r'''
1193 MESSAGE(STATUS "Creation of ${output}")
1194 CONFIGURE_FILE(${input} ${output})
1200 # add commands for generating of user's documentation
1202 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/gui/%s"%(upmod)
1203 doc_tui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s"%(upmod)
1204 doc_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome"
1205 head_source = "${CMAKE_CURRENT_SOURCE_DIR}/images/head.png"
1207 prepare_generating_doc_src = "${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/prepare_generating_doc.py"
1209 prepare_generating_doc_src = "$ENV{KERNEL_ROOT_DIR}/bin/salome/prepare_generating_doc.py"
1210 if mod in ['kernel', 'gui'] and self.root[-len('gui'):] == 'gui' or mod == 'med' and operator.contains(self.root, 'doxygen'):
1212 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/doc_ref_user/html"
1213 input = "Doxyfile_med_user"
1215 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1217 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs ${DOXYGEN_EXECUTABLE} %s
1218 COMMAND ${PYTHON_EXECUTABLE} -c "import shutil, sys; shutil.rmtree(r'''%s''', True); shutil.copytree(r'''%s''', r'''%s'''); shutil.copy(r'''%s''', r'''%s''')"
1220 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1221 )"""%(input, doc_gui_destination, doc_source, doc_gui_destination, head_source, doc_gui_destination))
1223 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'):
1224 ign = r"""'*usr_docs*', '*CMakeFiles*', '*.cmake', 'doxyfile*', '*.vcproj', 'static', 'Makefile*'"""
1225 if mod in ['geom', 'smesh']:
1228 input = "COMMAND ${DOXYGEN_EXECUTABLE} doxyfile_tui \n\t\t"
1232 newlines.append(r"""
1234 STRING(REPLACE "/" "\\" f "%s")
1238 ADD_CUSTOM_TARGET(usr_docs ${PYTHON_EXECUTABLE} ${f} %s.py ${CMAKE_SOURCE_DIR}/src/%s_SWIG/%sDC.py %s
1239 %sCOMMAND ${DOXYGEN_EXECUTABLE} doxyfile_py
1240 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1241 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''%s.py''')"
1242 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''')"
1244 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1245 )"""%(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))
1246 newlines.append(r"""ADD_DEPENDENCIES(usr_docs html_docs)""")
1249 if mod in ['netgenplugin','blsurfplugin','hexoticplugin','ghs3dplugin', "ghs3dprlplugin"] :
1250 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_py"
1251 elif mod not in ['pyhello']:
1252 config_f = "${DOXYGEN_EXECUTABLE} doxyfile_idl"
1253 newlines.append("""\t ADD_CUSTOM_TARGET(usr_docs %s
1254 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1255 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''')"
1257 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1258 )"""%(config_f, doc_gui_destination, doc_gui_destination, ign, head_source, doc_gui_destination))
1259 elif mod in ['yacs', 'jobmanager'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'):
1260 from sys import platform
1262 if platform == "win32":
1264 newlines.append(r"""
1265 ADD_CUSTOM_TARGET(html_docs ${SPHINX_EXECUTABLE} %s -c ${CMAKE_BINARY_DIR}/doc -b html ${ALLSPHINXOPTS} html
1266 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1267 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(params, doc_gui_destination, doc_gui_destination))
1268 elif mod in ['kernel', 'smesh', 'geom'] and operator.contains(self.root, upmod + '_SRC'+path.sep+'doc'+path.sep+'docutils'):
1269 from sys import platform
1273 if platform == "win32":
1277 cmd = "STRING(REPLACE \"/\" \"\\\\\" SCR"
1282 doc_gui_destination = "${CMAKE_INSTALL_PREFIX}/share/doc/salome/tui/%s/docutils"%(upmod)
1283 scr = self.writeEnvScript(upmod)
1284 newlines.append(r"""
1286 FILE(WRITE ${CMAKE_CURRENT_BINARY_DIR}/env_s.%s "${SCR}")
1287 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
1288 COMMAND ${PYTHON_EXECUTABLE} -c \"import shutil\;shutil.rmtree('''%s''', True)\;shutil.copytree('''${CMAKE_CURRENT_BINARY_DIR}/html''', '''%s''')\"
1289 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})"""%(cmd, scr, ext, prf, ext, params, doc_gui_destination, doc_gui_destination))
1295 # add commands for generating of developer's documentation
1298 upmod = self.module.upper()
1299 if mod in ['kernel', 'gui', 'med', 'smesh', 'visu', 'blsurfplugin'] and self.root[-len('tui'):] == 'tui':
1301 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE} -u
1302 COMMAND ${DOXYGEN_EXECUTABLE}
1303 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_CURRENT_BINARY_DIR}/doxyfile.bak''')" """
1306 tmp = """\tADD_CUSTOM_TARGET(dev_docs ${DOXYGEN_EXECUTABLE}"""
1308 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)
1309 elif mod == 'smesh':
1310 tmp1= """\n COMMAND ${PYTHON_EXECUTABLE} -c "from shutil import copy; copy(r'''${CMAKE_CURRENT_SOURCE_DIR}/images/smeshscreen.png''', r'''%s''')" """%(doc_tui_destination)
1313 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1314 inst_head_command=""
1315 if mod not in ['blsurfplugin']:
1316 inst_head_command = "; shutil.copy(r'''%s''', r'''%s''')"%(head_source, doc_tui_destination)
1317 newlines.append(tmp + """
1318 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 + """
1320 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1322 if mod == 'geom' and self.root[-len('tui'):] == 'tui':
1324 doc_source = "${CMAKE_CURRENT_BINARY_DIR}/%s"%(upmod)
1325 newlines.append(r"""
1327 STRING(REPLACE "/" "\\" f "%s")
1331 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
1332 COMMAND ${DOXYGEN_EXECUTABLE} doxyfile
1333 COMMAND ${PYTHON_EXECUTABLE} -c "import os; os.remove(r'''${CMAKE_BINARY_DIR}/src/%s_SWIG/%s.py''')"
1334 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''')"
1336 WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
1337 )"""%(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))
1340 # convert the SUBDIRS in cmake grammar
1342 if 1: # self.__thedict__.has_key("SUBDIRS"):
1343 newlines.append(r'''
1344 FOREACH(dir ${SUBDIRS})
1345 IF(NOT dir STREQUAL .)
1346 ADD_SUBDIRECTORY(${dir})
1347 ENDIF(NOT dir STREQUAL .)
1348 ENDFOREACH(dir ${SUBDIRS})
1354 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES", "libparaview_LTLIBRARIES"] :
1355 if self.__thedict__.has_key(key):
1356 self.addLibTarget(key, newlines)
1362 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
1363 if self.__thedict__.has_key(key):
1364 self.addBinTarget(key, newlines)
1370 if self.__thedict__.has_key("BASEIDL_FILES"):
1371 if not self.__thedict__.has_key("IDL_FILES"):
1372 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
1374 SET(IDL_FILES ${BASEIDL_FILES})
1383 if self.__thedict__.has_key(key):
1384 if self.module == "kernel":
1386 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
1390 FOREACH(input ${IDL_FILES})
1391 STRING(REGEX REPLACE ".idl" "" base ${input})
1392 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1394 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1395 SET(outputs ${outputs} ${dynsrc})
1396 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1397 SET(outputs ${outputs} ${inc})
1398 IF(input STREQUAL Calcium_Ports.idl)
1399 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1400 ELSE(input STREQUAL Calcium_Ports.idl)
1401 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1402 ENDIF(input STREQUAL Calcium_Ports.idl)
1403 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1404 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1406 SET(flags -bcxx ${flags})
1410 COMMAND ${OMNIORB_IDL} ${flags} ${input}
1411 MAIN_DEPENDENCY ${input}
1415 install(FILES ${input} DESTINATION idl/salome)
1417 if self.module not in ["pyhello"]:
1419 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1420 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1424 INSTALL(CODE "SET(IDL_FILE ${input})")
1425 INSTALL(CODE "SET(DIR ${salomepythondir})")
1427 INSTALL(CODE "SET(DIR bin/salome)")
1429 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1430 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1433 FOREACH(f ${IDLPYFLAGS})
1434 SET(flags "${flags} ${f}")
1435 ENDFOREACH(f ${IDLPYFLAGS})
1436 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1438 SET(flags "-bpython ${flags}")
1439 ENDIF(NOT ISBPYTHON)
1440 SET(IDLPYFLAGS ${flags})
1441 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1442 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1445 if self.module == "kernel":
1447 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1451 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1452 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_python_from_idl.cmake)
1456 ENDFOREACH(input ${IDL_FILES})
1462 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1463 if self.__thedict__.has_key(key):
1465 SET(SWIG_SOURCES ${%s})
1467 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1473 if self.__thedict__.has_key("SWIG_SOURCES"):
1475 IF(SWIG_SOURCES MATCHES ";")
1476 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1477 ELSE(SWIG_SOURCES MATCHES ";")
1478 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1479 ENDIF(SWIG_SOURCES MATCHES ";")
1481 FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1484 LIST(FIND flags ${f} index)
1485 IF(NOT index EQUAL -1)
1487 ENDIF(NOT index EQUAL -1)
1490 SET(flags ${flags} ${f})
1492 ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1494 OUTPUT ${build_srcs}
1495 COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1496 MAIN_DEPENDENCY ${SWIG_SOURCES}
1503 if self.__thedict__.has_key("BUILT_SOURCES"):
1505 FOREACH(f ${BUILT_SOURCES})
1506 IF(f MATCHES "WRAP.cxx$")
1507 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1508 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1510 OUTPUT ${f} # ${inc}
1511 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1512 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1514 ENDIF(f MATCHES "WRAP.cxx$")
1515 ENDFOREACH(f ${BUILT_SOURCES})
1522 if self.__thedict__.has_key(key):
1524 FOREACH(output ${MOC_FILES})
1526 if self.module in ["jobmanager", "yacs"]:
1528 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1532 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1536 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1537 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1540 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1541 MAIN_DEPENDENCY ${input}
1543 ENDFOREACH(output ${MOC_FILES})
1549 key = "MOC_FILES_HXX"
1550 if self.__thedict__.has_key(key):
1552 FOREACH(output ${MOC_FILES_HXX})
1555 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1558 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1559 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1562 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1563 MAIN_DEPENDENCY ${input}
1565 ENDFOREACH(output ${MOC_FILES_HXX})
1572 if self.__thedict__.has_key(key):
1574 FOREACH(output ${UIC_FILES})
1575 STRING(REPLACE "ui_" "" input ${output})
1576 STRING(REPLACE ".h" ".ui" input ${input})
1577 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1578 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1581 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1582 MAIN_DEPENDENCY ${input}
1584 ENDFOREACH(output ${UIC_FILES})
1591 if self.__thedict__.has_key(key):
1593 FOREACH(output ${PYUIC_FILES})
1594 STRING(REPLACE "_ui.py" ".ui" input ${output})
1595 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1596 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1599 COMMAND ${PYUIC_EXECUTABLE} -o ${output} ${input}
1600 MAIN_DEPENDENCY ${input}
1602 ENDFOREACH(output ${PYUIC_FILES})
1603 ADD_CUSTOM_TARGET(BUILD_PY_UI_FILES ALL DEPENDS ${PYUIC_FILES})
1610 if self.__thedict__.has_key(key):
1612 FOREACH(output ${QRC_FILES})
1613 STRING(REGEX REPLACE "qrc_" "" input ${output})
1614 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1615 STRING(REGEX REPLACE ".qrc" "" name ${input})
1616 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1617 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1620 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1621 MAIN_DEPENDENCY ${input}
1623 ENDFOREACH(output ${QRC_FILES})
1630 if self.__thedict__.has_key(key):
1632 FOREACH(input ${SIP_FILES})
1633 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1635 FOREACH(out ${SIP_SRC})
1636 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1637 ENDFOREACH(out ${SIP_SRC})
1640 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1641 MAIN_DEPENDENCY ${input}
1643 ENDFOREACH(input ${SIP_FILES})
1648 # For GUI/tools/dlgfactory
1650 key = "UIC_FILES_QDIALOG"
1651 if self.__thedict__.has_key(key):
1653 FOREACH(output ${UIC_FILES_QDIALOG} ${UIC_FILES_GDIALOG})
1654 STRING(REPLACE "ui_" "" input ${output})
1655 STRING(REPLACE ".hxx" ".ui" input ${input})
1656 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1657 IF (NOT EXISTS ${input_path})
1658 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1659 ENDIF (NOT EXISTS ${input_path})
1662 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input_path}
1663 MAIN_DEPENDENCY ${input}
1665 ENDFOREACH(output ${UIC_FILES})
1667 FOREACH(output ${MOC_FILES_QDIALOG} ${MOC_FILES_GDIALOG})
1668 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1669 SET(input_path ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1670 IF (NOT EXISTS ${input_path})
1671 SET(input_path ${CMAKE_CURRENT_BINARY_DIR}/${input})
1672 ENDIF (NOT EXISTS ${input_path})
1675 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input_path} -o ${output}
1676 MAIN_DEPENDENCY ${input}
1678 ENDFOREACH(output ${MOC_FILES})
1681 OUTPUT QDialogTest.ui QDialogTest.hxx QDialogTest.cxx
1682 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n QDialogTest -t qdialog
1683 DEPENDS __QDIALOG__.ui __QDIALOG__.hxx __QDIALOG__.cxx dlgfactory.py
1687 OUTPUT GDialogTest.ui GDialogTest.hxx GDialogTest.cxx
1688 COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/dlgfactory.py -n GDialogTest -t gdialog
1689 DEPENDS __GDIALOG__.ui __GDIALOG__.hxx __GDIALOG__.cxx dlgfactory.py
1697 for key in ["TESTS"]:
1698 if self.__thedict__.has_key(key):
1700 SET(UNIT_TEST_PROG ${%s})
1702 self.__thedict__["UNIT_TEST_PROG"] = self.__thedict__[key]
1705 key = "UNIT_TEST_PROG"
1706 if self.__thedict__.has_key(key):
1708 FOREACH(input ${UNIT_TEST_PROG})
1709 GET_FILENAME_COMPONENT(ext ${input} EXT)
1710 IF(ext STREQUAL .py)
1711 SET(test ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1712 ELSE(ext STREQUAL .py)
1714 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe.exe)
1716 SET(test ${CMAKE_CURRENT_BINARY_DIR}/${input}_exe)
1718 ENDIF(ext STREQUAL .py)
1719 ADD_TEST(${input} ${test})
1720 SET(fail_regex "KO")
1721 SET_PROPERTY(TEST ${input} PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1723 # ADD_TEST(${input}_valgrind valgrind ${test})
1724 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY FAIL_REGULAR_EXPRESSION "${fail_regex}")
1725 # SET_PROPERTY(TEST ${input}_valgrind PROPERTY PASS_REGULAR_EXPRESSION "no leaks are possible")
1727 ENDFOREACH(input ${UNIT_TEST_PROG})
1732 # Treat the install targets
1734 resdir = self.module
1735 if resdir == "hxx2salome":
1736 resdir = self.hxxmodule
1739 "salomeadmux_DATA" : "salome_adm/unix",
1740 "dist_salomeadmux_DATA" : "salome_adm/unix",
1741 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1742 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1743 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1744 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1745 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1746 "salomeinclude_DATA" : "include/salome",
1747 "salomeinclude_HEADERS" : "include/salome",
1748 "nodist_salomeinclude_HEADERS" : "include/salome",
1749 "dist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1750 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(resdir),
1751 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(resdir),
1752 "dist_salomescript_SCRIPTS" : "bin/salome",
1753 "dist_salomescript_DATA" : "bin/salome",
1754 "dist_salomescript_PYTHON" : "bin/salome",
1755 "dist_appliskel_SCRIPTS" : "bin/salome/appliskel",
1756 "dist_appliskel_PYTHON" : "bin/salome/appliskel",
1757 "nodist_salomescript_DATA" : "bin/salome",
1758 "salomepython_PYTHON" : "${salomepythondir}",
1759 "nodist_salomepython_PYTHON" : "${salomepythondir}",
1760 "dist_salomepython_DATA" : "${salomepythondir}",
1761 "sharedpkgpython_PYTHON" : "${salomepythondir}/shared_modules",
1762 "salomepypkg_PYTHON" : "${salomepypkgdir}",
1763 "mypkgpython_PYTHON" : "${mypkgpythondir}",
1764 "nodist_mypkgpython_PYTHON" : "${mypkgpythondir}",
1766 if self.module == "jobmanager":
1767 d["bin_SCRIPTS"] = "bin"
1769 if self.module == "medfile":
1771 "include_HEADERS" : "include",
1772 "nodist_include_HEADERS" : "include",
1773 "bin_SCRIPTS" : "bin",
1774 "doc_DATA" : "${docdir}",
1777 if self.module == "netgen":
1779 "include_HEADERS" : "include",
1780 "noinst_HEADERS" : "share/netgen/include",
1781 "dist_pkgdata_DATA" : "share/netgen",
1782 "dist_doc_DATA" : "share/doc/netgen",
1785 for key, value in d.items():
1786 if self.__thedict__.has_key(key):
1787 self.addInstallTarget(key, value, newlines)
1794 def setLibAdd(self, key, newlines):
1796 newlines.append(r'''
1800 newlines.append(r'''
1803 SET(targets ${targets} MEFISTO2D)
1804 FOREACH(target ${targets})
1805 IF(name STREQUAL ${target})
1806 SET(dir $ENV{F2CHOME})
1807 STRING(REPLACE "\\\\" "/" dir ${dir})
1808 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1809 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1810 ENDIF(name STREQUAL ${target})
1811 ENDFOREACH(target ${targets})
1814 SET(targets ${targets} MEFISTO2D)
1815 FOREACH(target ${targets})
1816 IF(name STREQUAL ${target})
1817 SET(libadd ${libadd} -lf2c)
1818 ENDIF(name STREQUAL ${target})
1819 ENDFOREACH(target ${targets})
1823 newlines.append(r'''
1824 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${LDADD} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1825 FOREACH(lib SALOMEBasics SalomeBatch)
1826 IF(name STREQUAL lib)
1827 SET(libs ${libs} ${PTHREAD_LIBS})
1828 ENDIF(name STREQUAL lib)
1829 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1832 newlines.append(r'''
1833 FOREACH(lib ${libs})
1834 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1835 IF(ext STREQUAL .la)
1836 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1837 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1838 ENDIF(ext STREQUAL .la)
1840 SET(vars ${vars} -no-undefined)
1841 SET(vars ${vars} -lvtkWidgets)
1843 SET(vars ${vars} -module)
1844 SET(vars ${vars} -Wl,-E)
1845 SET(vars ${vars} -Xlinker)
1846 SET(vars ${vars} -export-dynamic)
1847 SET(vars ${vars} -lm)
1848 SET(vars ${vars} -lboost_thread)
1849 SET(vars ${vars} -lboost_signals)
1850 SET(vars ${vars} -pthread -lpthread -ldl)
1855 ENDIF(lib STREQUAL v)
1856 ENDFOREACH(v ${vars})
1859 STRING(REGEX MATCH "^-lQt" test ${lib})
1862 SET(libadd ${libadd} ${lib})
1864 ENDFOREACH(lib ${libs})
1865 TARGET_LINK_LIBRARIES(${name} ${libadd})
1868 newlines.append(r'''
1871 SET(targets ${targets} MEFISTO2D)
1872 FOREACH(target ${targets})
1873 IF(name STREQUAL ${target})
1874 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1875 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1876 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1877 ENDIF(name STREQUAL ${target})
1878 ENDFOREACH(target ${targets})
1884 def setCompilationFlags(self, key, newlines):
1885 newlines.append(r'''
1889 SET(targets ${targets} SalomeIDLKernel)
1890 SET(targets ${targets} SalomeDS)
1891 SET(targets ${targets} SALOMEDSTest)
1892 SET(targets ${targets} SALOMEDS_Client_exe)
1893 SET(targets ${targets} SalomeIDLGEOM)
1894 SET(targets ${targets} GEOMEngine)
1895 SET(targets ${targets} MEDEngine)
1896 SET(targets ${targets} SMESHEngine)
1897 SET(targets ${targets} SMESH)
1898 SET(targets ${targets} SalomeIDLSPADDER)
1899 SET(targets ${targets} MeshJobManagerEngine)
1900 SET(targets ${targets} StdMeshersEngine)
1901 SET(targets ${targets} VISUEngineImpl)
1902 FOREACH(target ${targets})
1903 IF(name STREQUAL ${target})
1904 SET(var ${var} -DNOGDI)
1905 ENDIF(name STREQUAL ${target})
1906 ENDFOREACH(target ${targets})
1910 if self.module in ["medfile", "yacs"]:
1911 newlines.append(r'''
1913 SET(var ${var} -DNOGDI)
1918 newlines.append(r'''
1921 SET(targets ${targets} MEFISTO2D)
1922 FOREACH(target ${targets})
1923 IF(name STREQUAL ${target})
1924 SET(dir $ENV{F2CHOME})
1925 STRING(REPLACE "\\\\" "/" dir ${dir})
1926 SET(var ${var} -I${dir})
1927 SET(var ${var} -DF2C_BUILD)
1928 ENDIF(name STREQUAL ${target})
1929 ENDFOREACH(target ${targets})
1933 if self.module in ["geom", "med", "hexoticplugin", "blsurfplugin"]:
1934 newlines.append(r'''
1935 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1936 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1939 newlines.append(r'''
1940 SET(var ${var} ${AM_CPPFLAGS})
1941 SET(var ${var} ${AM_CXXFLAGS})
1944 newlines.append(r'''
1945 IF(type STREQUAL STATIC)
1946 SET(var ${var} -fPIC)
1947 ENDIF(type STREQUAL STATIC)
1950 if self.module == "yacs":
1951 newlines.append(r'''
1952 SET(var ${var} -DYACS_PTHREAD)
1953 SET(var ${var} -DCMAKE_BUILD)
1954 SET(var ${var} -DSALOME_KERNEL)
1955 SET(var ${var} -DDSC_PORTS)
1956 SET(var ${var} -DOMNIORB)
1959 newlines.append(r'''
1960 SET(var ${var} ${PLATFORM_CPPFLAGS})
1961 SET(var ${var} ${PTHREAD_CFLAGS})
1962 SET(var ${var} ${${amname}_CPPFLAGS})
1963 SET(var ${var} ${${amname}_CXXFLAGS})
1964 SET(var ${var} ${${amname}_CFLAGS})
1967 SET(vars ${vars} -include SALOMEconfig.h)
1968 SET(vars ${vars} -ftemplate-depth-32)
1969 SET(vars ${vars} -fPIC)
1970 SET(vars ${vars} -g)
1978 ENDFOREACH(v ${vars})
1980 string(REGEX MATCH "^-I" test_include ${f})
1982 string(REGEX REPLACE "^-I" "" include_dir ${f})
1984 if(include_dir STREQUAL /usr/include)
1985 else(include_dir STREQUAL /usr/include)
1986 string(REGEX MATCH "^\\." test_dot ${include_dir})
1988 set(include_dir ${CMAKE_CURRENT_BINARY_DIR}/${include_dir})
1990 include_directories(${include_dir})
1991 endif(include_dir STREQUAL /usr/include)
1994 SET(flags "${flags} ${f}")
1997 ENDFOREACH(f ${var})
1998 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
2002 def addLibTarget(self, key, newlines):
2003 newlines.append(r'''
2004 FOREACH(amname ${%s})
2007 # Replace .la by _la ...
2009 newlines.append(r'''
2010 STRING(REPLACE .la _la amname ${amname})
2013 # Remove the _la for the cmake name
2015 newlines.append(r'''
2016 STRING(LENGTH ${amname} len)
2017 MATH(EXPR newlen "${len}-3")
2018 STRING(SUBSTRING ${amname} 0 ${newlen} name)
2021 # Does the target begins with lib ??
2022 # If yes, remove lib at beginning for cmake name
2024 newlines.append(r'''
2025 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
2027 STRING(LENGTH ${name} len)
2028 MATH(EXPR newlen "${len}-3")
2029 STRING(SUBSTRING ${name} 3 ${newlen} name)
2030 ENDIF(BEGIN_WITH_lib)
2033 # Does the target is an idl library
2035 newlines.append(r'''
2036 STRING(REGEX MATCH "IDL" ISIDL ${name})
2039 # Set the type of the library
2041 newlines.append(r'''
2052 if key == "noinst_LTLIBRARIES":
2053 newlines.append(r'''
2062 # Set sources for the library
2064 newlines.append(r'''
2066 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2067 GET_FILENAME_COMPONENT(ext ${src} EXT)
2069 IF(src STREQUAL trte.f)
2070 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2071 STRING(REPLACE ".f" ".c" src ${src})
2072 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2076 IF(CMAKE_SIZEOF_VOID_P STREQUAL 8)
2077 SET(cmd valgrind f2c) # f2c seems to be buggy on 64 bits ... but with valgrind, it works :)
2082 COMMAND ${cmd} ${input}
2083 MAIN_DEPENDENCY ${input}
2085 ELSE(src STREQUAL trte.f)
2086 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
2087 STRING(REPLACE ".f" ".o" src ${src})
2088 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
2097 COMMAND ${F77} -c -o ${output} ${input}
2098 MAIN_DEPENDENCY ${input}
2100 ENDIF(src STREQUAL trte.f)
2101 ENDIF(ext STREQUAL .f)
2102 SET(srcs ${srcs} ${src})
2103 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2105 newlines.append(r'''
2106 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
2108 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2109 SET(srcs ${srcs} ${src})
2112 newlines.append(r'''
2114 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
2116 GET_FILENAME_COMPONENT(ext ${f} EXT)
2117 IF(ext STREQUAL .py)
2119 ELSE(ext STREQUAL .py)
2120 SET(fff ${CMAKE_CURRENT_BINARY_DIR}/${f})
2121 ENDIF(ext STREQUAL .py)
2124 LIST(FIND build_srcs ${fff} index)
2125 IF(NOT index EQUAL -1)
2127 ENDIF(NOT index EQUAL -1)
2131 SET(build_srcs ${build_srcs} ${fff})
2136 # Add the library to cmake
2138 newlines.append(r'''
2139 ADD_LIBRARY(${name} ${type} ${srcs})
2142 # The compilation flags
2144 self.setCompilationFlags(key, newlines)
2146 newlines.append(r'''
2147 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
2150 self.setLibAdd(key, newlines)
2152 if 1: # key != "noinst_LTLIBRARIES":
2153 newlines.append(r'''
2156 newlines.append(r'''
2158 IF(${key} STREQUAL noinst_LTLIBRARIES)
2160 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2162 if self.module == "netgen" :
2163 newlines.append(r'''
2164 IF(${key} STREQUAL noinst_LTLIBRARIES)
2168 ENDIF(${key} STREQUAL noinst_LTLIBRARIES)
2171 newlines.append(r'''
2174 if self.module in ["medfile", "netgen"]:
2175 newlines.append(r'''
2178 elif key == "libparaview_LTLIBRARIES":
2179 newlines.append(r'''
2180 SET(DEST lib/paraview)
2183 newlines.append(r'''
2184 SET(DEST lib/salome)
2187 newlines.append(r'''
2189 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2191 if self.module == "gui":
2192 newlines.append(r'''
2193 FOREACH(lib SalomePyQt)
2194 IF(name STREQUAL lib)
2196 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2197 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
2198 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2199 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
2200 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2202 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
2204 ENDIF(name STREQUAL lib)
2205 ENDFOREACH(lib SalomePyQt)
2206 FOREACH(lib SalomePy)
2207 IF(name STREQUAL lib)
2209 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2210 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
2211 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2212 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
2213 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2215 ENDIF(name STREQUAL lib)
2216 ENDFOREACH(lib SalomePy)
2219 if self.module == "geom":
2220 newlines.append(r'''
2222 STRING(REGEX MATCH "Export" ISExport ${name})
2224 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2226 STRING(REGEX MATCH "Import" ISImport ${name})
2228 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
2233 newlines.append(r'''
2234 ELSE(BEGIN_WITH_lib)
2236 newlines.append(r'''
2238 INSTALL(TARGETS ${name} DESTINATION ${salomepythondir})
2239 IF(CMAKE_BUILD_TYPE STREQUAL Release)
2240 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}.pyd)
2241 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
2242 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${salomepythondir}/${name}.dll DESTINATION ${salomepythondir} RENAME ${name}_d.pyd)
2243 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
2245 GET_TARGET_PROPERTY(version ${name} VERSION)
2246 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
2247 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${version})
2248 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so.${soversion})
2249 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION ${salomepythondir} RENAME ${name}.so)
2252 newlines.append(r'''
2253 ENDIF(BEGIN_WITH_lib)
2255 newlines.append(r'''
2260 newlines.append(r'''
2261 ENDFOREACH(amname ${%s})
2266 def addBinTarget(self, key, newlines):
2268 newlines.append(r'''
2269 FOREACH(amname ${%s})
2272 newlines.append(r'''
2275 if key == "check_PROGRAMS":
2276 newlines.append(r'''
2278 STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
2285 newlines.append(r'''
2289 newlines.append(r'''
2290 SET(name "${amname}_exe")
2291 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
2292 SET(l ${nodist_${amname}_SOURCES})
2294 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
2295 SET(srcs ${srcs} ${src})
2297 LIST(LENGTH srcs nb)
2299 ADD_EXECUTABLE(${name} ${srcs})
2302 self.setCompilationFlags(key, newlines)
2304 self.setLibAdd(key, newlines)
2306 if self.module in ["jobmanager", "medfile", "netgen"]:
2307 newlines.append(r'''
2311 newlines.append(r'''
2312 SET(DEST bin/salome)
2316 if key == "bin_PROGRAMS":
2317 newlines.append(r'''
2319 INSTALL(TARGETS ${name} DESTINATION ${DEST})
2320 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
2321 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
2324 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2325 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2326 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2327 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
2332 newlines.append(r'''
2336 newlines.append(r'''
2339 newlines.append(r'''
2340 ENDFOREACH(amname ${%s})
2345 def addInstallTarget(self, key, destination, newlines):
2346 newlines.append(r"FOREACH(f ${%s})"%(key))
2347 newlines.append(r'''
2350 newlines.append(r'''
2351 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
2352 IF(test_SALOMEconfig.h.in)
2353 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
2354 ELSE(test_SALOMEconfig.h.in)
2355 SET(dummy dummy-NOTFOUND)
2356 MARK_AS_ADVANCED(dummy)
2357 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
2358 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
2361 if key in ['dist_salomescript_SCRIPTS',
2362 'dist_appliskel_SCRIPTS',
2363 'dist_appliskel_PYTHON']:
2364 newlines.append(r'''
2366 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2367 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2368 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2369 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2372 newlines.append(r'''
2373 GET_FILENAME_COMPONENT(ext ${f} EXT)
2374 IF(ext STREQUAL .py)
2375 IF(DEST STREQUAL bin/salome)
2377 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
2378 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
2379 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
2380 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
2381 ELSE(DEST STREQUAL bin/salome)
2382 INSTALL(FILES ${f} DESTINATION ${DEST})
2383 ENDIF(DEST STREQUAL bin/salome)
2384 ELSE(ext STREQUAL .py)
2385 INSTALL(FILES ${f} DESTINATION ${DEST})
2386 ENDIF(ext STREQUAL .py)
2389 newlines.append(r'''
2391 GET_FILENAME_COMPONENT(ext ${f} EXT)
2392 IF(ext STREQUAL .qm)
2393 STRING(REGEX REPLACE .qm .ts input ${f})
2395 if self.module in ["kernel", "gui", "yacs"]:
2396 newlines.append(r'''
2397 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
2400 newlines.append(r'''
2401 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
2404 newlines.append(r'''
2405 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
2406 # ADD_CUSTOM_COMMAND(
2408 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
2409 # MAIN_DEPENDENCY ${input}
2411 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
2412 ENDIF(ext STREQUAL .qm)
2413 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
2415 ENDIF(test_SALOMEconfig.h.in)
2417 newlines.append(r'''
2418 GET_FILENAME_COMPONENT(ext ${f} EXT)
2419 IF(ext STREQUAL .py)
2420 INSTALL(CODE "SET(PYTHON_FILE ${f})")
2421 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
2422 INSTALL(CODE "SET(DEST ${DEST})")
2423 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
2425 if self.module == "kernel":
2427 IF(f STREQUAL SALOME_ContainerPy.py)
2428 ELSE(f STREQUAL SALOME_ContainerPy.py)
2429 IF(f STREQUAL am2cmake.py)
2430 ELSE(f STREQUAL am2cmake.py)
2431 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
2432 ENDIF(f STREQUAL am2cmake.py)
2433 ENDIF(f STREQUAL SALOME_ContainerPy.py)
2437 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
2438 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/deprecated/install_and_compile_python_file.cmake)
2441 newlines.append(r'''
2442 ENDIF(ext STREQUAL .py)
2444 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
2447 def writeListsFile(self):
2448 f = open(self.listsFile, "w")
2449 f.write(self.content)
2453 def writeEnvScript(self, upmod, buildmod=True):
2455 p_version = sys.version[:3]
2456 python_path = "PYTHONPATH"
2457 root_dir = "%s_ROOT_DIR" % upmod
2458 if sys.platform == "win32":
2459 script_line = '@SET %(var)s=%(val)s;%%%(var)s%%\n'
2466 script_line = 'export %(var)s=%(val)s:\$%(var)s\n'
2468 lib_path = "LD_LIBRARY_PATH"
2470 omni_py = "/".join( ["python%s"%p_version , "site-packages"] )
2476 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2477 script += script_line % { 'var':python_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "bin", "salome"] ) }
2478 script += script_line % { 'var':lib_path, 'val':"/".join( ["${CMAKE_INSTALL_PREFIX}", "lib", "salome"] ) }
2481 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "lib", "python%s"%p_version, "site-packages", "salome"] ) }
2482 script += script_line % { 'var':python_path, 'val':"/".join( [var_line % root_dir, "bin", "salome"] ) }
2483 script += script_line % { 'var':lib_path, 'val':"/".join( [var_line % root_dir, "lib", "salome"] ) }
2486 if upmod == "KERNEL" :
2489 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2490 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni] ) }
2493 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2494 script += script_line % { 'var':lib_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib"] ) }
2496 script += script_line % { 'var':python_path, 'val':"/".join( ["${OMNIORB_ROOT_USER}", "lib", omni_py] ) }
2499 if upmod == "GEOM" :
2500 script = self.writeEnvScript("KERNEL", False) + "\n" + script
2501 script = self.writeEnvScript("GUI", False) + "\n" + script
2504 if upmod == "SMESH" :
2505 script = self.writeEnvScript("GEOM", False) + "\n" + script
2511 def convertAmFile(the_root, root, dirs, files, f, module):
2512 cmake = CMakeFile(the_root, root, dirs, files, f, module)
2513 cmake.writeListsFile()
2516 def usage(exit_status):
2517 from sys import exit
2518 from sys import argv
2519 print "Usage: %s --module"%(argv[0])
2523 if __name__ == "__main__":
2525 from sys import argv
2531 if module.find('--') != 0:
2535 if len(module) == 0:
2539 from os import getcwd
2544 from os import getenv
2546 for root, dirs, files in walk(the_root):
2548 # E.A. : Remove 'CVS' in dirs
2549 # E.A. : It allows to not recurse in CVS dirs
2550 # E.A. : See os module python documentation
2557 if "Makefile.am.cmake" in files:
2558 if "Makefile.am" in files:
2559 files.remove("Makefile.am")
2564 if f in ["Makefile.am", "Makefile.am.cmake"]:
2565 convert = True # convert files by default
2566 forced = getenv("AM2CMAKE_FORCE_GENERATION", "0")=="1" or \
2567 getenv("AM2CMAKE_FORCE_%s_GENERATION"%module.upper(), "0")=="1"
2569 # detect if conversion should be done
2570 if "CMakeLists.txt" in files:
2571 from os.path import join
2572 ff = open(join(root, "CMakeLists.txt"))
2575 if content.find("generated by am2cmake") == -1:
2581 convertAmFile(the_root, root, dirs, files, f, module)
2587 from sys import stdout
2590 msg = "%s file has been converted to cmake"%(nok)
2592 msg = "%s files have been converted to cmake"%(nok)