# This program source code file is part of KICAD, a free EDA CAD application. # # Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck # Copyright (C) 2010-2020 Kicad Developers, see AUTHORS.txt for contributors. # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, you may find one here: # http://www.gnu.org/licenses/old-licenses/gpl-2.0.html # or you may search the http://www.gnu.org website for the version 2 license, # or you may write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA # # Function make_lexer # is a standard way to invoke TokenList2DsnLexer.cmake. # Extra arguments are treated as source files which depend on the generated # files. Some detail here on the indirection: # - Parallel builds all depend on the same files, and CMake will generate the same file multiple times in the same location. # This can be problematic if the files are generated at the same time and overwrite each other. # - To fix this, we create a custom target (outputTarget) that the parallel builds depend on. # AND build dependencies. This creates the needed rebuild for appropriate source object changes. function( make_lexer outputTarget inputFile outHeaderFile outCppFile enum ) add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${outHeaderFile} ${CMAKE_CURRENT_BINARY_DIR}/${outCppFile} COMMAND ${CMAKE_COMMAND} -Denum=${enum} -DinputFile=${CMAKE_CURRENT_SOURCE_DIR}/${inputFile} -DoutHeaderFile=${CMAKE_CURRENT_BINARY_DIR}/${outHeaderFile} -DoutCppFile=${CMAKE_CURRENT_BINARY_DIR}/${outCppFile} -P ${CMAKE_MODULE_PATH}/BuildSteps/TokenList2DsnLexer.cmake COMMENT "TokenList2DsnLexer.cmake creating: ${outHeaderFile} and ${outCppFile} from ${inputFile}" DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${inputFile} ${CMAKE_MODULE_PATH}/BuildSteps/TokenList2DsnLexer.cmake ) target_sources( ${outputTarget} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/${outCppFile} ) target_include_directories( ${outputTarget} PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ) endfunction() # Function generate_lemon_grammar # # This is a function to create a custom command to generate a parser grammar using lemon. # # Arguments: # - TGT is the target to add the consuming file to # - GRAMMAR_DIR is the path relative to CMAKE_CURRENT_BINARY_DIR for the directory where the files will be generated into # - CONSUMING_FILE is the file relative to CMAKE_CURRENT_SOURCE_DIR that will include the grammar.c/h file # - GRAMMAR_FILE is the file relative to CMAKE_CURRENT_SOURCE_DIR of the grammar file to use. function( generate_lemon_grammar TGT GRAMMAR_DIR CONSUMING_FILE GRAMMAR_FILE ) # Get the name without extension get_filename_component( GRAMMAR_BASE ${GRAMMAR_FILE} NAME_WE ) file( MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR} ) set( LEMON_EXE $) get_property( LEMON_TEMPLATE TARGET lemon PROPERTY lemon_template ) add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR}/${GRAMMAR_BASE}.c ${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR}/${GRAMMAR_BASE}.h COMMAND ${CMAKE_COMMAND} -DLEMON_EXE=${LEMON_EXE} -DLEMON_TEMPLATE=${LEMON_TEMPLATE} -DGRAMMAR_FILE=${CMAKE_CURRENT_SOURCE_DIR}/${GRAMMAR_FILE} -DGRAMMAR_DIR=${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR} -P ${CMAKE_MODULE_PATH}/BuildSteps/LemonParserGenerator.cmake COMMENT "Running Lemon on ${GRAMMAR_FILE} to generate ${GRAMMAR_DIR}/${GRAMMAR_BASE}.c" DEPENDS lemon ${CMAKE_CURRENT_SOURCE_DIR}/${GRAMMAR_FILE} ${CMAKE_MODULE_PATH}/BuildSteps/LemonParserGenerator.cmake WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR} ) # Mark the consuming file with a direct dependency on the generated grammar so that # it isn't compiled until the grammar is generated set_source_files_properties( ${CMAKE_CURRENT_SOURCE_DIR}/${CONSUMING_FILE} PROPERTIES OBJECT_DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${GRAMMAR_DIR}/${GRAMMAR_BASE}.c ) target_sources( ${TGT} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/${CONSUMING_FILE} ) target_include_directories( ${TGT} PUBLIC ${CMAKE_CURRENT_BINARY_DIR} ) endfunction() # Is a macro instead of function so there's a higher probability that the # scope of CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA is global macro( add_conffiles ) if( ${ARGC} STREQUAL "0" ) # remove the file when user passes no arguments, which he should do exactly once at top file( REMOVE ${CMAKE_CURRENT_BINARY_DIR}/conffiles ) else() foreach( filename ${ARGV} ) file( APPEND ${CMAKE_CURRENT_BINARY_DIR}/conffiles "${filename}\n" ) endforeach() set( CPACK_DEBIAN_PACKAGE_CONTROL_EXTRA ${CMAKE_CURRENT_BINARY_DIR}/conffiles ) endif() endmacro( add_conffiles ) # Function translate_language # # This is a function to add the targets and install step for translating a language # # Arguments: # - LANG is the code for the language (which must be the same as the directory name) # - OUT_FILE is the file (including directory) to save the translations to function( translate_language LANG OUT_FILE) # Make the output directory (if it doesn't already exist) get_filename_component( OUT_DIR ${OUT_FILE} DIRECTORY ) file( MAKE_DIRECTORY ${OUT_DIR} ) add_custom_command( OUTPUT ${OUT_FILE} DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/pofiles/${LANG}.po COMMAND ${GETTEXT_MSGFMT_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/pofiles/${LANG}.po -o ${OUT_FILE} COMMENT "Building translation library for ${LANG}" ) if( UNIX AND KICAD_I18N_UNIX_STRICT_PATH ) install( FILES ${OUT_FILE} DESTINATION ${KICAD_I18N_PATH}/${LANG}/LC_MESSAGES COMPONENT resources ) else() install( FILES ${OUT_FILE} DESTINATION ${KICAD_I18N_PATH}/${LANG} COMPONENT resources ) endif() endfunction() # Function linux_metadata_translation # # This is a macro to handle the translation of the linux metadata files using # the existing .po files. # # Arguments: # - SRC_FILE is the file to use as the translation source # - OUT_FILE is the file (including directory) to save the translations to # - PO_DIR is the directory containing the raw po files macro( linux_metadata_translation SRC_FILE OUT_FILE PO_DIR ) get_filename_component( OUT_DIR ${OUT_FILE} DIRECTORY ) get_filename_component( OUT_FNAME ${OUT_FILE} NAME ) file( MAKE_DIRECTORY ${OUT_DIR} ) # Find all the po files to setup the dependency chain file( STRINGS ${PO_DIR}/LINGUAS LANG_ARRAY REGEX "^[^#].*" ) set( LANG_FILES "" ) foreach( LANG ${LANG_ARRAY} ) # Keep a list of the language files that are created to add to the target list( APPEND LANG_FILES "${PO_DIR}/${LANG}.po" ) endforeach() # Add the command to translate the file if( KICAD_BUILD_I18N ) add_custom_command( OUTPUT ${OUT_FILE} DEPENDS ${SRC_FILE} ${LANG_FILES} ${CMAKE_MODULE_PATH}/BuildSteps/TranslatePlatformMetadata_linux.cmake COMMAND ${CMAKE_COMMAND} -DMSGFMT_EXE="${GETTEXT_MSGFMT_EXECUTABLE}" -DPO_DIR="${PO_DIR}" -DSRC_FILE="${SRC_FILE}" -DDEST_FILE="${OUT_FILE}" -P ${CMAKE_MODULE_PATH}/BuildSteps/TranslatePlatformMetadata_linux.cmake COMMENT "Translating file ${OUT_FNAME}" ) else() add_custom_command( OUTPUT ${OUT_FILE} DEPENDS ${SRC_FILE} COMMAND ${CMAKE_COMMAND} -E copy_if_different "${SRC_FILE}" "${OUT_FILE}" COMMENT "Copying file ${OUT_FNAME}" ) endif() endmacro()