| # Copyright 2019,2020 NXP |
| # |
| # SPDX-License-Identifier: Apache-2.0 |
| # |
| |
| """ |
| Utility to generate version information files. |
| |
| This file reads, version_info.txt from input directory and generates |
| files invarious formats. |
| |
| Input: |
| Param 1: Directory where version_info.txt is kept |
| Param 2: Output file[s] with extension. |
| |
| For generating with different date set environment |
| varaible VERSION_INFO_DATE. |
| e.g. SET VERSION_INFO_DATE=2019.02.01 |
| |
| |
| version_info.txt needs these inputs: |
| |
| # Product |
| prod_name = "HostLib" |
| prod_desc = "Host Libary" |
| |
| # Programming language specific customizations |
| lang_c_prefix = prod_name.upper() |
| lang_namespace = "nxp::HostLib" |
| |
| # Version |
| v_major = "01" |
| v_minor = "01" |
| v_dev = "01" |
| v_meta = "" # Meta string identifier |
| # Maturity of library. Alpha, Beta, Production |
| maturity = "A" |
| """ |
| |
| import logging |
| import os |
| import sys |
| import time |
| from string import Template |
| |
| log = logging.getLogger("version_update") |
| |
| logging.basicConfig(level=logging.DEBUG) |
| |
| # Version of this python script. |
| __VUP_VERSION__ = '2019.01.17_00' |
| |
| # Version Log of this file: |
| # |
| # |
| # 2019.01.17_00 : PGh : Added _VER_MAJOR_MINOR and _VER_MAJOR_MINOR_DEV |
| # : |
| # 2019.01.12_00 : PGh : Re-Write based on old version_info.py |
| # |
| |
| COPYRIGHTS = """Copyright 2019,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. |
| """ |
| |
| |
| class KVINFO: # pylint: disable=too-few-public-methods |
| """ |
| Version info variable structure |
| """ |
| PROD_NAME = "prod_name" |
| PROD_DESC = "prod_desc" |
| # |
| # Programming language specific customizations |
| LANG_C_PREFIX = "lang_c_prefix" |
| LANG_NAMESPACE = "lang_namespace" |
| # |
| # Version |
| V_MAJOR = "v_major" |
| V_MINOR = "v_minor" |
| V_DEV = "v_dev" |
| V_META = "v_meta" |
| # Maturity of library. Alpha, Beta, Production |
| MATURITY = "maturity" |
| |
| |
| DEF_NAME = { |
| KVINFO.V_MAJOR: "VER_MAJOR", |
| KVINFO.V_MINOR: "VER_MINOR", |
| KVINFO.V_DEV: "VER_DEV", |
| } |
| |
| |
| class VersionInformation: |
| """ |
| Version information |
| """ |
| def __init__(self, vinfo, raw_contents): |
| self.vinfo = vinfo |
| self.raw_contents = raw_contents |
| self.values = None |
| |
| def parse(self): |
| self.values = {} |
| self._parse_values() |
| self._parse_date_time_meta() |
| print(" v%s" % self.values['ver_date_string']) |
| |
| def generate_files(self, file_names): |
| """ |
| Generate files |
| :param file_names: list of files |
| :return: None |
| """ |
| for file_name in file_names: |
| generator_fn = None |
| if file_name.endswith(".h"): |
| generator_fn = self.generate_h_output |
| elif file_name.endswith(".cs"): |
| generator_fn = self.generate_cs_output |
| elif file_name.endswith(".doxyfile"): |
| generator_fn = self.generate_doxy_output |
| elif file_name.endswith(".org"): |
| generator_fn = self.generate_org_output |
| elif file_name.endswith(".sh"): |
| generator_fn = self.generate_sh_output |
| elif file_name.endswith(".nsh"): |
| generator_fn = self.generate_nsh_output |
| elif file_name.endswith(".py"): |
| generator_fn = self.generate_py_output |
| elif file_name.endswith(".rst.txt"): |
| generator_fn = self.generate_rst_output |
| else: |
| raise Exception("Unsupported extension '%s'" % (file_name,)) |
| |
| if generator_fn: |
| with open(file_name, "w") as f: |
| generator_fn(f) |
| |
| def _parse_values(self): |
| """ |
| Parse version info values |
| :return: None |
| """ |
| self.values["i_major"] = int(self.vinfo[KVINFO.V_MAJOR]) |
| self.values["i_minor"] = int(self.vinfo[KVINFO.V_MINOR]) |
| self.values["i_dev"] = int(self.vinfo[KVINFO.V_DEV]) |
| self.values["v_major"] = self.vinfo[KVINFO.V_MAJOR] |
| self.values["v_minor"] = self.vinfo[KVINFO.V_MINOR] |
| self.values["v_dev"] = self.vinfo[KVINFO.V_DEV] |
| self.values["maturity"] = self.vinfo[KVINFO.MATURITY] |
| self.values["lang_c_prefix"] = self.vinfo[KVINFO.LANG_C_PREFIX] |
| self.values["prod_name"] = self.vinfo[KVINFO.PROD_NAME] |
| self.values["cs_namespace"] = self.vinfo[KVINFO.LANG_C_PREFIX] |
| self.values['i_major_minor'] = 0 \ |
| + (int(self.vinfo[KVINFO.V_MAJOR]) * 10000) \ |
| + (int(self.vinfo[KVINFO.V_MINOR])) |
| self.values['i_major_minor_dev'] = 0 \ |
| + (int(self.vinfo[KVINFO.V_MAJOR]) * 10000 * 10000) \ |
| + (int(self.vinfo[KVINFO.V_MINOR]) * 10000) \ |
| + (int(self.vinfo[KVINFO.V_DEV])) |
| |
| def _parse_date_time_meta(self): |
| """ |
| Parse time stamp |
| :return: None |
| """ |
| # Timestamp |
| local_time = time.localtime() |
| datetime_str = os.getenv("VERSION_INFO_DATE") |
| |
| if datetime_str: |
| log.warning("Over-riding datetime as '%s' because " |
| "environment varaible 'VERSION_INFO_DATE' is set", (datetime_str,)) |
| elif self.vinfo[KVINFO.MATURITY] == 'B': |
| datetime_str = time.strftime("%Y%m%d", local_time) |
| elif self.vinfo[KVINFO.MATURITY] == 'A': |
| datetime_str = time.strftime("%Y%m%d", local_time) + "_" + \ |
| time.strftime("%H%M", local_time) |
| elif self.vinfo[KVINFO.MATURITY] == 'P': |
| datetime_str = '' |
| else: |
| raise Exception("Invalid maturity='%s'. Expect either 'A', 'B' or 'P'" |
| % (self.vinfo[KVINFO.MATURITY],)) |
| |
| if len(datetime_str) > 0: |
| uc_datetime_str = '_' + datetime_str |
| else: |
| uc_datetime_str = '' |
| |
| # ID String |
| if len(self.vinfo[KVINFO.V_META]) > 0: |
| uc_v_meta = "_" + self.vinfo[KVINFO.V_META] |
| else: |
| uc_v_meta = "" |
| |
| self.values["ver_date_string"] = \ |
| "%02d.%02d.%02d%s%s" % ( |
| self.values["i_major"], |
| self.values["i_minor"], |
| self.values["i_dev"], |
| uc_datetime_str, uc_v_meta) |
| self.values["ver_date_string_u"] = \ |
| "%02d_%02d_%02d%s%s" % ( |
| self.values["i_major"], |
| self.values["i_minor"], |
| self.values["i_dev"], uc_datetime_str, uc_v_meta) |
| |
| @classmethod |
| def put_comment_c(cls, f_object, raw_contents): |
| f_object.write("/*") |
| if isinstance(raw_contents, list): |
| f_object.write(" %s\n" % (raw_contents[0].rstrip(),)) |
| for l in raw_contents[1:]: |
| f_object.write(" * %s\n" % (l.rstrip(),)) |
| elif isinstance(raw_contents, str): |
| f_object.write(" %s\n" % (raw_contents.split("\n")[0].rstrip(),)) |
| for l in raw_contents.split("\n")[1:]: |
| f_object.write(" * %s\n" % (l.rstrip(),)) |
| f_object.write(" */\n\n") |
| |
| # def dumpraw_contents_c(self, fObject): |
| # self.put_comment_c() |
| # fObject.write("\n/* %s" % ("______GENERATED_FROM____version_info.txt",)) |
| # for l in self.raw_contents: |
| # fObject.write("\n * %s" % (l.rstrip(),)) |
| # fObject.write("\n */\n") |
| |
| def lang_c_get_header_guard(self): |
| header_guard_def = self.vinfo[KVINFO.LANG_C_PREFIX] + "_VERSION_INFO_H_INCLUDED" |
| return header_guard_def |
| |
| def generate_h_output(self, output_f): |
| self.put_comment_c(output_f, COPYRIGHTS) |
| header_guard_def = self.lang_c_get_header_guard() |
| output_f.write("#ifndef " + header_guard_def + "\n") |
| output_f.write("#define " + header_guard_def + "\n\n") |
| |
| output_f.write(TEMPLATE_C.substitute(self.values)) |
| # self.putValues_c(o, c_defines) |
| |
| self.put_comment_c(output_f, self.raw_contents) |
| output_f.write("#endif /* " + header_guard_def + " */\n") |
| |
| def generate_doxy_output(self, output_f): |
| output_f.write(TEMPLATE_DOXYGEN.substitute(self.values)) |
| |
| def generate_sh_output(self, output_f): |
| output_f.write(TEMPLATE_SH.substitute(self.values)) |
| |
| def generate_org_output(self, output_f): |
| output_f.write(TEMPLATE_ORG.substitute(self.values)) |
| |
| def generate_nsh_output(self, output_f): |
| output_f.write(TEMPLATE_NSH.substitute(self.values)) |
| |
| def generate_cs_output(self, output_f): |
| self.put_comment_c(output_f, COPYRIGHTS) |
| |
| output_f.write(TEMPLATE_CS.substitute(self.values)) |
| # self.putValues_c(output_f, c_defines) |
| |
| self.put_comment_c(output_f, self.raw_contents) |
| |
| def generate_py_output(self, output_f): |
| output_f.write(TEMPLATE_PY.substitute(self.values)) |
| |
| def generate_rst_output(self, output_f): |
| output_f.write(TEMPLATE_RST.substitute(self.values)) |
| |
| |
| # def generate_cs_file_string(cs_namespace, product_name, sw_vstr, v_major, |
| # v_minor, v_dev, maturity, rd_lib_stream): |
| # s = [] |
| # |
| # return "\n".join(s) |
| |
| |
| TEMPLATE_C = Template(""" |
| /* clang-format off */ |
| #define ${lang_c_prefix}_PROD_NAME "${prod_name}" |
| #define ${lang_c_prefix}_VER_STRING_NUM "v${ver_date_string}" |
| #define ${lang_c_prefix}_PROD_NAME_VER_FULL "${prod_name}_v${ver_date_string}" |
| #define ${lang_c_prefix}_VER_MAJOR (${i_major}u) |
| #define ${lang_c_prefix}_VER_MINOR (${i_minor}u) |
| #define ${lang_c_prefix}_VER_DEV (${i_dev}u) |
| |
| /* v${v_major}.${v_minor} = ${i_major_minor}u */ |
| #define ${lang_c_prefix}_VER_MAJOR_MINOR ( 0 \\ |
| | (${lang_c_prefix}_VER_MAJOR * 10000u) \\ |
| | (${lang_c_prefix}_VER_MINOR)) |
| |
| /* v${v_major}.${v_minor}.${v_dev} = ${i_major_minor_dev}ULL */ |
| #define ${lang_c_prefix}_VER_MAJOR_MINOR_DEV ( 0 \\ |
| | (${lang_c_prefix}_VER_MAJOR * 10000*10000u) \\ |
| | (${lang_c_prefix}_VER_MINOR * 10000u) \\ |
| | (${lang_c_prefix}_VER_DEV)) |
| |
| /* clang-format on */ |
| |
| |
| """) |
| |
| TEMPLATE_DOXYGEN = Template(""" |
| PROJECT_NUMBER = "v${v_major}.${v_minor}.${v_dev}" |
| """) |
| |
| TEMPLATE_SH = Template(""" |
| ${prod_name}_Ver="v${v_major}.${v_minor}.${v_dev}" |
| ${prod_name}_Ver_Full="v${ver_date_string}" |
| """) |
| |
| TEMPLATE_ORG = Template(""" |
| #+MACRO: ${prod_name}_Ver v${v_major}.${v_minor}.${v_dev} |
| """) |
| |
| TEMPLATE_NSH = Template(""" |
| !define ${lang_c_prefix}_PRODUCT_NAME "${prod_name}" |
| !define ${lang_c_prefix}_VER_STR "v${v_major}.${v_minor}.${v_dev}.00" |
| !define ${lang_c_prefix}_VER_STR_FULL "v${ver_date_string}" |
| !define ${lang_c_prefix}_MAJOR "${v_major}" |
| !define ${lang_c_prefix}_MINOR "${v_minor}" |
| !define ${lang_c_prefix}_DEV "${v_dev}" |
| """) |
| |
| TEMPLATE_CS = Template(""" |
| namespace ${cs_namespace} { |
| public class ${cs_namespace}_Ver { |
| /// <summary> |
| /// Name of the Product |
| /// </summary> |
| public const string ProductName = "${prod_name}"; |
| |
| /// <summary> |
| /// Version String/Description of the Binary |
| /// </summary> |
| public const string ProductNameWithVersion = "${prod_name}_v${ver_date_string}"; |
| |
| /// <summary> |
| /// Version of the binary (with patch as star) |
| /// </summary> |
| public const string AssemblyVersion = "${i_major}.${i_minor}.${i_dev}.*"; |
| |
| /// <summary> |
| /// Assembly file version |
| /// </summary> |
| public const string AssemblyFileVersion = "${i_major}.${i_minor}.${i_dev}.0"; |
| } |
| } |
| """) |
| |
| TEMPLATE_RST = Template(""" |
| .. |${lang_c_prefix}_PRODUCT_NAME| replace:: :samp:`${prod_name}` |
| .. |${lang_c_prefix}_VER_STR| replace:: :samp:`v${v_major}.${v_minor}.${v_dev}` |
| .. |${lang_c_prefix}_VER_STR_FULL| replace:: :samp:`v${ver_date_string}` |
| .. |${lang_c_prefix}_MAJOR| replace:: :samp:`${v_major}` |
| .. |${lang_c_prefix}_MINOR| replace:: :samp:`${v_minor}` |
| .. |${lang_c_prefix}_DEV| replace:: :samp:`${v_dev}` |
| """) |
| |
| TEMPLATE_PY = Template(""" |
| ${lang_c_prefix}_PRODUCT_NAME = "${prod_name}" |
| ${lang_c_prefix}_VER_STR = "v${v_major}.${v_minor}.${v_dev}" |
| ${lang_c_prefix}_VER_STR_FULL = "v${ver_date_string}" |
| ${lang_c_prefix}_MAJOR = "${v_major}" |
| ${lang_c_prefix}_MINOR = "${v_minor}" |
| ${lang_c_prefix}_DEV = "${v_dev}" |
| """) |
| |
| |
| def usage(message): |
| print("ERROR!" + message) |
| print( |
| """ |
| Input: |
| 1. Directory where version_info.txt is kept |
| 2. Output files list with supported extensions |
| |
| Following extensions are supported: |
| .h, .cs, .doxyfile, .nsh, .org, .py, .rst.txt, .sh, |
| |
| To override date, set VERSION_INFO_DATE. e.g. |
| SET VERSION_INFO_DATE=DATE |
| |
| """) |
| |
| |
| def get_v_info(): |
| vinfo = {} |
| raw_contents = [] |
| generator = os.path.relpath(sys.argv[0]) + " (v" + __VUP_VERSION__ + ")" |
| try: |
| |
| version_info_file = os.path.relpath(sys.argv[1]) |
| except IndexError: |
| version_info_file = "." |
| |
| raw_contents.append("Version Information:") |
| raw_contents.append("Generated by:") |
| raw_contents.append(" " + generator) |
| raw_contents.append("") |
| raw_contents.append("Do not edit this file. Update:") |
| raw_contents.append(" " + version_info_file + "/version_info.txt instead.") |
| |
| try: |
| exec(compile(open("version_info.txt", "rb").read(), "version_info.txt", 'exec'), {}, vinfo) # pylint: disable=exec-used |
| with open("version_info.txt", "r") as vf: |
| raw_contents.extend(vf.readlines()) |
| except IOError: |
| usage("Missing version_info.txt in " + os.getcwd()) |
| return None |
| return vinfo, raw_contents |
| |
| |
| def main_gen_required_file(vinfo_dir, input_files): |
| print("> vinfo Running on " + vinfo_dir) |
| the_pwd = os.getcwd() |
| os.chdir(vinfo_dir) |
| (vinfo, raw_contents) = get_v_info() |
| os.chdir(the_pwd) |
| if vinfo: |
| o = VersionInformation(vinfo, raw_contents) |
| o.parse() |
| o.generate_files(input_files) |
| |
| |
| def test(): |
| ROOT = '/Users/ing05193/data/n/cm/scripts/vesion_update/' |
| DEST_F = "/Users/ing05193/data/n/cm/scripts/vesion_update/tst/out_prod_one/prod_one" |
| main_gen_required_file( |
| ROOT + "tst/prod_one", |
| [ |
| DEST_F + ".h", |
| DEST_F + ".sh", |
| DEST_F + ".doxyfile", |
| DEST_F + ".org", |
| DEST_F + ".nsh", |
| DEST_F + ".cs", |
| ]) |
| |
| |
| def main(): |
| # if len(sys.argv) == 1: |
| # test() |
| if len(sys.argv) >= 3: |
| main_gen_required_file(sys.argv[1], sys.argv[2:]) |
| else: |
| usage("Insufficient arguments") |
| |
| |
| if __name__ == '__main__': |
| main() |
