| # Copyright 2019,2020 NXP |
| # |
| # SPDX-License-Identifier: Apache-2.0 |
| # |
| |
| import os |
| |
| import cmake_features |
| from pprint import pprint |
| |
| __VERSION__ = "2020.01.31_00" |
| # |
| # 2020.06.30_00 : Pradnya : SE05X_Auth can be selected from Header file option for KSDK examples |
| # : |
| # 2020.01.31_00 : Purnank : Limit options in customer selection |
| # : : |
| # 2019.09.17_00 : Purnank : Add SSSFTR to cmake_options_installed.cmake.in |
| # : : |
| # 2019.09.13_00 : Marc : Create cmake_options_installed.cmake.in |
| # : : |
| # 2019.08.18_00 : Purnank : Added cmake_features |
| # : : |
| # 2019.07.28_00 : Purnank : Removed 02_02_00 |
| # : : |
| # 2019.07.23_00 : Purnank : LPC55S Trust Zone added |
| # : : |
| # 2019.03.31_00 : Purnank : Handle drop down options. |
| # : : |
| # 2019.03.11_00 : Sujay : For OpenSSL Engine support both OpenSSL and mbedTLS |
| # : : conditionally. |
| # : : |
| # 2019.03.02_00 : Purnank : Add AR 02_01_00 (and later) |
| # : : |
| # 2019.02.02_00 : Purnank : Document cmake_options.cmake as well |
| # : : |
| # 2019.01.17_00 : Purnank : Re-Integrated logic for WithOptionCheck |
| # : : |
| # 2018.12.10_00 : Purnank : With Option check context |
| # : : |
| # 2018.11.06_00 : Purnank : Create Groovy Helper as well |
| # : : |
| # 2018.10.23_00 : Sujay : Added Azure checks |
| # : : |
| # 2018.08.13_00 : Purnank : separate cmake_otions_check.py |
| # : file |
| # |
| |
| IMPL_TYPES = ["sscp", "se05x", "mbedtls", "openssl"] |
| |
| LIST_APPLETS = [ |
| ("None", "Compiling without any Applet Support", True), |
| ("A71CH", "A71CH (ECC)", True), |
| ("A71CL", "A71CL (RSA)", False), |
| ("A71CH_SIM", "Similar to A71CH", False), |
| |
| ("SE05X_A", "SE050 Type A (ECC)", True), |
| ("SE05X_B", "SE050 Type B (RSA)", True), |
| ("SE05X_C", "SE050 (Super set of A + B)", True), |
| ("SE05X_L", "SE050 (Similar to A71CL)", False), |
| # ("SE051_C", "SE051 With Iot and SEMS Lite Applet", True), |
| ("LoopBack", "NXP Internal testing Applet", False), |
| ] |
| |
| LIST_FIPS = [ |
| ("None", "NO FIPS", True), |
| ("SE050", "SE050 IC FIPS", True), |
| ("140_2", "FIPS 140-2", False), |
| ("140_3", "FIPS 140-3", False), |
| ] |
| |
| DEPREATCED_LIST = [ |
| ("WithApplet_SE05X", "SSS_HAVE_APPLET_SE05X_IOT"), |
| ("WithApplet_SE050_A", "SSS_HAVE_APPLET_SE05X_A"), |
| ("WithApplet_SE050_B", "SSS_HAVE_APPLET_SE05X_B"), |
| ("WithApplet_SE050_C", "SSS_HAVE_APPLET_SE05X_C"), |
| ("SSS_HAVE_SE050_A", "SSS_HAVE_APPLET_SE05X_A"), |
| ("SSS_HAVE_SE050_B", "SSS_HAVE_APPLET_SE05X_B"), |
| ("SSS_HAVE_SE050_C", "SSS_HAVE_APPLET_SE05X_C"), |
| ("SSS_HAVE_SE05X", "SSS_HAVE_APPLET_SE05X_IOT"), |
| ("SSS_HAVE_SE", "SSS_HAVE_APPLET"), |
| |
| # ("SSS_HAVE_A71CH", "SSS_HAVE_APPLET_A71CH"), |
| # ("SSS_HAVE_A71CL", "SSS_HAVE_APPLET_A71CL"), |
| # ("SSS_HAVE_A71CH_SIM", "SSS_HAVE_APPLET_A71CH_SIM"), |
| ("SSS_HAVE_LOOPBACK", "SSS_HAVE_APPLET_LOOPBACK"), |
| |
| # ("SSS_HAVE_OPENSSL", "SSS_HAVE_HOSTCRYPTO_OPENSSL"), |
| # ("SSS_HAVE_MBEDTLS", "SSS_HAVE_HOSTCRYPTO_MBEDTLS"), |
| # ("SSS_HAVE_MBEDCRYPTO", "SSS_HAVE_HOSTCRYPTO_MBEDCRYPTO"), |
| # ("SSS_HAVE_ALT_A71CH", "SSS_HAVE_MBEDTLS_ALT_A71CH"), |
| #("SSS_HAVE_ALT_SSS", "SSS_HAVE_MBEDTLS_ALT_SSS"), |
| ("SSS_HAVE_ALT", "SSS_HAVE_MBEDTLS_ALT"), |
| ] |
| |
| for e, _, _ in LIST_APPLETS: |
| DEPREATCED_LIST.append( |
| ( |
| "WithApplet_%s"%e, |
| "SSS_HAVE_APPLET_%s"%e.upper(), |
| )) |
| DEPREATCED_LIST.append( |
| ( |
| "SSS_HAVE_%s"%e, |
| "SSS_HAVE_APPLET_%s"%e.upper(), |
| )) |
| |
| |
| # |
| # THIS is used for CMake GUI |
| # |
| |
| ENABLED_FOR_SE051 = True |
| |
| LIST_SE05X_APPLET_VERSIONS = [ |
| # ("Any", "Any version of SE05X Applet", True), |
| ("03_XX", "SE050", True), |
| # ("04_04", "NXP Internal - 4.4", False), |
| # # ("04_08", "NXP Internal - 4.8", False), |
| # # ("04_12", "NXP Internal - 4.12", False), |
| # ("05_00", "NXP Internal - 5.00", ENABLED_FOR_SE051), |
| # ("05_02", "NXP Internal - 5.02", ENABLED_FOR_SE051), |
| # ("05_04", "NXP Internal - 5.04", ENABLED_FOR_SE051), |
| # ("05_06", "NXP Internal - 5.06", ENABLED_FOR_SE051), |
| # ("05_08", "NXP Internal - 5.08", ENABLED_FOR_SE051), |
| # ("05_10", "NXP Internal - 5.10", ENABLED_FOR_SE051), |
| # ("05_12", "NXP Internal - 5.12", ENABLED_FOR_SE051), |
| ("06_00", "SE051", ENABLED_FOR_SE051), |
| # ("ANY", ("Any version", "", |
| # "When this is selected, compatibility decisions are taken at run time.", |
| # # "And MW tries to be compatible to a wider extent across applet versions.", |
| # # "NOTE: any feature not supported by Applet may still be tried to be exercise, |
| # # "and such operations will fail at applet level",), False), |
| ] |
| |
| # |
| # THIS is used for GTE Checks |
| # Greater than equal to! |
| # |
| LIST_SE05X_APPLET_VERSIONS_ALL = [ |
| "03_XX", |
| # "04_04", |
| # "04_08", |
| # "04_12", |
| # "05_00", |
| # "05_02", |
| # "05_04", |
| # "05_06", |
| # "05_08", |
| # "05_10", |
| # "05_12", |
| "06_00", |
| ] |
| |
| # LIST_OPENSSL = [ |
| # ("1_1_1", "Use latest 1.1.1 version (Only applicable on PC)", True), |
| # ("1_0_2", "Use older 1.0.2 version (Only NXP Internal)", False), |
| # ] |
| |
| LIST_SMCOM = [ |
| ("None", "Not using any Communication layer", True), |
| ("JRCP_V2", "Socket Interface New Implementation", True), |
| ("JRCP_V1", ( |
| "Socket Interface Old Implementation.", |
| "This is the interface used from Host PC when when we run jrcpv1_server", |
| "from the linux PC."), True), |
| ("VCOM", "Virtual COM Port", True), |
| ("SCI2C", "Smart Card I2C for A71CH and A71CH", True), |
| ("T1oI2C", "T=1 over I2C for SE050", True), |
| ("T1oI2C_GP1_0", "GP Spec", False), |
| ("RC663_VCOM", "Via RC663 Over VCOM Interface from Windows PC", False), |
| ("PN7150", "NFC Interface using PN7150", False), |
| ("Thread", "Thread Mode interface", False), |
| ("PCSC", "CCID PC/SC reader interface", True), |
| ] |
| |
| LIST_HOST = [ |
| ("Darwin", "OS X / Macintosh", True), |
| ("PCLinux32", "PC/Laptop Linux with 32bit libraries", True), |
| ("PCLinux64", "PC/Laptop Linux with 64bit libraries", True), |
| ("PCWindows", "PC/Laptop Windows", True), |
| ("Cygwin", "Using Cygwin", True), |
| ("frdmk64f", "Embedded Kinetis Freedom K64F", True), |
| ("evkmimxrt1060", "Embedded Kinetis i.MX RT 1060", True), |
| ("lpcxpresso55s", "Embedded LPCXpresso55s (No demarcation of secure/non-secure world)", True), |
| ("lpcxpresso55s_ns", "Non Secure world of LPCXpresso55s", True), |
| ("lpcxpresso55s_s", "Secure world of LPCXpresso55s", True), |
| ("iMXLinux", "Embedded Linux on i.MX", True), |
| ("Raspbian", "Embedded Linux on RaspBerry PI", True), |
| ("Android", "Android", True), |
| ("Win10IoT", "Windows 10 IoT Core", False), |
| ] |
| |
| # Update cmake_options_check.py ==> LIST_APPLET_SE05X_VERSION as well. |
| |
| # LIST_APPLET_SE05X_VERSION = [ |
| # # "02_01_00", |
| # ("03_XX_XX", "RFP", True), |
| # # ("02_05_XX", "AR6"), |
| # # ("02_04_XX", "AR6"), |
| # # ("02_03_XX", "AR6"), |
| # # ("02_02_00", "Older release"), |
| # ] |
| |
| LIST_RTOS = [ |
| ("Default", "No specific RTOS. Either bare matal on embedded system" + |
| " or native linux or Windows OS", True), |
| ("FreeRTOS", "Free RTOS for embedded systems", True), |
| ] |
| |
| LIST_HOSTCRYPTO = [ |
| ("MBEDTLS", "Use mbedTLS as host crypto", True), |
| ("MBEDCRYPTO", ( |
| "Use mbed-crypto as host crypto", |
| "Required for ARM-PSA / TF-M" |
| ), True), |
| ("OPENSSL", "Use OpenSSL as host crypto", True), |
| ("User", ( |
| "User Implementation of Host Crypto", |
| "e.g. Files at ``sss/src/user/crypto`` have low level AES/CMAC primitives.", |
| "The files at ``sss/src/user`` use those primitives.", |
| "This becomes an example for users with their own AES Implementation", |
| "This then becomes integration without mbedTLS/OpenSSL for SCP03 / AESKey.", |
| "", |
| ".. note:: ECKey abstraction is not implemented/available yet.", |
| ), True), |
| ("None", |
| ("NO Host Crypto", |
| "Note, this is unsecure and only provided for experimentation", |
| "on platforms that do not have an mbedTLS PORT", |
| "Many :ref:`sssftr-control` have to be disabled to have a valid build." |
| |
| ), True), |
| ] |
| |
| for e, _, _ in LIST_HOSTCRYPTO: |
| DEPREATCED_LIST.append( |
| ( |
| "SSS_HAVE_%s"%e.upper(), |
| "SSS_HAVE_HOSTCRYPTO_%s"%e.upper(), |
| )) |
| |
| |
| LIST_MBEDTLS_ALT = [ |
| ("SSS", "Use SSS Layer ALT implementation", True), |
| ("A71CH", "Legacy implementation", True), |
| ("None", ("Not using any mbedTLS_ALT", "", "When this is selected, cloud demos can not work with mbedTLS"), True), |
| ] |
| |
| for e, _, _ in LIST_MBEDTLS_ALT: |
| DEPREATCED_LIST.append( |
| ( |
| "SSS_HAVE_ALT_%s"%e.upper(), |
| "SSS_HAVE_MBEDTLS_ALT_%s"%e.upper(), |
| )) |
| |
| |
| LIST_SCP = [ |
| ("None", "", True), |
| ("SCP03_SSS", "Use SSS Layer for SCP. Used for SE050 family.", True), |
| ("SCP03_HostCrypto", |
| "Use Host Crypto Layer for SCP03. Legacy implementation. " |
| "Used for older demos of A71CH Family.", True), |
| # ("SCP02_HostCrypto", "Use Host Crypto Layer for SCP02. Used only for NXP internal testing.", False), |
| ] |
| |
| LIST_A71CH_AUTH = [ |
| ("None", "Plain communication, not authenticated or encrypted", True), |
| ("SCP03", "SCP03 enabled", True), |
| ] |
| |
| LIST_SE05X_AUTHLIST = [ |
| ("None", "Use the default session (i.e. session less) login", True), |
| ("UserID", "Do User Authentication with UserID", True), |
| ("PlatfSCP03", "Use Platform SCP for connection to SE", True), |
| ("AESKey", ("Do User Authentication with AES Key", "Earlier this was called AppletSCP03"), True), |
| ("ECKey", ("Do User Authentication with EC Key", "Earlier this was called FastSCP"), True), |
| ("UserID_PlatfSCP03", "UserID and PlatfSCP03", True), |
| ("AESKey_PlatfSCP03", "AESKey and PlatfSCP03", True), |
| ("ECKey_PlatfSCP03", "ECKey and PlatfSCP03", True), |
| ] |
| |
| for e, _, _ in LIST_SE05X_AUTHLIST: |
| DEPREATCED_LIST.append( |
| ( |
| "SSS_HAVE_SE05X_Auth_%s"%e, |
| "SSS_HAVE_SE05X_AUTH_%s"%e.upper(), |
| )) |
| |
| |
| LIST_LOG = [ |
| ("Default", "Default Logging", True), |
| ("Verbose", "Very Verbose logging", True), |
| ("Silent", "Totally silent logging", True), |
| |
| # #> .. note:: This is NXP internal Option |
| ("SeggerRTT", "Segger Real Time Transfer (For Test Automation, NXP Internal)", False), |
| ] |
| |
| CMAKE_BUILD_TYPE = [ |
| # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html" |
| ("Debug", "For developer", True), |
| ("Release", "Optimization enabled and debug symbols removed", True), |
| ("RelWithDebInfo", "Optimization enabled but with debug symbols", True), |
| ("", "Empty Allowed", True), |
| # ("MinSizeRel", "For Developer"), |
| ] |
| |
| ALL_VALUES = [ |
| ("Applet", "SE05X_C", |
| ("The Secure Element Applet", "", |
| "You can compile host library for different Applets listed below.", |
| "Please note, some of these Applets may be for NXP Internal use only.", |
| ), LIST_APPLETS), |
| ("SE05X_Ver", "03_XX", |
| ( |
| "SE05X Applet version.", "", "Selection of Applet version 03_XX enables SE050 features.", |
| "Selection of Applet version 06_00 enables SE051 features.", |
| "", |
| ), LIST_SE05X_APPLET_VERSIONS), |
| # ("Applet_SE05X_Ver", "03_XX_XX", |
| # ("Applet version of SE050", "", |
| # "You can compile host library for different versions/variants of the SE05X Applets.", |
| # "Please note, some of these Versions of the Applets may be for NXP Internal use only.", |
| # ), LIST_APPLET_SE05X_VERSION), |
| ("Host", "PCWindows", |
| ("Host where the software stack is running", "", |
| "e.g. Windows, PC Linux, Embedded Linux, Kinetis like embedded platform", |
| ), LIST_HOST), |
| ("SMCOM", "VCOM", |
| ("Communication Interface", "", |
| "How the host library communicates to the Secure Element.", |
| "This may be directly over an I2C interface on embedded platform.", |
| "Or sometimes over Remote protocol like JRCP_V1 / JRCP_V2 / VCOM from PC." |
| ), LIST_SMCOM), |
| ("HostCrypto", "MBEDTLS", |
| ("Counterpart Crypto on Host", "", |
| "What is being used as a cryptographic library on the host.", |
| "As of now only OpenSSL / mbedTLS is supported", |
| ), LIST_HOSTCRYPTO), |
| ("RTOS", "Default", |
| ("Choice of Operating system", "", |
| "Default would mean nothing special.", |
| "i.e. Without any RTOS on embedded system, or default APIs on PC/Linux", |
| ), LIST_RTOS), |
| ("mbedTLS_ALT", "None", |
| ("ALT Engine implementation for mbedTLS", "", |
| "When set to None, mbedTLS would not use ALT " |
| "Implementation to connect to / use Secure Element.", |
| "This needs to be set to SSS for Cloud Demos over SSS APIs", |
| ), LIST_MBEDTLS_ALT), |
| ("SCP", "None", |
| ("Secure Channel Protocol", "", |
| "In case we enable secure channel to Secure Element, which interface to be used.", |
| ), LIST_SCP), |
| ("FIPS", "None", |
| ("Enable or disable FIPS ", "", |
| "This selection mostly impacts tests, and generally not the actual Middleware"), |
| LIST_FIPS), |
| ("SE05X_Auth", "None", |
| ("SE050 Authentication", "", |
| "This settings is used by examples to connect using various options", |
| "to authenticate with the Applet.", |
| "The SE05X_Auth options can be changed for KSDK Demos and Examples.", |
| "To change SE05X_Auth option follow below steps.", |
| "Set flag ``SSS_HAVE_SCP_SCP03_SSS`` to 1 and Reset flag ``SSS_HAVE_SCP_NONE`` to 0.", |
| "To change SE05X_Auth option other than ``None`` and ``PlatfSCP03``,", |
| "execute se05x_Delete_and_test_provision.exe in order to provision the Authentication Key.", |
| "To change SE05X_Auth option to ``ECKey`` or ``ECKey_PlatfSCP03``,", |
| "Set additional flag ``SSS_HAVE_HOSTCRYPTO_ANY`` to 1." |
| ), LIST_SE05X_AUTHLIST), |
| ("A71CH_AUTH", "None", |
| ("A71CH Authentication", "", |
| "This settings is used by SSS-API based examples to connect using either plain " |
| "or authenticated to the A71CH." |
| ), LIST_A71CH_AUTH), |
| ("Log", "Default", |
| ("Logging", |
| ), LIST_LOG), |
| ("CMAKE_BUILD_TYPE", "Debug", |
| ("See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html", "", |
| "For embedded builds, this choices sets optimization levels.", |
| "For MSVC builds, build type is selected from IDE As well", |
| ), CMAKE_BUILD_TYPE), |
| # ("OpenSSL", "1_1_1", |
| # ("For PC, which OpenSSL to pick up", "", |
| # "On Linux based builds, this option has no impact, because the build system", |
| # "picks up the default available/installed OpenSSL from the system directly.", |
| # ), LIST_OPENSSL), |
| ] |
| |
| CMAKE_OPTIONS_CHECK_GROOVY_FOOTER = r''' |
| // Manual |
| doWithApplet_SE050_EAR_CH_ON=doWithApplet_A71CH_SIM_ON |
| |
| |
| def VCOM_Delete_and_provision(binary_path="") { |
| try |
| { |
| timeout(15) { |
| if (binary_path == ""){ |
| binary_path="%WORKSPACE%\\src\\binaries\\tst" |
| } |
| bat """ |
| cd ${WORKSPACE}\\Automation_tools\\SE050_Automation |
| SET PATH=C:\\Python37;%PATH% |
| start Jlink_term_click.exe |
| python program_and_terminate.py utils\\a7x_vcom-T1oI2C-frdmk64f-SE050x.bin |
| ping 127.0.0.1 |
| ping 127.0.0.1 |
| ping 127.0.0.1 |
| python get_comport_frdmk64f.py |
| IF NOT EXIST setenv_comport.bat echo "Missing setenv_comport.bat" |
| IF NOT EXIST setenv_comport.bat exit 1 |
| call setenv_comport.bat |
| call "${binary_path}\\VCOM-None-se05x_Delete_and_test_provision.exe" %VCOM_PORT% |
| call "${binary_path}\\VCOM-None-se05x_FactoryReset.exe" %VCOM_PORT% |
| call "${binary_path}\\VCOM-None-se05x_Delete_and_test_provision.exe" %VCOM_PORT% |
| """ |
| } |
| } |
| catch(err) { |
| echo "Delete all and Test Provisioning Failed Continue to run the test" |
| } |
| } |
| |
| |
| def VCOM_Get_AC_Log(binary_path="", ac_log_path, testname) { |
| try |
| { |
| timeout(15) { |
| if (ac_log_path == ""){ |
| echo "AC Log path not SET" |
| } else { |
| if (binary_path == ""){ |
| binary_path="%WORKSPACE%/src/binaries/tst/nxp" |
| } |
| bat """ |
| cd ${WORKSPACE}\\Automation_tools\\SE050_Automation |
| SET PATH=C:\\Python37;%PATH% |
| start Jlink_term_click.exe |
| python program_and_terminate.py utils\\a7x_vcom-T1oI2C-frdmk64f-SE050x.bin |
| ping 127.0.0.1 |
| ping 127.0.0.1 |
| ping 127.0.0.1 |
| python get_comport_frdmk64f.py |
| IF NOT EXIST setenv_comport.bat echo "Missing setenv_comport.bat" |
| IF NOT EXIST setenv_comport.bat exit 1 |
| call setenv_comport.bat |
| call "${binary_path}\\VCOM-se05x_Log_AC.exe" -file ${ac_log_path} -testname ${testname} %VCOM_PORT% |
| """ |
| } |
| } |
| } |
| catch(err) { |
| echo "Delete all and Test Provisioning Failed Continue to run the test" |
| } |
| } |
| |
| |
| ''' |
| |
| COPYRIGHT = ["", |
| " Copyright 2018-2020 NXP", |
| "", |
| " This software is owned or controlled by NXP and may only be used", |
| " strictly in accordance with the applicable license terms. By expressly", |
| " accepting such terms or by downloading, installing, activating and/or", |
| " otherwise using the software, you are agreeing that you have read, and", |
| " that you agree to comply with and are bound by, such license terms. If", |
| " you do not agree to be bound by the applicable license terms, then you", |
| " may not retain, install, activate or otherwise use the software.", |
| "", |
| " #############################################################", |
| " This file is generated using a script", |
| " #############################################################", |
| "", |
| # " Update `cmake_options_check.py` and `cmake_options_check.py`", |
| # " instead of modifying this file.", |
| # "", |
| ] |
| |
| class CMakeOptionsValue: # pylint: disable=too-many-instance-attributes |
| """ |
| Generates skeleton files for various APIs in SSS Layer |
| """ |
| |
| # cm_val : Cmake File object |
| # cm_gv : Groovy File object |
| def __init__(self, cm_val, cm_gv, cm_rst_v, cm_sh, cm_makin, cm_cmiin): # pylint: disable=too-many-arguments |
| self.cm_gv = cm_gv |
| self.cm_val = cm_val |
| self.cm_rst_v = cm_rst_v |
| self.cm_sh = cm_sh |
| self.cm_makin = cm_makin |
| self.cm_cmiin = cm_cmiin |
| self.prepend = "" |
| self.condition = "" |
| |
| self.cm_f = cmake_features.CMakeFeatures( |
| self.cm_val, self.cm_gv, self.cm_rst_v, self.cm_sh, self.cm_makin, self.cm_cmiin) |
| # Header fle generated by cmake_features() |
| self.cm_hin = None |
| |
| def run(self): |
| self.cm_f.open() |
| self.cm_hin = self.cm_f.get_h_file() |
| for f in (self.cm_sh, self.cm_val, self.cm_makin, self.cm_cmiin): |
| f.write(("\n#".join(COPYRIGHT)).strip()) |
| f.write("\n") |
| for option, default_value, description, option_list in ALL_VALUES: |
| self.write_option(option, default_value, description, option_list) |
| for option, default_value, description, option_list in ALL_VALUES: |
| self.write_with_cmake_names(option, description, option_list) |
| for option, default_value, description, option_list in ALL_VALUES: |
| self.write_option_description(option, description, option_list) |
| |
| self.cm_f.write_features() |
| |
| |
| for sh in (self.cm_makin, self.cm_cmiin, self.cm_rst_v, self.cm_hin): |
| sh.write("\n\n") |
| self.cm_cmiin.write("# ") |
| import cmake_options_check |
| |
| cmake_options_check.generate_cmake_options_check_file(self.cm_hin, self.cm_cmiin) |
| |
| self.cm_hin.write("/** ") |
| |
| for sh in (self.cm_makin, self.cm_cmiin, ): |
| sh.write("\n# ") |
| for f in (self.cm_makin, self.cm_cmiin, self.cm_hin): |
| f.write("Deprecated items. Used here for backwards compatibility.") |
| self.cm_hin.write(" */") |
| self.cm_rst_v.write(""" |
| .. _deprecated-defines: |
| |
| Deprecated Defines |
| ======================== |
| |
| Keept and for time being for backwards compatibility. They will be removed in |
| some future release. |
| |
| """) |
| for sh in (self.cm_makin, self.cm_cmiin, self.cm_rst_v, self.cm_hin): |
| sh.write("\n\n") |
| for old_name, new_name in DEPREATCED_LIST: |
| self.cm_rst_v.write("- ``%s`` is renamed to ``%s``\n"%(old_name, new_name)) |
| self.cm_makin.write("%s := ${%s}\n"%(old_name, new_name)) |
| self.cm_cmiin.write("SET(%s %s)\n"%(old_name, new_name)) |
| self.cm_hin.write("#define %s (%s)\n"%(old_name, new_name)) |
| |
| self.cm_f.close() |
| |
| def write_option(self, option, default_value, description, option_list): |
| option_values_internal = [] |
| option_values_public = [] |
| |
| for value, _, public in option_list: |
| option_values_internal.append(value) |
| self.cm_gv.write("doWith%s_%s_ON=\" -D%s=%s\"\n" % ( |
| option, value, option, value)) |
| if public: |
| option_values_public.append(value) |
| if default_value not in option_values_internal: |
| raise Exception("option_list=%s does not have default_value=%s" % ( |
| str(option_list), default_value)) |
| cm_description = description[0] |
| self.cm_val.write(SET_AND_SET_PROPERTY % ( |
| option, default_value, cm_description, option, ";".join(option_values_internal), |
| option, ";".join(option_values_public))) |
| |
| @classmethod |
| def get_sss_have_opt_val(cls, option, option_value): |
| uoption = option.upper() |
| uoption_value = option_value.upper() |
| return "SSS_HAVE_%s_%s"%(uoption, uoption_value) |
| |
| def write_with_cmake_names(self, option, description, option_list): |
| option_values = [] |
| self.cm_makin.write("\n# ") |
| self.cm_makin.write("\n# ".join(description,)) |
| self.cm_makin.write("\n") |
| for value, _, public in option_list: |
| option_values.append(value) |
| for option_value in option_values: |
| uoption_value = "" |
| uoption = option.upper() |
| if option_value: |
| uoption_value = option_value.upper() |
| sss_have_opt_val = self.get_sss_have_opt_val(option, option_value) |
| self.cm_makin.write("%s := ${%s}\n" % (sss_have_opt_val, sss_have_opt_val)) |
| self.cm_val.write("IF(\"${%s}\" STREQUAL \"%s\")\n" % (option, option_value)) |
| self.cm_val.write(" SET(With%s_%s ON)\n" % (option, option_value)) |
| self.cm_val.write(" SET(%s \"1\")\n" % (sss_have_opt_val, )) |
| self.cm_val.write("ELSE()\n") |
| self.cm_val.write(" SET(With%s_%s OFF)\n" % (option, option_value)) |
| self.cm_val.write(" SET(%s \"0\")\n" % (sss_have_opt_val, )) |
| self.cm_val.write("ENDIF()\n\n") |
| for option_value in option_values[:1]: |
| self.cm_val.write("IF(\"${%s}\" STREQUAL \"%s\")\n" % (option, option_value)) |
| self.cm_val.write(" # OK\n") |
| for option_value in option_values[1:]: |
| self.cm_val.write("ELSEIF(\"${%s}\" STREQUAL \"%s\")\n" % (option, option_value)) |
| self.cm_val.write(" # OK\n") |
| self.cm_val.write("ELSE()\n") |
| self.cm_val.write(" MESSAGE(SEND_ERROR \"For '%s' '${%s}' is invalid.\")\n" |
| % (option, option)) |
| self.cm_val.write(" MESSAGE(STATUS \"Only supported values are '%s'\")\n" |
| % (", ".join(option_values))) |
| self.cm_val.write("ENDIF()\n\n") |
| |
| def write_option_description(self, option, o_description, option_list): |
| self.cm_rst_v.write("\n") |
| self.cm_rst_v.write(".. _cmake-option-%s:\n\n"%(option,)) |
| self.cm_rst_v.write("%s\n" % (option,)) |
| self.cm_rst_v.write("%s\n" % ("=" * (20 + len(option)),)) |
| if tuple == type(o_description): |
| sh_description = "\n# ".join(o_description) |
| rst_description = "\n ".join(o_description) |
| else: |
| sh_description = o_description |
| rst_description = o_description |
| self.cm_cmiin.write("\n# %s\n" % (sh_description,)) |
| self.cm_sh.write("\n\n### %s : %s\n" % (option, sh_description)) |
| if self.isHFileOption(option): |
| self.cm_hin.write("\n\n/** %s : %s\n */\n" % (option, sh_description.replace("\n#","\n *"))) |
| self.cm_rst_v.write("\n") |
| self.cm_rst_v.write(".. option:: %s\n" % (option,)) |
| self.cm_rst_v.write("\n") |
| self.cm_rst_v.write(" %s\n" % (rst_description,)) |
| self.cm_rst_v.write("\n") |
| for option_value, o_value_description, public in option_list: |
| if public: |
| self.cm_rst_v.write(" ``-D%s=%s``" % (option, option_value,)) |
| if tuple == type(o_value_description): |
| sh_value_description = "\n# ".join(o_value_description) |
| rst_value_description = "\n ".join(o_value_description) |
| if not public: |
| sh_value_description += "\n# NXP Internal\n" |
| self.cm_sh.write("\n#") |
| self.cm_sh.write(sh_value_description) |
| self.cm_sh.write("\n") |
| else: |
| sh_value_description = o_value_description |
| rst_value_description = o_value_description |
| for e in (self.cm_makin, self.cm_cmiin): |
| if sh_value_description: |
| e.write("\n# ") |
| e.write(sh_value_description) |
| e.write("\n") |
| |
| if public: |
| if rst_value_description: |
| self.cm_rst_v.write(": %s" % (rst_value_description,)) |
| self.cm_rst_v.write("\n\n") |
| if tuple == type(o_value_description): |
| self.cm_sh.write("do%s_%s_ON=\"-D%s=%s\"\n" % (option, option_value, option, option_value)) |
| else: |
| self.cm_sh.write("do%s_%s_ON=\"-D%s=%s\" #%s\n" % (option, |
| option_value, |
| option, |
| option_value, |
| sh_value_description)) |
| if option_value: |
| sss_have_opt_val = self.get_sss_have_opt_val(option, option_value) |
| if self.isHFileOption(option): |
| self.cm_hin.write("\n/** %s */\n"%sh_value_description.replace("\n#","\n *")) |
| self.cm_hin.write("#cmakedefine01 %s\n" % (sss_have_opt_val, )) |
| self.cm_cmiin.write("SET(%s ${%s})\n" % ( |
| sss_have_opt_val, sss_have_opt_val)) |
| self.cm_makin.write("%s := ${%s}\n" % ( |
| sss_have_opt_val, sss_have_opt_val)) |
| if self.isHFileOption(option): |
| self.cm_hin.write("\n#if (( 0 \\\n") |
| for option_value, _, _ in option_list: |
| sss_have_opt_val = self.get_sss_have_opt_val(option, option_value) |
| self.cm_hin.write(" + %-30s \\\n"%(sss_have_opt_val)) |
| self.cm_hin.write(" ) > 1)\n") |
| self.cm_hin.write("# error \"Enable only one of '%s'\"\n"%(option,)) |
| self.cm_hin.write("#endif\n\n") |
| self.cm_hin.write("\n#if (( 0 \\\n") |
| for option_value, _, _ in option_list: |
| sss_have_opt_val = self.get_sss_have_opt_val(option, option_value) |
| self.cm_hin.write(" + %-30s \\\n"%(sss_have_opt_val)) |
| self.cm_hin.write(" ) == 0)\n") |
| self.cm_hin.write("# error \"Enable at-least one of '%s'\"\n"%(option,)) |
| self.cm_hin.write("#endif\n\n") |
| |
| def _NOT_USED_write_values(self, prefix, impl_types): |
| for impl_type in impl_types: |
| uhave_type = "%s_%s" % (prefix.upper(), impl_type.upper()) |
| have_type = "%s%s" % (prefix, impl_type) |
| value_type = "SSS_HAVE_%s" % (uhave_type,) |
| sss_have_opt_val = "SSS_HAVE_%s_%s"%(uoption, uoption_value) |
| self.cm_val.write("\n") |
| self.cm_val.write("IF(%s)\n" % (have_type,)) |
| self.cm_val.write(" SET(%s \"1\")\n" % (value_type,)) |
| self.cm_val.write("ELSE()\n") |
| self.cm_val.write(" SET(%s \"0\")\n" % (value_type,)) |
| self.cm_val.write("ENDIF()\n") |
| |
| # def xset_when_either_of(self, prefix, impl_types, new_variable): |
| # have_types = [] |
| # for impl_type in impl_types: |
| # have_type = "%s%s" % (prefix, impl_type) |
| # have_types.append(have_type) |
| # if len(have_types) > 4: |
| # self.cm_val.write("%sIF(\n %s\n)\n" % (self.prepend, |
| # "\n OR ".join(have_types))) |
| # else: |
| # self.cm_val.write("%sIF(%s)\n" % (self.prepend, |
| # " OR ".join(have_types))) |
| # self.cm_val.write("%s SET(%s ON)\n" % (self.prepend, new_variable)) |
| # self.cm_val.write("%sELSE()\n" % (self.prepend,)) |
| # self.cm_val.write("%s SET(%s OFF)\n" % (self.prepend, new_variable)) |
| # self.cm_val.write("%sENDIF()\n" % (self.prepend,)) |
| |
| def mark_as_depreceted(self, key_words): |
| for key_word in key_words: |
| self.cm_val.write("\n") |
| self.cm_val.write("IF(%s)\n" % (key_word,)) |
| self.cm_val.write(' MESSAGE(WARNING "Keyword \'%s\' is deprecated.")\n' % (key_word,)) |
| self.cm_val.write("ENDIF()\n") |
| |
| def isHFileOption(self, option): |
| if option in ( |
| "RTOS", |
| "CMAKE_BUILD_TYPE", |
| "Host", |
| "Log", |
| # "SE05X_Auth", |
| "SMCOM", |
| ): |
| return False |
| return True |
| |
| |
| def generate_cmake_options_value_files(): |
| cm_gv = open("jenkins/cmake_options_check.groovy", "w") |
| cm_val = open("cmake_options_values.cmake", "w") |
| cm_rst_v = open("cmake_options_values.rst.txt", "w") |
| cm_sh = open("cmake_options.sh", "w") |
| cm_makin = open("cmake_options.mak.in", "w") |
| cm_cmiin = open("cmake_options_installed.cmake.in", "w") |
| cm_check = CMakeOptionsValue(cm_val, cm_gv, cm_rst_v, cm_sh, cm_makin, cm_cmiin) |
| cm_check.run() |
| CMakeOptionsFileToRST(cm_gv, cm_sh).run() |
| cm_gv.write(CMAKE_OPTIONS_CHECK_GROOVY_FOOTER) |
| cm_gv.write("\nreturn this;\n") |
| |
| for k in (cm_gv, cm_val, cm_rst_v, cm_sh): |
| k.close() |
| |
| |
| class CMakeOptionsFileToRST: |
| """ |
| Write CMake options to RST file. |
| """ |
| def __init__(self, cm_gv, cm_sh): |
| self.to_write = [] |
| self.cm_gv = cm_gv |
| self.cm_sh = cm_sh |
| self.cm_cmake = None |
| self.cm_rst = None |
| |
| def run(self): |
| self.cm_cmake = open("cmake_options.cmake") |
| self.cm_rst = open("cmake_options.rst", "w") |
| self.cmake_to_rst() |
| self.cm_cmake.close() |
| self.cm_rst.close() |
| |
| def cmake_to_rst(self): |
| for l in self.cm_cmake: |
| if l.startswith("##"): |
| pass |
| elif l.startswith("# "): |
| self.cm_rst.write(l[2:]) |
| elif l.strip() == "#": |
| self.cm_rst.write("\n") |
| elif l.startswith("#> "): |
| self.to_write.append(l[3:]) |
| elif l.startswith("#"): |
| self.cm_rst.write(l[1:]) |
| elif l.startswith("OPTION("): |
| self.cmake_option_to_rst(l) |
| elif l.strip() == "": |
| self.cm_rst.write("\n") |
| else: |
| pass |
| |
| def cmake_option_to_rst(self, op_line): |
| assert op_line.startswith("OPTION(") |
| (eoption, description, evalue) = op_line.split('"') |
| option = eoption[7:].strip() |
| if "NXPInternal" == option: # pylint: disable=misplaced-comparison-constant |
| value = "OFF. (ON only within NXP)" |
| elif "ON" in evalue: |
| value = "ON" |
| elif "OFF" in evalue: |
| value = "OFF" |
| else: |
| value = "Unknown" |
| |
| self.cm_rst.write(".. option:: %s\n\n" % (option,)) |
| self.cm_rst.write(" - %s" % (description,)) |
| self.cm_rst.write("\n") |
| self.cm_rst.write(" - Default is %s\n" % (value,)) |
| if self.to_write: |
| self.cm_rst.write("\n") |
| while self.to_write: |
| v = self.to_write.pop().strip() |
| if v.startswith(":") or v.startswith("."): |
| self.cm_rst.write(" %s" % (v,)) |
| else: |
| self.cm_rst.write(" - %s" % (v,)) |
| self.cm_rst.write("\n") |
| self.cm_rst.write("\n") |
| self.cm_rst.write("\n") |
| self.cm_gv.write('do%s_ON="-D%s=ON"\n' % (option, option,)) |
| self.cm_gv.write('do%s_OFF="-D%s=OFF"\n' % (option, option,)) |
| self.cm_sh.write("\n# %s\n"%description) |
| self.cm_sh.write('do%s_ON="-D%s=ON"\n' % (option, option,)) |
| self.cm_sh.write('do%s_OFF="-D%s=OFF"\n' % (option, option,)) |
| |
| |
| SET_AND_SET_PROPERTY = """ |
| SET( |
| %s |
| "%s" |
| CACHE |
| STRING |
| "%s" |
| ) |
| |
| IF(NXPInternal) |
| SET_PROPERTY( |
| CACHE %s |
| PROPERTY |
| STRINGS |
| "%s;" |
| ) |
| ELSE() |
| SET_PROPERTY( |
| CACHE %s |
| PROPERTY |
| STRINGS |
| "%s;" |
| ) |
| ENDIF() |
| """ |
| |
| |
| |
| def main(): |
| script_root_dir = os.path.dirname(os.path.realpath(__file__)) |
| if os.path.abspath(os.curdir) != script_root_dir: |
| os.chdir(script_root_dir) |
| generate_cmake_options_value_files() |
| |
| |
| if __name__ == "__main__": |
| main() |
