1 # Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
3 # Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 # CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 # This library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License.
11 # This library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with this library; if not, write to the Free Software
18 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
25 # A set of regular expressions used ...
28 p_multiline = re.compile(r"""
34 p_dollar = re.compile(r"""
36 (?P<val> # open the group val
37 [^)]* # the group contain 0 or more non ) characters
42 p_arobas = re.compile(r"""
44 (?P<val> # open the group val
45 [^@]* # the group contain 0 or more non @ characters
50 p_if = re.compile(r"""
51 ^ # beginning of the string
55 (?P<val> # open the group val
56 [^\s]+ # the group contain 1 or more non space characters
60 p_else = re.compile(r"""
61 ^ # beginning of the line
67 p_endif = re.compile(r"""
68 ^ # beginning of the line
74 p_attribution = re.compile(r"""
75 ^ # beginning of the line
76 (?P<spaces> # open the group spaces
79 (?P<key> # open the group key
80 \w+ # the group contain 1 or more alphanumeric characters
83 (?P<method> # open the group method
87 (?P<value> # open the group value
88 .* # 0 or more any characters
94 class CMakeFile(object):
96 def __init__(self, the_root, root, dirs, files, f, module):
98 self.the_root = the_root
104 from os.path import join
105 self.amFile = join(root, f)
106 self.listsFile = join(root, "CMakeLists.txt")
115 # Read the Makefile.am file
118 stream = open(amFile)
119 content = stream.read()
123 # Replace the composed lines separated by "\\n" by an unique line
125 content = p_multiline.sub(r' ', content)
128 # Compatibility netgen plugin
130 content = content.replace("../NETGEN/libNETGEN.la", "${NETGEN_LIBS}")
205 "vtkGraphicsPythonD",
217 "SalomeCommunication",
219 "SalomeDSCContainer",
227 "SalomeLifeCycleCORBA",
229 "SalomeLoggerServer",
230 "SalomeNotification",
232 "SalomeResourcesManager",
234 "with_loggerTraceCollector",
286 "GEOMFiltersSelection",
310 "InterpGeometric2DAlg",
339 "SMESHFiltersSelection",
347 full_list = cas_list + vtk_list
348 full_list += kernel_list + gui_list
349 full_list += geom_list + med_list + smesh_list
351 # E.A. : sort by len before substitution ...
352 # Why ? Thing to "-lMEDWrapper" then "-lMEDWrapper_V2_1" substition
353 # And you understand ...
355 full_list.sort(cmp = lambda x, y : cmp(len(y), len(x)))
357 for key in full_list:
358 content = content.replace("-l%s"%(key), "${%s}"%(key))
362 # Split content in lines to treat each one separately
364 lines = content.split('\n')
367 # newlines contains the lines of the future CMakeLists.txt file
372 # opened_ifs is used to deals with nested conditionnals
377 # the __thedict__ dictionnary contains key, val
378 # of the Makefile.am file
380 self.__thedict__ = {}
383 # Initialize file ... mainly includes other cmake files
385 self.initialize(newlines)
388 # Do the job for each line
391 self.treatLine(line, newlines, opened_ifs)
395 # Finalize file ... it is in here the cmake job is done
397 self.finalize(newlines)
400 # Concatenate newlines into content
402 content = '\n'.join(newlines)
405 # Add a CR at end if necessary
407 lines = content.split('\n')
408 # lines = [ l.strip() for l in lines ]
409 if len(lines[-1]) != 0:
412 content = '\n'.join(lines)
415 self.content = content
420 def initialize(self, newlines):
421 if self.root == self.the_root:
424 CMAKE_MINIMUM_REQUIRED(VERSION 2.4.7 FATAL_ERROR)
425 IF(COMMAND cmake_policy)
426 cmake_policy(SET CMP0003 NEW)
427 ENDIF(COMMAND cmake_policy)
430 if self.module == "kernel":
432 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
433 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
434 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
435 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
436 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
437 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
438 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
439 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
440 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
445 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
446 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
447 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
448 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
449 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
450 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
451 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
452 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
453 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
454 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
455 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
457 if self.module == "gui":
459 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
460 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
461 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
462 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
463 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
464 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
468 SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
469 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
470 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
471 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
472 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
473 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
474 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
475 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
477 if self.module == "med":
479 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
482 if self.module == "smesh":
484 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
485 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
486 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
487 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
488 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
491 if self.module == "netgenplugin":
493 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
494 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
495 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
496 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
497 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
498 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
499 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
502 if self.module == "blsurfplugin":
504 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
505 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
506 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
507 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
508 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
509 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
510 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
513 if self.module == "hexoticplugin":
515 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
516 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
517 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
518 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
519 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
520 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
523 if self.module == "ghs3dplugin":
525 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
526 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
527 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
528 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
529 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
530 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
533 if self.module == "visu":
535 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
536 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
539 if self.module == "yacs":
541 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
542 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
548 if self.module == "kernel":
553 set(XVERSION 0x050102)
554 SET(CALCIUM_IDL_INT_F77 long)
555 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
558 elif self.module == "gui":
560 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
561 SET(ENABLE_VTKVIEWER ON)
562 SET(ENABLE_SALOMEOBJECT ON)
563 SET(ENABLE_OCCVIEWER ON)
564 SET(ENABLE_GLVIEWER ON)
565 SET(ENABLE_PLOT2DVIEWER ON)
566 SET(ENABLE_PYCONSOLE ON)
567 SET(ENABLE_SUPERVGRAPHVIEWER ON)
568 SET(ENABLE_QXGRAPHVIEWER ON)
570 set(XVERSION 0x050102)
573 elif self.module == "geom":
575 SET(GEOM_ENABLE_GUI ON)
578 elif self.module == "medfile":
580 SET(MED_NUM_MAJEUR 2)
581 SET(MED_NUM_MINEUR 3)
582 SET(MED_NUM_RELEASE 5)
585 SET(FLIBS -lgfortranbegin -lgfortran)
589 elif self.module == "med":
591 SET(MED_ENABLE_KERNEL ON)
593 SET(MED_ENABLE_SPLITTER ON)
595 SET(MED_ENABLE_GUI ON)
598 elif self.module == "smesh":
600 SET(SMESH_ENABLE_GUI ON)
603 elif self.module == "netgenplugin":
605 SET(NETGENPLUGIN_ENABLE_GUI ON)
608 elif self.module == "blsurfplugin":
610 SET(BLSURFPLUGIN_ENABLE_GUI ON)
613 elif self.module == "ghs3dplugin":
615 SET(GHS3DPLUGIN_ENABLE_GUI ON)
618 elif self.module == "yacs":
620 SET(SALOME_KERNEL ON)
628 SET(VERSION_INFO 0.0.0)
629 SET(SOVERSION_INFO 0)
635 if self.module == "kernel":
637 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
638 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
641 if self.module not in ["yacs"]:
643 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
644 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
651 def treatLine(self, line, newlines, opened_ifs):
654 # Print the comment above the line itself
656 if line.find('#') >= 0:
657 fields = line.split('#')
659 comment = '#'.join([''] + fields[1:])
660 newlines.append(comment)
666 # If the line begins with 'include ', just comment it
668 if line.find("include ") == 0:
669 newlines.append("# " + line)
673 # If the line begins with '-include', just comment it
675 if line.find("-include") == 0:
676 newlines.append("# " + line)
680 # If the line is a definition of a make rule, just comment it
682 if line.count(':') == 1:
683 newlines.append("# " + line)
687 # A particuliar case where there are two ":" on the same line
689 if line.find('install-exec-local:') == 0:
690 newlines.append("# " + line)
694 # If the line begin by a tabulation, consider it's a makefile command and comment it
696 if line.find("\t") == 0:
697 newlines.append("# " + line)
702 key = "-version-info"
703 if line.find(key) >= 0:
705 before = line.split(key)[0]
706 after = line[len(before)+len(key):]
709 version_info = after.split()[0]
710 line = line.replace(key+sep+version_info, "")
712 version_info = version_info.replace(':', '.')
713 soversion_info = version_info.split('.')[0]
714 newlines.append("SET(VERSION_INFO " + version_info + ")")
715 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
720 # Replace the $(TOTO) by ${TOTO}
721 # Replace the @TOTO@ by ${TOTO}
723 line = p_dollar.sub(r"${\1}", line)
724 line = p_arobas.sub(r"${\1}", line)
727 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
728 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
729 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
730 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
731 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
734 # Check if the line is a 'if' condition
735 # If yes, replace it by a cmake grammar
737 match = p_if.match(line)
739 theif = match.group("val")
741 theif = "NOT " + theif[1:]
743 line = p_if.sub(r"IF(%s)"%(theif), line)
744 opened_ifs.append(theif)
745 newlines.append(line)
749 # Check if the line is a 'else' condition
750 # If yes, replace it by a cmake grammar
752 match = p_else.match(line)
754 line = "ELSE(%s)"%(opened_ifs[-1])
755 newlines.append(line)
759 # Check if the line is a 'endif' condition
760 # If yes, replace it by a cmake grammar
762 match = p_endif.match(line)
764 line = "ENDIF(%s)"%(opened_ifs[-1])
766 newlines.append(line)
770 # Check if the line is an attribution '=' or '+='
772 match = p_attribution.match(line)
774 self.treatAttribution(match, newlines)
778 newlines.append(line)
783 def treatAttribution(self, match, newlines):
785 spaces = match.group("spaces")
786 key = match.group("key")
787 method = match.group("method")
788 value = match.group("value")
789 # print [spaces, key, method, value]
792 # Open cmake SET command
794 newlines.append(spaces + "SET(" + key)
797 # If method is '+=', put the previous definition as first value
800 newlines.append("%s ${%s}"%(spaces, key))
804 fields = value.split()
805 for i in range(len(fields)):
806 newlines.append("%s %s"%(spaces, fields[i]))
812 # The try: except KeyError is here if the +=
813 # is an error which occurs in salome ...
816 self.__thedict__[key] += fields[:]
818 self.__thedict__[key] = fields[:]
822 self.__thedict__[key] = fields[:]
826 # Close cmake SET command
829 newlines.append("%s)"%(spaces))
833 def finalize(self, newlines):
836 # Convert the .in files in build dir
840 if f == "sstream.in":
842 if f in ["runContainer.in", "stopContainer.in"]:
843 if self.module == "med":
844 if self.root[-3:] == "csh":
848 if f == "SALOMEconfig.ref.in":
849 out = "SALOMEconfig.h"
854 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
857 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
860 MESSAGE(STATUS "Creation of ${output}")
861 CONFIGURE_FILE(${input} ${output})
867 # convert the SUBDIRS in cmake grammar
869 if 1: # self.__thedict__.has_key("SUBDIRS"):
871 FOREACH(dir ${SUBDIRS})
872 IF(NOT dir STREQUAL .)
873 ADD_SUBDIRECTORY(${dir})
874 ENDIF(NOT dir STREQUAL .)
875 ENDFOREACH(dir ${SUBDIRS})
881 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
882 if self.__thedict__.has_key(key):
883 self.addLibTarget(key, newlines)
889 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
890 if self.__thedict__.has_key(key):
891 self.addBinTarget(key, newlines)
897 if self.__thedict__.has_key("BASEIDL_FILES"):
898 if not self.__thedict__.has_key("IDL_FILES"):
899 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
901 SET(IDL_FILES ${BASEIDL_FILES})
910 if self.__thedict__.has_key(key):
911 if self.module == "kernel":
913 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
917 FOREACH(input ${IDL_FILES})
918 STRING(REGEX REPLACE ".idl" "" base ${input})
919 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
921 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
922 SET(outputs ${outputs} ${dynsrc})
923 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
924 SET(outputs ${outputs} ${inc})
925 IF(input STREQUAL Calcium_Ports.idl)
926 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
927 ELSE(input STREQUAL Calcium_Ports.idl)
928 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
929 ENDIF(input STREQUAL Calcium_Ports.idl)
930 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
931 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
933 SET(flags -bcxx ${flags})
937 COMMAND ${OMNIORB_IDL} ${flags} ${input}
938 MAIN_DEPENDENCY ${input}
940 install(FILES ${input} DESTINATION idl/salome)
941 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
942 install(FILES ${IDL_HEADER} DESTINATION include/salome)
943 INSTALL(CODE "SET(IDL_FILE ${input})")
944 INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
945 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
946 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
949 FOREACH(f ${IDLPYFLAGS})
950 SET(flags "${flags} ${f}")
951 ENDFOREACH(f ${IDLPYFLAGS})
952 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
954 SET(flags "-bpython ${flags}")
956 SET(IDLPYFLAGS ${flags})
957 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
958 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
961 if self.module == "kernel":
963 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
967 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
968 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
972 ENDFOREACH(input ${IDL_FILES})
978 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
979 if self.__thedict__.has_key(key):
981 SET(SWIG_SOURCES ${%s})
983 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
989 if self.__thedict__.has_key("SWIG_SOURCES"):
991 IF(SWIG_SOURCES MATCHES ";")
992 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
993 ELSE(SWIG_SOURCES MATCHES ";")
994 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
995 ENDIF(SWIG_SOURCES MATCHES ";")
998 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${MY_SWIG_FLAGS} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
999 MAIN_DEPENDENCY ${SWIG_SOURCES}
1006 if self.__thedict__.has_key("BUILT_SOURCES"):
1008 FOREACH(f ${BUILT_SOURCES})
1009 IF(f MATCHES "WRAP.cxx$")
1010 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1011 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1013 OUTPUT ${f} # ${inc}
1014 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1015 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1017 ENDIF(f MATCHES "WRAP.cxx$")
1018 ENDFOREACH(f ${BUILT_SOURCES})
1025 if self.__thedict__.has_key(key):
1027 FOREACH(output ${MOC_FILES})
1029 if self.module == "yacs":
1031 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1032 IF(input STREQUAL WrapGraphicsView.hxx)
1033 SET(input ../genericgui/${input})
1034 ENDIF(input STREQUAL WrapGraphicsView.hxx)
1038 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1042 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1043 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1046 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1047 MAIN_DEPENDENCY ${input}
1049 ENDFOREACH(output ${MOC_FILES})
1056 if self.__thedict__.has_key(key):
1058 FOREACH(output ${UIC_FILES})
1059 STRING(REPLACE "ui_" "" input ${output})
1060 STRING(REPLACE ".h" ".ui" input ${input})
1061 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1062 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1065 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1066 MAIN_DEPENDENCY ${input}
1068 ENDFOREACH(output ${UIC_FILES})
1075 if self.__thedict__.has_key(key):
1077 FOREACH(output ${QRC_FILES})
1078 STRING(REGEX REPLACE "qrc_" "" input ${output})
1079 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1080 STRING(REGEX REPLACE ".qrc" "" name ${input})
1081 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1082 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1085 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1086 MAIN_DEPENDENCY ${input}
1088 ENDFOREACH(output ${QRC_FILES})
1095 if self.__thedict__.has_key(key):
1097 FOREACH(input ${SIP_FILES})
1098 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1100 FOREACH(out ${SIP_SRC})
1101 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1102 ENDFOREACH(out ${SIP_SRC})
1105 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1106 MAIN_DEPENDENCY ${input}
1108 ENDFOREACH(input ${SIP_FILES})
1113 # Treat the install targets
1116 "salomeadmux_DATA" : "salome_adm/unix",
1117 "dist_salomeadmux_DATA" : "salome_adm/unix",
1118 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1119 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1120 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1121 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1122 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1123 "salomeinclude_DATA" : "include/salome",
1124 "salomeinclude_HEADERS" : "include/salome",
1125 "dist_salomeres_DATA" : "share/salome/resources/%s"%(self.module),
1126 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(self.module),
1127 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(self.module),
1128 "dist_salomescript_SCRIPTS" : "bin/salome",
1129 "dist_salomescript_DATA" : "bin/salome",
1130 "dist_salomescript_PYTHON" : "bin/salome",
1131 "nodist_salomescript_DATA" : "bin/salome",
1132 "salomepython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1133 "nodist_salomepython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1134 "dist_salomepython_DATA" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1135 "sharedpkgpython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1137 if self.module == "medfile":
1139 "include_HEADERS" : "include",
1140 "nodist_include_HEADERS" : "include",
1141 "bin_SCRIPTS" : "bin",
1142 "doc_DATA" : "${docdir}",
1145 for key, value in d.items():
1146 if self.__thedict__.has_key(key):
1147 self.addInstallTarget(key, value, newlines)
1154 def setLibAdd(self, key, newlines):
1156 newlines.append(r'''
1160 newlines.append(r'''
1163 SET(targets ${targets} MEFISTO2D)
1164 FOREACH(target ${targets})
1165 IF(name STREQUAL ${target})
1166 SET(dir $ENV{F2CHOME})
1167 STRING(REPLACE "\\\\" "/" dir ${dir})
1168 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1169 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1170 ENDIF(name STREQUAL ${target})
1171 ENDFOREACH(target ${targets})
1175 newlines.append(r'''
1176 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1177 FOREACH(lib SALOMEBasics SalomeBatch)
1178 IF(name STREQUAL lib)
1179 SET(libs ${libs} ${PTHREAD_LIBS})
1180 ENDIF(name STREQUAL lib)
1181 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1183 if key == "bin_PROGRAMS":
1184 newlines.append(r'''
1185 SET(libs ${libs} ${LDADD})
1189 newlines.append(r'''
1190 FOREACH(lib ${libs})
1191 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1192 IF(ext STREQUAL .la)
1193 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1194 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1195 ENDIF(ext STREQUAL .la)
1197 SET(vars ${vars} -no-undefined)
1198 SET(vars ${vars} -lvtkWidgets)
1200 SET(vars ${vars} -module)
1201 SET(vars ${vars} -Wl,-E)
1202 SET(vars ${vars} -Xlinker)
1203 SET(vars ${vars} -export-dynamic)
1204 SET(vars ${vars} -lm)
1205 SET(vars ${vars} -lboost_thread)
1206 SET(vars ${vars} -lboost_signals)
1207 SET(vars ${vars} -pthread -lpthread -ldl)
1212 ENDIF(lib STREQUAL v)
1213 ENDFOREACH(v ${vars})
1214 SET(libadd ${libadd} ${lib})
1215 ENDFOREACH(lib ${libs})
1216 TARGET_LINK_LIBRARIES(${name} ${libadd})
1219 newlines.append(r'''
1222 SET(targets ${targets} MEFISTO2D)
1223 FOREACH(target ${targets})
1224 IF(name STREQUAL ${target})
1225 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1226 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1227 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1228 ENDIF(name STREQUAL ${target})
1229 ENDFOREACH(target ${targets})
1235 def setCompilationFlags(self, key, newlines):
1236 newlines.append(r'''
1240 SET(targets ${targets} SalomeIDLKernel)
1241 SET(targets ${targets} SalomeDS)
1242 SET(targets ${targets} SALOMEDSTest)
1243 SET(targets ${targets} SALOMEDS_Client_exe)
1244 SET(targets ${targets} SalomeIDLGEOM)
1245 SET(targets ${targets} GEOMEngine)
1246 SET(targets ${targets} MEDEngine)
1247 SET(targets ${targets} SMESHEngine)
1248 SET(targets ${targets} SMESH)
1249 FOREACH(target ${targets})
1250 IF(name STREQUAL ${target})
1251 SET(var ${var} -DNOGDI)
1252 ENDIF(name STREQUAL ${target})
1253 ENDFOREACH(target ${targets})
1257 if self.module == "yacs":
1258 newlines.append(r'''
1260 SET(var ${var} -DNOGDI)
1265 newlines.append(r'''
1268 SET(targets ${targets} MEFISTO2D)
1269 FOREACH(target ${targets})
1270 IF(name STREQUAL ${target})
1271 SET(dir $ENV{F2CHOME})
1272 STRING(REPLACE "\\\\" "/" dir ${dir})
1273 SET(var ${var} -I${dir})
1274 SET(var ${var} -DF2C_BUILD)
1275 ENDIF(name STREQUAL ${target})
1276 ENDFOREACH(target ${targets})
1280 if self.module in ["geom", "med"]:
1281 newlines.append(r'''
1282 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1283 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1286 newlines.append(r'''
1287 SET(var ${var} ${AM_CPPFLAGS})
1288 SET(var ${var} ${AM_CXXFLAGS})
1290 if self.module == "yacs":
1291 newlines.append(r'''
1292 SET(var ${var} -DYACS_PTHREAD)
1293 SET(var ${var} -DCMAKE_BUILD)
1294 SET(var ${var} -DSALOME_KERNEL)
1295 SET(var ${var} -DDSC_PORTS)
1296 SET(var ${var} -DOMNIORB)
1299 newlines.append(r'''
1300 SET(var ${var} ${PLATFORM_CPPFLAGS})
1301 SET(var ${var} ${PTHREAD_CFLAGS})
1302 SET(var ${var} ${${amname}_CPPFLAGS})
1303 SET(var ${var} ${${amname}_CXXFLAGS})
1304 SET(var ${var} ${${amname}_CFLAGS})
1307 SET(vars ${vars} -include SALOMEconfig.h)
1308 SET(vars ${vars} -ftemplate-depth-32)
1309 SET(vars ${vars} -fPIC)
1310 SET(vars ${vars} -g)
1318 ENDFOREACH(v ${vars})
1319 SET(flags "${flags} ${f}")
1320 ENDFOREACH(f ${var})
1321 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1325 def addLibTarget(self, key, newlines):
1326 newlines.append(r'''
1327 FOREACH(amname ${%s})
1330 # Replace .la by _la ...
1332 newlines.append(r'''
1333 STRING(REPLACE .la _la amname ${amname})
1336 # Remove the _la for the cmake name
1338 newlines.append(r'''
1339 STRING(LENGTH ${amname} len)
1340 MATH(EXPR newlen "${len}-3")
1341 STRING(SUBSTRING ${amname} 0 ${newlen} name)
1344 # Does the target begins with lib ??
1345 # If yes, remove lib at beginning for cmake name
1347 newlines.append(r'''
1348 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1350 STRING(LENGTH ${name} len)
1351 MATH(EXPR newlen "${len}-3")
1352 STRING(SUBSTRING ${name} 3 ${newlen} name)
1353 ENDIF(BEGIN_WITH_lib)
1356 # Does the target is an idl library
1358 newlines.append(r'''
1359 STRING(REGEX MATCH "IDL" ISIDL ${name})
1362 # Set the type of the library
1364 newlines.append(r'''
1376 # Set sources for the library
1378 newlines.append(r'''
1380 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1381 GET_FILENAME_COMPONENT(ext ${src} EXT)
1383 IF(src STREQUAL trte.f)
1384 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1385 STRING(REPLACE ".f" ".c" src ${src})
1386 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1390 COMMAND f2c ${input}
1391 MAIN_DEPENDENCY ${input}
1393 ELSE(src STREQUAL trte.f)
1394 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1395 STRING(REPLACE ".f" ".o" src ${src})
1396 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1405 COMMAND ${F77} -c -o ${output} ${input}
1406 MAIN_DEPENDENCY ${input}
1408 ENDIF(src STREQUAL trte.f)
1409 ENDIF(ext STREQUAL .f)
1410 SET(srcs ${srcs} ${src})
1411 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1413 newlines.append(r'''
1414 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1416 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1417 SET(srcs ${srcs} ${src})
1420 newlines.append(r'''
1422 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1424 GET_FILENAME_COMPONENT(ext ${f} EXT)
1425 IF(ext STREQUAL .py)
1426 ELSE(ext STREQUAL .py)
1427 SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1428 ENDIF(ext STREQUAL .py)
1432 # Add the library to cmake
1434 newlines.append(r'''
1435 ADD_LIBRARY(${name} ${type} ${srcs})
1438 # The compilation flags
1440 self.setCompilationFlags(key, newlines)
1442 newlines.append(r'''
1443 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1446 self.setLibAdd(key, newlines)
1448 if 1: # key != "noinst_LTLIBRARIES":
1449 if self.module == "medfile":
1450 newlines.append(r'''
1454 newlines.append(r'''
1455 SET(DEST lib/salome)
1458 newlines.append(r'''
1460 INSTALL(TARGETS ${name} DESTINATION ${DEST})
1462 if self.module == "gui":
1463 newlines.append(r'''
1464 FOREACH(lib SalomePyQt)
1465 IF(name STREQUAL lib)
1467 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1468 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1469 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1470 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1471 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1473 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1475 ENDIF(name STREQUAL lib)
1476 ENDFOREACH(lib SalomePyQt)
1477 FOREACH(lib SalomePy)
1478 IF(name STREQUAL lib)
1480 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1481 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1482 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1483 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1484 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1486 ENDIF(name STREQUAL lib)
1487 ENDFOREACH(lib SalomePy)
1490 if self.module == "geom":
1491 newlines.append(r'''
1493 STRING(REGEX MATCH "Export" ISExport ${name})
1495 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1497 STRING(REGEX MATCH "Import" ISImport ${name})
1499 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1504 newlines.append(r'''
1505 ELSE(BEGIN_WITH_lib)
1507 newlines.append(r'''
1509 INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1510 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1511 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.pyd)
1512 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1513 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/lib/python${PYTHON_VERSION}/site-packages/salome/${name}.dll DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}_d.pyd)
1514 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1516 GET_TARGET_PROPERTY(version ${name} VERSION)
1517 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1518 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1519 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1520 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1523 newlines.append(r'''
1524 ENDIF(BEGIN_WITH_lib)
1528 newlines.append(r'''
1529 ENDFOREACH(amname ${%s})
1534 def addBinTarget(self, key, newlines):
1536 newlines.append(r'''
1537 FOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1540 newlines.append(r'''
1541 SET(name "${amname}_exe")
1542 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1543 SET(l ${nodist_${amname}_SOURCES})
1545 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1546 SET(srcs ${srcs} ${src})
1548 LIST(LENGTH srcs nb)
1550 ADD_EXECUTABLE(${name} ${srcs})
1553 self.setCompilationFlags(key, newlines)
1555 self.setLibAdd(key, newlines)
1557 if self.module == "medfile":
1558 newlines.append(r'''
1562 newlines.append(r'''
1563 SET(DEST bin/salome)
1567 if key == "bin_PROGRAMS":
1568 newlines.append(r'''
1570 INSTALL(TARGETS ${name} DESTINATION ${DEST})
1571 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1572 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1575 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1576 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1577 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1578 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1583 newlines.append(r'''
1587 newlines.append(r'''
1588 ENDFOREACH(amname ${bin_PROGRAMS} ${check_PROGRAMS})
1593 def addInstallTarget(self, key, destination, newlines):
1594 newlines.append(r"FOREACH(f ${%s})"%(key))
1595 newlines.append(r'''
1598 newlines.append(r'''
1599 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1600 IF(test_SALOMEconfig.h.in)
1601 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1602 ELSE(test_SALOMEconfig.h.in)
1603 SET(dummy dummy-NOTFOUND)
1604 MARK_AS_ADVANCED(dummy)
1605 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1606 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1609 if key in ['dist_salomescript_SCRIPTS']:
1610 newlines.append(r'''
1612 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1613 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1614 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1615 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1618 newlines.append(r'''
1619 GET_FILENAME_COMPONENT(ext ${f} EXT)
1620 IF(ext STREQUAL .py)
1621 IF(DEST STREQUAL bin/salome)
1623 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1624 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1625 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1626 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1627 ELSE(DEST STREQUAL bin/salome)
1628 INSTALL(FILES ${f} DESTINATION ${DEST})
1629 ENDIF(DEST STREQUAL bin/salome)
1630 ELSE(ext STREQUAL .py)
1631 INSTALL(FILES ${f} DESTINATION ${DEST})
1632 ENDIF(ext STREQUAL .py)
1635 newlines.append(r'''
1637 GET_FILENAME_COMPONENT(ext ${f} EXT)
1638 IF(ext STREQUAL .qm)
1639 STRING(REGEX REPLACE .qm .ts input ${f})
1641 if self.module in ["kernel", "gui"]:
1642 newlines.append(r'''
1643 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1646 newlines.append(r'''
1647 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1650 newlines.append(r'''
1651 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1652 # ADD_CUSTOM_COMMAND(
1654 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1655 # MAIN_DEPENDENCY ${input}
1657 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1658 ENDIF(ext STREQUAL .qm)
1659 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1661 ENDIF(test_SALOMEconfig.h.in)
1663 newlines.append(r'''
1664 GET_FILENAME_COMPONENT(ext ${f} EXT)
1665 IF(ext STREQUAL .py)
1666 INSTALL(CODE "SET(PYTHON_FILE ${f})")
1667 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1668 INSTALL(CODE "SET(DEST ${DEST})")
1669 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1671 if self.module == "kernel":
1673 IF(f STREQUAL SALOME_ContainerPy.py)
1674 ELSE(f STREQUAL SALOME_ContainerPy.py)
1675 IF(f STREQUAL am2cmake.py)
1676 ELSE(f STREQUAL am2cmake.py)
1677 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1678 ENDIF(f STREQUAL am2cmake.py)
1679 ENDIF(f STREQUAL SALOME_ContainerPy.py)
1683 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1684 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1687 newlines.append(r'''
1688 ENDIF(ext STREQUAL .py)
1690 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1693 def writeListsFile(self):
1694 f = open(self.listsFile, "w")
1695 f.write(self.content)
1701 def convertAmFile(the_root, root, dirs, files, f, module):
1702 cmake = CMakeFile(the_root, root, dirs, files, f, module)
1703 cmake.writeListsFile()
1706 def usage(exit_status):
1707 from sys import exit
1708 from sys import argv
1709 print "Usage: %s --module"%(argv[0])
1713 if __name__ == "__main__":
1715 from sys import argv
1721 if module.find('--') != 0:
1725 if len(module) == 0:
1729 from os import getcwd
1733 for root, dirs, files in walk(the_root):
1735 # E.A. : Remove 'CVS' in dirs
1736 # E.A. : It allows to not recurse in CVS dirs
1737 # E.A. : See os module python documentation
1745 if f == "Makefile.am":
1746 convertAmFile(the_root, root, dirs, files, f, module)