1 # -*- coding: iso-8859-1 -*-
2 # Copyright (C) 2007-2010 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",
216 "SalomeCommunication",
218 "SalomeDSCContainer",
226 "SalomeLifeCycleCORBA",
228 "SalomeLoggerServer",
229 "SalomeNotification",
231 "SalomeResourcesManager",
233 "with_loggerTraceCollector",
285 "GEOMFiltersSelection",
309 "InterpGeometric2DAlg",
326 "GeomSelectionTools",
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)
441 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
442 INCLUDE(${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/FindMPI.cmake)
446 if self.module == "med":
448 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
450 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
451 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
452 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
453 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
454 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
455 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
456 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
457 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
458 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
459 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
460 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
461 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
462 ELSE(KERNEL_ROOT_DIR)
463 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindPLATFORM.cmake)
464 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local_without_kernel/cmake_files/FindMPI.cmake)
465 ENDIF(KERNEL_ROOT_DIR)
469 SET(KERNEL_ROOT_DIR $ENV{KERNEL_ROOT_DIR})
470 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPLATFORM.cmake)
471 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPYTHON.cmake)
472 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindOMNIORB.cmake)
473 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindPTHREADS.cmake)
474 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindHDF5.cmake)
475 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindBOOST.cmake)
476 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindLIBXML2.cmake)
477 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindSWIG.cmake)
478 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindCPPUNIT.cmake)
479 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindDOXYGEN.cmake)
480 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindMPI.cmake)
481 INCLUDE(${KERNEL_ROOT_DIR}/salome_adm/cmake_files/FindKERNEL.cmake)
484 if self.module == "gui":
486 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindCAS.cmake)
487 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQT4.cmake)
488 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
489 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindVTK.cmake)
490 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindQWT.cmake)
491 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
495 SET(GUI_ROOT_DIR $ENV{GUI_ROOT_DIR})
497 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindCAS.cmake)
498 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQT4.cmake)
499 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindOPENGL.cmake)
500 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindVTK.cmake)
501 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindQWT.cmake)
502 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindSIPPYQT.cmake)
503 INCLUDE(${GUI_ROOT_DIR}/adm_local/cmake_files/FindGUI.cmake)
506 if self.module == "med":
508 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
510 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindXDR.cmake)
514 if self.module == "smesh":
516 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
517 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
518 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
519 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
520 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
523 if self.module == "netgenplugin":
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)
531 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindNETGEN.cmake)
534 if self.module == "blsurfplugin":
536 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
537 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
538 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
539 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
540 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
541 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
542 INCLUDE(${CMAKE_SOURCE_DIR}/adm_local/cmake_files/FindBLSURF.cmake)
545 if self.module in ["ghs3dplugin", "hexoticplugin"]:
547 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
548 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
549 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
550 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
551 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
552 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
555 if self.module == "ghs3dprlplugin":
557 SET(GEOM_ROOT_DIR $ENV{GEOM_ROOT_DIR})
558 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
559 SET(SMESH_ROOT_DIR $ENV{SMESH_ROOT_DIR})
560 INCLUDE(${GEOM_ROOT_DIR}/adm_local/cmake_files/FindGEOM.cmake)
561 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMEDFILE.cmake)
562 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
563 INCLUDE(${SMESH_ROOT_DIR}/adm_local/cmake_files/FindSMESH.cmake)
566 if self.module == "visu":
568 SET(MED_ROOT_DIR $ENV{MED_ROOT_DIR})
569 INCLUDE(${MED_ROOT_DIR}/adm_local/cmake_files/FindMED.cmake)
572 if self.module == "yacs":
574 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindEXPAT.cmake)
575 INCLUDE(${CMAKE_SOURCE_DIR}/adm/cmake/FindGRAPHVIZ.cmake)
584 if self.module not in ['med']:
592 if self.module == "kernel":
597 set(XVERSION 0x050104)
598 SET(CALCIUM_IDL_INT_F77 long)
599 SET(CALCIUM_CORBA_INT_F77 CORBA::Long)
602 elif self.module == "gui":
604 SET(GUI_ENABLE_CORBA ${CORBA_GEN})
605 SET(ENABLE_VTKVIEWER ON)
606 SET(ENABLE_SALOMEOBJECT ON)
607 SET(ENABLE_OCCVIEWER ON)
608 SET(ENABLE_GLVIEWER ON)
609 SET(ENABLE_PLOT2DVIEWER ON)
610 SET(ENABLE_PYCONSOLE ON)
611 SET(ENABLE_SUPERVGRAPHVIEWER ON)
612 SET(ENABLE_QXGRAPHVIEWER ON)
614 set(XVERSION 0x050104)
617 elif self.module == "geom":
620 SET(GEOM_ENABLE_GUI ON)
624 elif self.module == "medfile":
626 SET(MED_NUM_MAJEUR 2)
627 SET(MED_NUM_MINEUR 3)
628 SET(MED_NUM_RELEASE 5)
631 SET(FLIBS -lgfortranbegin -lgfortran)
635 elif self.module == "med":
638 SET(MED_ENABLE_KERNEL ON)
640 SET(MED_ENABLE_SPLITTER ON)
642 ENDIF(KERNEL_ROOT_DIR)
644 SET(MED_ENABLE_GUI ON)
648 elif self.module == "smesh":
651 SET(SMESH_ENABLE_GUI ON)
655 elif self.module == "netgenplugin":
658 SET(NETGENPLUGIN_ENABLE_GUI ON)
662 elif self.module == "blsurfplugin":
665 SET(BLSURFPLUGIN_ENABLE_GUI ON)
669 elif self.module == "ghs3dplugin":
672 SET(GHS3DPLUGIN_ENABLE_GUI ON)
676 elif self.module == "hexoticplugin":
679 SET(HEXOTICPLUGIN_ENABLE_GUI ON)
683 elif self.module == "ghs3dprlplugin":
686 SET(GHS3DPRLPLUGIN_ENABLE_GUI ON)
690 elif self.module == "yacs":
692 SET(SALOME_KERNEL ON)
701 SET(VERSION_INFO 0.0.0)
702 SET(SOVERSION_INFO 0)
708 if self.module == "kernel":
710 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
711 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${CMAKE_BINARY_DIR}/salome_adm/unix -include SALOMEconfig.h)
714 if self.module not in ["yacs"]:
717 SET(AM_CPPFLAGS ${AM_CPPFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
718 SET(AM_CXXFLAGS ${AM_CXXFLAGS} -DHAVE_SALOME_CONFIG -I${KERNEL_ROOT_DIR}/include/salome -include SALOMEconfig.h)
719 ENDIF(KERNEL_ROOT_DIR)
726 def treatLine(self, line, newlines, opened_ifs):
729 # Print the comment above the line itself
731 if line.find('#') >= 0:
732 fields = line.split('#')
734 comment = '#'.join([''] + fields[1:])
735 newlines.append(comment)
741 # If the line begins with 'include ', just comment it
743 if line.find("include ") == 0:
744 newlines.append("# " + line)
748 # If the line begins with '-include', just comment it
750 if line.find("-include") == 0:
751 newlines.append("# " + line)
755 # If the line is a definition of a make rule, just comment it
757 if line.count(':') == 1:
758 newlines.append("# " + line)
762 # A particuliar case where there are two ":" on the same line
764 if line.find('install-exec-local:') == 0:
765 newlines.append("# " + line)
769 # If the line begin by a tabulation, consider it's a makefile command and comment it
771 if line.find("\t") == 0:
772 newlines.append("# " + line)
777 key = "-version-info"
778 if line.find(key) >= 0:
780 before = line.split(key)[0]
781 after = line[len(before)+len(key):]
784 version_info = after.split()[0]
785 line = line.replace(key+sep+version_info, "")
787 version_info = version_info.replace(':', '.')
788 soversion_info = version_info.split('.')[0]
789 newlines.append("SET(VERSION_INFO " + version_info + ")")
790 newlines.append("SET(SOVERSION_INFO " + soversion_info + ")")
795 # Replace the $(TOTO) by ${TOTO}
796 # Replace the @TOTO@ by ${TOTO}
798 line = p_dollar.sub(r"${\1}", line)
799 line = p_arobas.sub(r"${\1}", line)
802 line = line.replace(r"${top_builddir}", r"${CMAKE_BINARY_DIR}")
803 line = line.replace(r"${top_srcdir}", r"${CMAKE_SOURCE_DIR}")
804 line = line.replace(r"${srcdir}", r"${CMAKE_CURRENT_SOURCE_DIR}")
805 line = line.replace(r"${builddir}", r"${CMAKE_CURRENT_BINARY_DIR}")
806 line = line.replace(r"${datadir}", r"${CMAKE_INSTALL_PREFIX}/share")
809 # Check if the line is a 'if' condition
810 # If yes, replace it by a cmake grammar
812 match = p_if.match(line)
814 theif = match.group("val")
816 theif = "NOT " + theif[1:]
818 line = p_if.sub(r"IF(%s)"%(theif), line)
819 opened_ifs.append(theif)
820 newlines.append(line)
824 # Check if the line is a 'else' condition
825 # If yes, replace it by a cmake grammar
827 match = p_else.match(line)
829 line = "ELSE(%s)"%(opened_ifs[-1])
830 newlines.append(line)
834 # Check if the line is a 'endif' condition
835 # If yes, replace it by a cmake grammar
837 match = p_endif.match(line)
839 line = "ENDIF(%s)"%(opened_ifs[-1])
841 newlines.append(line)
845 # Check if the line is an attribution '=' or '+='
847 match = p_attribution.match(line)
849 self.treatAttribution(match, newlines)
853 newlines.append(line)
858 def treatAttribution(self, match, newlines):
860 spaces = match.group("spaces")
861 key = match.group("key")
862 method = match.group("method")
863 value = match.group("value")
864 # print [spaces, key, method, value]
867 # Open cmake SET command
869 newlines.append(spaces + "SET(" + key)
872 # If method is '+=', put the previous definition as first value
875 newlines.append("%s ${%s}"%(spaces, key))
879 fields = value.split()
880 for i in range(len(fields)):
881 newlines.append("%s %s"%(spaces, fields[i]))
887 # The try: except KeyError is here if the +=
888 # is an error which occurs in salome ...
891 self.__thedict__[key] += fields[:]
893 self.__thedict__[key] = fields[:]
897 self.__thedict__[key] = fields[:]
901 # Close cmake SET command
904 newlines.append("%s)"%(spaces))
908 def finalize(self, newlines):
911 # Convert the .in files in build dir
913 if self.module == "yacs":
915 if self.root[-len(key):] == key:
916 self.files.append("resources/YACSCatalog.xml.in")
921 if f == "sstream.in":
923 if f in ["runContainer.in", "stopContainer.in"]:
924 if self.module == "med":
925 if self.root[-3:] == "csh":
929 if f == "SALOMEconfig.ref.in":
930 out = "SALOMEconfig.h"
935 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/%s)
938 SET(output ${CMAKE_CURRENT_BINARY_DIR}/%s)
941 MESSAGE(STATUS "Creation of ${output}")
942 CONFIGURE_FILE(${input} ${output})
948 # convert the SUBDIRS in cmake grammar
950 if 1: # self.__thedict__.has_key("SUBDIRS"):
952 FOREACH(dir ${SUBDIRS})
953 IF(NOT dir STREQUAL .)
954 ADD_SUBDIRECTORY(${dir})
955 ENDIF(NOT dir STREQUAL .)
956 ENDFOREACH(dir ${SUBDIRS})
962 for key in ["lib_LTLIBRARIES", "noinst_LTLIBRARIES", "salomepyexec_LTLIBRARIES"]:
963 if self.__thedict__.has_key(key):
964 self.addLibTarget(key, newlines)
970 for key in ["bin_PROGRAMS", "check_PROGRAMS"]:
971 if self.__thedict__.has_key(key):
972 self.addBinTarget(key, newlines)
978 if self.__thedict__.has_key("BASEIDL_FILES"):
979 if not self.__thedict__.has_key("IDL_FILES"):
980 self.__thedict__["IDL_FILES"] = self.__thedict__["BASEIDL_FILES"]
982 SET(IDL_FILES ${BASEIDL_FILES})
991 if self.__thedict__.has_key(key):
992 if self.module == "kernel":
994 SET(IDL_FILES ${IDL_FILES} Calcium_Ports.idl)
998 FOREACH(input ${IDL_FILES})
999 STRING(REGEX REPLACE ".idl" "" base ${input})
1000 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${base}SK.cc)
1002 SET(dynsrc ${CMAKE_CURRENT_BINARY_DIR}/${base}DynSK.cc)
1003 SET(outputs ${outputs} ${dynsrc})
1004 SET(inc ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1005 SET(outputs ${outputs} ${inc})
1006 IF(input STREQUAL Calcium_Ports.idl)
1007 SET(input ${CMAKE_CURRENT_BINARY_DIR}/${input})
1008 ELSE(input STREQUAL Calcium_Ports.idl)
1009 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1010 ENDIF(input STREQUAL Calcium_Ports.idl)
1011 SET(flags ${IDLCXXFLAGS} ${OMNIORB_IDLCXXFLAGS})
1012 STRING(REGEX MATCH "-bcxx" ISBCXX ${flags})
1014 SET(flags -bcxx ${flags})
1018 COMMAND ${OMNIORB_IDL} ${flags} ${input}
1019 MAIN_DEPENDENCY ${input}
1023 install(FILES ${input} DESTINATION idl/salome)
1025 if self.module not in ["pyhello"]:
1027 SET(IDL_HEADER ${CMAKE_CURRENT_BINARY_DIR}/${base}.hh)
1028 install(FILES ${IDL_HEADER} DESTINATION include/salome)
1032 INSTALL(CODE "SET(IDL_FILE ${input})")
1033 INSTALL(CODE "SET(DIR lib/python${PYTHON_VERSION}/site-packages/salome)")
1034 INSTALL(CODE "SET(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})")
1035 INSTALL(CODE "SET(OMNIORB_IDL_PYTHON ${OMNIORB_IDL_PYTHON})")
1038 FOREACH(f ${IDLPYFLAGS})
1039 SET(flags "${flags} ${f}")
1040 ENDFOREACH(f ${IDLPYFLAGS})
1041 STRING(REGEX MATCH "-bpython" ISBPYTHON ${flags})
1043 SET(flags "-bpython ${flags}")
1044 ENDIF(NOT ISBPYTHON)
1045 SET(IDLPYFLAGS ${flags})
1046 STRING(REPLACE "\\\\" "/" IDLPYFLAGS ${IDLPYFLAGS})
1047 INSTALL(CODE "SET(IDLPYFLAGS ${IDLPYFLAGS})")
1050 if self.module == "kernel":
1052 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1056 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1057 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_python_from_idl.cmake)
1061 ENDFOREACH(input ${IDL_FILES})
1067 for key in ["SWIG_SRC", "SWIGSOURCES", "SWIG_DEF"]:
1068 if self.__thedict__.has_key(key):
1070 SET(SWIG_SOURCES ${%s})
1072 self.__thedict__["SWIG_SOURCES"] = self.__thedict__[key]
1078 if self.__thedict__.has_key("SWIG_SOURCES"):
1080 IF(SWIG_SOURCES MATCHES ";")
1081 STRING(REGEX REPLACE ";.*" "" SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1082 ELSE(SWIG_SOURCES MATCHES ";")
1083 SET(SWIG_SOURCES_FIRST "${SWIG_SOURCES}")
1084 ENDIF(SWIG_SOURCES MATCHES ";")
1086 FOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1089 LIST(FIND flags ${f} index)
1090 IF(NOT index EQUAL -1)
1092 ENDIF(NOT index EQUAL -1)
1095 SET(flags ${flags} ${f})
1097 ENDFOREACH(f ${SWIG_FLAGS} ${MY_SWIG_FLAGS})
1099 OUTPUT ${build_srcs}
1100 COMMAND ${SWIG_EXECUTABLE} ${flags} -o ${build_srcs} ${CMAKE_CURRENT_SOURCE_DIR}/${SWIG_SOURCES_FIRST}
1101 MAIN_DEPENDENCY ${SWIG_SOURCES}
1108 if self.__thedict__.has_key("BUILT_SOURCES"):
1110 FOREACH(f ${BUILT_SOURCES})
1111 IF(f MATCHES "WRAP.cxx$")
1112 # STRING(REGEX REPLACE "WRAP.cxx" "WRAP.h" inc ${f})
1113 STRING(REGEX REPLACE "WRAP.cxx" ".i" input ${f})
1115 OUTPUT ${f} # ${inc}
1116 COMMAND ${SWIG_EXECUTABLE} ${SWIG_FLAGS} ${SWIG_PYTHON_INCLUDES} ${MYSWIG_FLAGS} -o ${f} ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1117 MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/${input}
1119 ENDIF(f MATCHES "WRAP.cxx$")
1120 ENDFOREACH(f ${BUILT_SOURCES})
1127 if self.__thedict__.has_key(key):
1129 FOREACH(output ${MOC_FILES})
1131 if self.module == "yacs":
1133 STRING(REGEX REPLACE _moc.cxx .hxx input ${output})
1137 STRING(REGEX REPLACE _moc.cxx .h input ${output})
1141 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1142 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1145 COMMAND ${QT_MOC_EXECUTABLE} ${MOC_FLAGS} ${input} -o ${output}
1146 MAIN_DEPENDENCY ${input}
1148 ENDFOREACH(output ${MOC_FILES})
1155 if self.__thedict__.has_key(key):
1157 FOREACH(output ${UIC_FILES})
1158 STRING(REPLACE "ui_" "" input ${output})
1159 STRING(REPLACE ".h" ".ui" input ${input})
1160 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1161 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1164 COMMAND ${QT_UIC_EXECUTABLE} -o ${output} ${input}
1165 MAIN_DEPENDENCY ${input}
1167 ENDFOREACH(output ${UIC_FILES})
1174 if self.__thedict__.has_key(key):
1176 FOREACH(output ${QRC_FILES})
1177 STRING(REGEX REPLACE "qrc_" "" input ${output})
1178 STRING(REGEX REPLACE ".cxx" ".qrc" input ${input})
1179 STRING(REGEX REPLACE ".qrc" "" name ${input})
1180 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1181 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${output})
1184 COMMAND ${QT_RCC_EXECUTABLE} ${input} -o ${output} -name ${name}
1185 MAIN_DEPENDENCY ${input}
1187 ENDFOREACH(output ${QRC_FILES})
1194 if self.__thedict__.has_key(key):
1196 FOREACH(input ${SIP_FILES})
1197 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1199 FOREACH(out ${SIP_SRC})
1200 SET(output ${output} ${CMAKE_CURRENT_BINARY_DIR}/${out})
1201 ENDFOREACH(out ${SIP_SRC})
1204 COMMAND ${SIP_EXECUTABLE} ${PYQT_SIPFLAGS} ${input}
1205 MAIN_DEPENDENCY ${input}
1207 ENDFOREACH(input ${SIP_FILES})
1212 # Treat the install targets
1215 "salomeadmux_DATA" : "salome_adm/unix",
1216 "dist_salomeadmux_DATA" : "salome_adm/unix",
1217 "dist_salome_cmake_DATA" : "salome_adm/cmake_files",
1218 "dist_salomem4_DATA" : "salome_adm/unix/config_files",
1219 "dist_salome4depr_DATA" : "salome_adm/unix/config_files/DEPRECATED",
1220 "dist_admlocalm4_DATA" : "adm_local/unix/config_files",
1221 "dist_admlocal_cmake_DATA" : "adm_local/cmake_files",
1222 "salomeinclude_DATA" : "include/salome",
1223 "salomeinclude_HEADERS" : "include/salome",
1224 "dist_salomeres_DATA" : "share/salome/resources/%s"%(self.module),
1225 "nodist_salomeres_DATA" : "share/salome/resources/%s"%(self.module),
1226 "nodist_salomeres_SCRIPTS" : "share/salome/resources/%s"%(self.module),
1227 "dist_salomescript_SCRIPTS" : "bin/salome",
1228 "dist_salomescript_DATA" : "bin/salome",
1229 "dist_salomescript_PYTHON" : "bin/salome",
1230 "nodist_salomescript_DATA" : "bin/salome",
1231 "salomepython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1232 "nodist_salomepython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1233 "dist_salomepython_DATA" : "lib/python${PYTHON_VERSION}/site-packages/salome",
1234 "sharedpkgpython_PYTHON" : "lib/python${PYTHON_VERSION}/site-packages/salome/shared_modules",
1236 if self.module == "medfile":
1238 "include_HEADERS" : "include",
1239 "nodist_include_HEADERS" : "include",
1240 "bin_SCRIPTS" : "bin",
1241 "doc_DATA" : "${docdir}",
1244 for key, value in d.items():
1245 if self.__thedict__.has_key(key):
1246 self.addInstallTarget(key, value, newlines)
1253 def setLibAdd(self, key, newlines):
1255 newlines.append(r'''
1259 newlines.append(r'''
1262 SET(targets ${targets} MEFISTO2D)
1263 FOREACH(target ${targets})
1264 IF(name STREQUAL ${target})
1265 SET(dir $ENV{F2CHOME})
1266 STRING(REPLACE "\\\\" "/" dir ${dir})
1267 SET(libadd ${libadd} ${dir}/LIBF77.lib)
1268 SET(libadd ${libadd} ${dir}/LIBI77.lib)
1269 ENDIF(name STREQUAL ${target})
1270 ENDFOREACH(target ${targets})
1274 newlines.append(r'''
1275 SET(libs ${PLATFORM_LIBADD} ${PLATFORM_LDFLAGS} ${${amname}_LIBADD} ${${amname}_LDADD} ${${amname}_LDFLAGS})
1276 FOREACH(lib SALOMEBasics SalomeBatch)
1277 IF(name STREQUAL lib)
1278 SET(libs ${libs} ${PTHREAD_LIBS})
1279 ENDIF(name STREQUAL lib)
1280 ENDFOREACH(lib SALOMEBasics SalomeBatch)
1282 if key == "bin_PROGRAMS":
1283 newlines.append(r'''
1284 SET(libs ${libs} ${LDADD})
1288 newlines.append(r'''
1289 FOREACH(lib ${libs})
1290 GET_FILENAME_COMPONENT(ext ${lib} EXT)
1291 IF(ext STREQUAL .la)
1292 GET_FILENAME_COMPONENT(lib ${lib} NAME_WE)
1293 STRING(REGEX REPLACE "^lib" "" lib ${lib})
1294 ENDIF(ext STREQUAL .la)
1296 SET(vars ${vars} -no-undefined)
1297 SET(vars ${vars} -lvtkWidgets)
1299 SET(vars ${vars} -module)
1300 SET(vars ${vars} -Wl,-E)
1301 SET(vars ${vars} -Xlinker)
1302 SET(vars ${vars} -export-dynamic)
1303 SET(vars ${vars} -lm)
1304 SET(vars ${vars} -lboost_thread)
1305 SET(vars ${vars} -lboost_signals)
1306 SET(vars ${vars} -pthread -lpthread -ldl)
1311 ENDIF(lib STREQUAL v)
1312 ENDFOREACH(v ${vars})
1313 SET(libadd ${libadd} ${lib})
1314 ENDFOREACH(lib ${libs})
1315 TARGET_LINK_LIBRARIES(${name} ${libadd})
1318 newlines.append(r'''
1321 SET(targets ${targets} MEFISTO2D)
1322 FOREACH(target ${targets})
1323 IF(name STREQUAL ${target})
1324 IF(CMAKE_BUILD_TYPE STREQUAL Debug)
1325 SET_TARGET_PROPERTIES(${name} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:MSVCRT")
1326 ENDIF(CMAKE_BUILD_TYPE STREQUAL Debug)
1327 ENDIF(name STREQUAL ${target})
1328 ENDFOREACH(target ${targets})
1334 def setCompilationFlags(self, key, newlines):
1335 newlines.append(r'''
1339 SET(targets ${targets} SalomeIDLKernel)
1340 SET(targets ${targets} SalomeDS)
1341 SET(targets ${targets} SALOMEDSTest)
1342 SET(targets ${targets} SALOMEDS_Client_exe)
1343 SET(targets ${targets} SalomeIDLGEOM)
1344 SET(targets ${targets} GEOMEngine)
1345 SET(targets ${targets} MEDEngine)
1346 SET(targets ${targets} SMESHEngine)
1347 SET(targets ${targets} SMESH)
1348 FOREACH(target ${targets})
1349 IF(name STREQUAL ${target})
1350 SET(var ${var} -DNOGDI)
1351 ENDIF(name STREQUAL ${target})
1352 ENDFOREACH(target ${targets})
1356 if self.module in ["medfile", "yacs"]:
1357 newlines.append(r'''
1359 SET(var ${var} -DNOGDI)
1364 newlines.append(r'''
1367 SET(targets ${targets} MEFISTO2D)
1368 FOREACH(target ${targets})
1369 IF(name STREQUAL ${target})
1370 SET(dir $ENV{F2CHOME})
1371 STRING(REPLACE "\\\\" "/" dir ${dir})
1372 SET(var ${var} -I${dir})
1373 SET(var ${var} -DF2C_BUILD)
1374 ENDIF(name STREQUAL ${target})
1375 ENDFOREACH(target ${targets})
1379 if self.module in ["geom", "med"]:
1380 newlines.append(r'''
1381 SET(var ${var} -I${CMAKE_CURRENT_SOURCE_DIR})
1382 SET(var ${var} -I${CMAKE_CURRENT_BINARY_DIR})
1385 newlines.append(r'''
1386 SET(var ${var} ${AM_CPPFLAGS})
1387 SET(var ${var} ${AM_CXXFLAGS})
1389 if self.module == "yacs":
1390 newlines.append(r'''
1391 SET(var ${var} -DYACS_PTHREAD)
1392 SET(var ${var} -DCMAKE_BUILD)
1393 SET(var ${var} -DSALOME_KERNEL)
1394 SET(var ${var} -DDSC_PORTS)
1395 SET(var ${var} -DOMNIORB)
1398 newlines.append(r'''
1399 SET(var ${var} ${PLATFORM_CPPFLAGS})
1400 SET(var ${var} ${PTHREAD_CFLAGS})
1401 SET(var ${var} ${${amname}_CPPFLAGS})
1402 SET(var ${var} ${${amname}_CXXFLAGS})
1403 SET(var ${var} ${${amname}_CFLAGS})
1406 SET(vars ${vars} -include SALOMEconfig.h)
1407 SET(vars ${vars} -ftemplate-depth-32)
1408 SET(vars ${vars} -fPIC)
1409 SET(vars ${vars} -g)
1417 ENDFOREACH(v ${vars})
1418 SET(flags "${flags} ${f}")
1419 ENDFOREACH(f ${var})
1420 SET_TARGET_PROPERTIES(${name} PROPERTIES COMPILE_FLAGS "${flags}")
1424 def addLibTarget(self, key, newlines):
1425 newlines.append(r'''
1426 FOREACH(amname ${%s})
1429 # Replace .la by _la ...
1431 newlines.append(r'''
1432 STRING(REPLACE .la _la amname ${amname})
1435 # Remove the _la for the cmake name
1437 newlines.append(r'''
1438 STRING(LENGTH ${amname} len)
1439 MATH(EXPR newlen "${len}-3")
1440 STRING(SUBSTRING ${amname} 0 ${newlen} name)
1443 # Does the target begins with lib ??
1444 # If yes, remove lib at beginning for cmake name
1446 newlines.append(r'''
1447 STRING(REGEX MATCH "^lib" BEGIN_WITH_lib ${name})
1449 STRING(LENGTH ${name} len)
1450 MATH(EXPR newlen "${len}-3")
1451 STRING(SUBSTRING ${name} 3 ${newlen} name)
1452 ENDIF(BEGIN_WITH_lib)
1455 # Does the target is an idl library
1457 newlines.append(r'''
1458 STRING(REGEX MATCH "IDL" ISIDL ${name})
1461 # Set the type of the library
1463 newlines.append(r'''
1474 if key == "noinst_LTLIBRARIES":
1475 newlines.append(r'''
1484 # Set sources for the library
1486 newlines.append(r'''
1488 FOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1489 GET_FILENAME_COMPONENT(ext ${src} EXT)
1491 IF(src STREQUAL trte.f)
1492 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1493 STRING(REPLACE ".f" ".c" src ${src})
1494 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1498 COMMAND f2c ${input}
1499 MAIN_DEPENDENCY ${input}
1501 ELSE(src STREQUAL trte.f)
1502 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${src})
1503 STRING(REPLACE ".f" ".o" src ${src})
1504 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${src})
1513 COMMAND ${F77} -c -o ${output} ${input}
1514 MAIN_DEPENDENCY ${input}
1516 ENDIF(src STREQUAL trte.f)
1517 ENDIF(ext STREQUAL .f)
1518 SET(srcs ${srcs} ${src})
1519 ENDFOREACH(src ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1521 newlines.append(r'''
1522 SET(l ${nodist_${amname}_SOURCES} ${UIC_FILES})
1524 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1525 SET(srcs ${srcs} ${src})
1528 newlines.append(r'''
1530 SET(l ${nodist_${amname}_SOURCES} ${BUILT_SOURCES})
1532 GET_FILENAME_COMPONENT(ext ${f} EXT)
1533 IF(ext STREQUAL .py)
1534 ELSE(ext STREQUAL .py)
1535 SET(build_srcs ${build_srcs} ${CMAKE_CURRENT_BINARY_DIR}/${f})
1536 ENDIF(ext STREQUAL .py)
1540 # Add the library to cmake
1542 newlines.append(r'''
1543 ADD_LIBRARY(${name} ${type} ${srcs})
1546 # The compilation flags
1548 self.setCompilationFlags(key, newlines)
1550 newlines.append(r'''
1551 SET_TARGET_PROPERTIES(${name} PROPERTIES VERSION ${VERSION_INFO} SOVERSION ${SOVERSION_INFO})
1554 self.setLibAdd(key, newlines)
1556 if key != "noinst_LTLIBRARIES":
1557 if self.module == "medfile":
1558 newlines.append(r'''
1562 newlines.append(r'''
1563 SET(DEST lib/salome)
1566 newlines.append(r'''
1568 INSTALL(TARGETS ${name} DESTINATION ${DEST})
1570 if self.module == "gui":
1571 newlines.append(r'''
1572 FOREACH(lib SalomePyQt)
1573 IF(name STREQUAL lib)
1575 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1576 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}.pyd)
1577 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1578 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME ${name}_d.pyd)
1579 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1581 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so DESTINATION ${DEST} RENAME ${name}.so)
1583 ENDIF(name STREQUAL lib)
1584 ENDFOREACH(lib SalomePyQt)
1585 FOREACH(lib SalomePy)
1586 IF(name STREQUAL lib)
1588 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1589 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.pyd)
1590 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1591 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}_d.pyd)
1592 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1594 ENDIF(name STREQUAL lib)
1595 ENDFOREACH(lib SalomePy)
1598 if self.module == "geom":
1599 newlines.append(r'''
1601 STRING(REGEX MATCH "Export" ISExport ${name})
1603 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1605 STRING(REGEX MATCH "Import" ISImport ${name})
1607 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.dll DESTINATION ${DEST} RENAME lib${name}.dll)
1612 newlines.append(r'''
1613 ELSE(BEGIN_WITH_lib)
1615 newlines.append(r'''
1617 INSTALL(TARGETS ${name} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome)
1618 IF(CMAKE_BUILD_TYPE STREQUAL Release)
1619 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)
1620 ELSE(CMAKE_BUILD_TYPE STREQUAL Release)
1621 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)
1622 ENDIF(CMAKE_BUILD_TYPE STREQUAL Release)
1624 GET_TARGET_PROPERTY(version ${name} VERSION)
1625 GET_TARGET_PROPERTY(soversion ${name} SOVERSION)
1626 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${version})
1627 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so.${soversion})
1628 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lib${name}.so.${version} DESTINATION lib/python${PYTHON_VERSION}/site-packages/salome RENAME ${name}.so)
1631 newlines.append(r'''
1632 ENDIF(BEGIN_WITH_lib)
1636 newlines.append(r'''
1637 ENDFOREACH(amname ${%s})
1642 def addBinTarget(self, key, newlines):
1644 newlines.append(r'''
1645 FOREACH(amname ${%s})
1648 newlines.append(r'''
1651 if key == "check_PROGRAMS":
1652 newlines.append(r'''
1654 STRING(REGEX MATCH ${amname} is_present ${bin_PROGRAMS})
1661 newlines.append(r'''
1665 newlines.append(r'''
1666 SET(name "${amname}_exe")
1667 SET(srcs ${${amname}_SOURCES} ${dist_${amname}_SOURCES})
1668 SET(l ${nodist_${amname}_SOURCES})
1670 SET(src ${CMAKE_CURRENT_BINARY_DIR}/${f})
1671 SET(srcs ${srcs} ${src})
1673 LIST(LENGTH srcs nb)
1675 ADD_EXECUTABLE(${name} ${srcs})
1678 self.setCompilationFlags(key, newlines)
1680 self.setLibAdd(key, newlines)
1682 if self.module == "medfile":
1683 newlines.append(r'''
1687 newlines.append(r'''
1688 SET(DEST bin/salome)
1692 if key == "bin_PROGRAMS":
1693 newlines.append(r'''
1695 INSTALL(TARGETS ${name} DESTINATION ${DEST})
1696 INSTALL(FILES ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe DESTINATION ${DEST} RENAME ${amname}.exe)
1697 INSTALL(CODE "FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${name}.exe)")
1700 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1701 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1702 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1703 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name} DESTINATION ${DEST} PERMISSIONS ${PERMS} RENAME ${amname})
1708 newlines.append(r'''
1712 newlines.append(r'''
1715 newlines.append(r'''
1716 ENDFOREACH(amname ${%s})
1721 def addInstallTarget(self, key, destination, newlines):
1722 newlines.append(r"FOREACH(f ${%s})"%(key))
1723 newlines.append(r'''
1726 newlines.append(r'''
1727 STRING(COMPARE EQUAL ${f} SALOMEconfig.h.in test_SALOMEconfig.h.in)
1728 IF(test_SALOMEconfig.h.in)
1729 INSTALL(FILES SALOMEconfig.ref.in DESTINATION ${DEST} RENAME SALOMEconfig.h.in)
1730 ELSE(test_SALOMEconfig.h.in)
1731 SET(dummy dummy-NOTFOUND)
1732 MARK_AS_ADVANCED(dummy)
1733 # FILE(REMOVE ${CMAKE_INSTALL_PREFIX}/${DEST}/${f})
1734 FIND_FILE(dummy ${f} PATHS ${CMAKE_CURRENT_SOURCE_DIR} NO_DEFAULT_PATH)
1737 if key in ['dist_salomescript_SCRIPTS']:
1738 newlines.append(r'''
1740 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1741 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1742 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1743 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1746 newlines.append(r'''
1747 GET_FILENAME_COMPONENT(ext ${f} EXT)
1748 IF(ext STREQUAL .py)
1749 IF(DEST STREQUAL bin/salome)
1751 SET(PERMS ${PERMS} OWNER_READ OWNER_WRITE OWNER_EXECUTE)
1752 SET(PERMS ${PERMS} GROUP_READ GROUP_EXECUTE)
1753 SET(PERMS ${PERMS} WORLD_READ WORLD_EXECUTE)
1754 INSTALL(FILES ${f} DESTINATION ${DEST} PERMISSIONS ${PERMS})
1755 ELSE(DEST STREQUAL bin/salome)
1756 INSTALL(FILES ${f} DESTINATION ${DEST})
1757 ENDIF(DEST STREQUAL bin/salome)
1758 ELSE(ext STREQUAL .py)
1759 INSTALL(FILES ${f} DESTINATION ${DEST})
1760 ENDIF(ext STREQUAL .py)
1763 newlines.append(r'''
1765 GET_FILENAME_COMPONENT(ext ${f} EXT)
1766 IF(ext STREQUAL .qm)
1767 STRING(REGEX REPLACE .qm .ts input ${f})
1769 if self.module in ["kernel", "gui", "yacs"]:
1770 newlines.append(r'''
1771 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/resources/${input})
1774 newlines.append(r'''
1775 SET(input ${CMAKE_CURRENT_SOURCE_DIR}/${input})
1778 newlines.append(r'''
1779 SET(output ${CMAKE_CURRENT_BINARY_DIR}/${f})
1780 # ADD_CUSTOM_COMMAND(
1782 # COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output}
1783 # MAIN_DEPENDENCY ${input}
1785 EXECUTE_PROCESS(COMMAND ${QT_LRELEASE_EXECUTABLE} ${input} -qm ${output})
1786 ENDIF(ext STREQUAL .qm)
1787 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${f} DESTINATION ${DEST})
1789 ENDIF(test_SALOMEconfig.h.in)
1791 newlines.append(r'''
1792 GET_FILENAME_COMPONENT(ext ${f} EXT)
1793 IF(ext STREQUAL .py)
1794 INSTALL(CODE "SET(PYTHON_FILE ${f})")
1795 INSTALL(CODE "SET(CMAKE_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX})")
1796 INSTALL(CODE "SET(DEST ${DEST})")
1797 INSTALL(CODE "SET(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})")
1799 if self.module == "kernel":
1801 IF(f STREQUAL SALOME_ContainerPy.py)
1802 ELSE(f STREQUAL SALOME_ContainerPy.py)
1803 IF(f STREQUAL am2cmake.py)
1804 ELSE(f STREQUAL am2cmake.py)
1805 INSTALL(SCRIPT ${CMAKE_SOURCE_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1806 ENDIF(f STREQUAL am2cmake.py)
1807 ENDIF(f STREQUAL SALOME_ContainerPy.py)
1811 STRING(REPLACE "\\\\" "/" KERNEL_ROOT_DIR ${KERNEL_ROOT_DIR})
1812 INSTALL(SCRIPT ${KERNEL_ROOT_DIR}/salome_adm/cmake_files/install_and_compile_python_file.cmake)
1815 newlines.append(r'''
1816 ENDIF(ext STREQUAL .py)
1818 newlines.append(r"ENDFOREACH(f ${%s})"%(key))
1821 def writeListsFile(self):
1822 f = open(self.listsFile, "w")
1823 f.write(self.content)
1829 def convertAmFile(the_root, root, dirs, files, f, module):
1830 cmake = CMakeFile(the_root, root, dirs, files, f, module)
1831 cmake.writeListsFile()
1834 def usage(exit_status):
1835 from sys import exit
1836 from sys import argv
1837 print "Usage: %s --module"%(argv[0])
1841 if __name__ == "__main__":
1843 from sys import argv
1849 if module.find('--') != 0:
1853 if len(module) == 0:
1857 from os import getcwd
1861 for root, dirs, files in walk(the_root):
1863 # E.A. : Remove 'CVS' in dirs
1864 # E.A. : It allows to not recurse in CVS dirs
1865 # E.A. : See os module python documentation
1872 if "Makefile.am.cmake" in files:
1873 if "Makefile.am" in files:
1874 files.remove("Makefile.am")
1878 from sys import stdout
1880 if f in ["Makefile.am", "Makefile.am.cmake"]:
1881 stdout.write("Scanning %s %s ..."%(root, f))
1883 convertAmFile(the_root, root, dirs, files, f, module)
1884 stdout.write(" done.\n")