devtools/update_version_map_abi.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: BSD-3-Clause
   3 # Copyright(c) 2019 Intel Corporation
   4
   5 """
   6 A Python program that updates and merges all available stable ABI versions into
   7 one ABI version, while leaving experimental ABI exactly as it is. The intended
   8 ABI version is supplied via command-line parameter. This script is to be called
   9 from the devtools/update-abi.sh utility.
  10 """
  11
  12 import argparse
  13 import sys
  14 import re
  15
  16
  17 def __parse_map_file(f_in):
  18     # match function name, followed by semicolon, followed by EOL or comments,
  19     # optionally with whitespace in between each item
  20     func_line_regex = re.compile(r"\s*"
  21                                  r"(?P<line>"
  22                                  r"(?P<func>[a-zA-Z_0-9]+)"
  23                                  r"\s*"
  24                                  r";"
  25                                  r"\s*"
  26                                  r"(?P<comment>#.+)?"
  27                                  r")"
  28                                  r"\s*"
  29                                  r"$")
  30     # match section name, followed by opening bracked, followed by EOL,
  31     # optionally with whitespace in between each item
  32     section_begin_regex = re.compile(r"\s*"
  33                                      r"(?P<version>[a-zA-Z0-9_\.]+)"
  34                                      r"\s*"
  35                                      r"{"
  36                                      r"\s*"
  37                                      r"$")
  38     # match closing bracket, optionally followed by section name (for when we
  39     # inherit from another ABI version), followed by semicolon, followed by
  40     # EOL, optionally with whitespace in between each item
  41     section_end_regex = re.compile(r"\s*"
  42                                    r"}"
  43                                    r"\s*"
  44                                    r"(?P<parent>[a-zA-Z0-9_\.]+)?"
  45                                    r"\s*"
  46                                    r";"
  47                                    r"\s*"
  48                                    r"$")
  49
  50     # for stable ABI, we don't care about which version introduced which
  51     # function, we just flatten the list. there are dupes in certain files, so
  52     # use a set instead of a list
  53     stable_lines = set()
  54     # copy experimental section as is
  55     experimental_lines = []
  56     # copy internal section as is
  57     internal_lines = []
  58     in_experimental = False
  59     in_internal = False
  60     has_stable = False
  61
  62     # gather all functions
  63     for line in f_in:
  64         # clean up the line
  65         line = line.strip('\n').strip()
  66
  67         # is this an end of section?
  68         match = section_end_regex.match(line)
  69         if match:
  70             # whatever section this was, it's not active any more
  71             in_experimental = False
  72             in_internal = False
  73             continue
  74
  75         # if we're in the middle of experimental section, we need to copy
  76         # the section verbatim, so just add the line
  77         if in_experimental:
  78             experimental_lines += [line]
  79             continue
  80
  81         # if we're in the middle of internal section, we need to copy
  82         # the section verbatim, so just add the line
  83         if in_internal:
  84             internal_lines += [line]
  85             continue
  86
  87         # skip empty lines
  88         if not line:
  89             continue
  90
  91         # is this a beginning of a new section?
  92         match = section_begin_regex.match(line)
  93         if match:
  94             cur_section = match.group("version")
  95             # is it experimental?
  96             in_experimental = cur_section == "EXPERIMENTAL"
  97             # is it internal?
  98             in_internal = cur_section == "INTERNAL"
  99             if not in_experimental and not in_internal:
 100                 has_stable = True
 101             continue
 102
 103         # is this a function?
 104         match = func_line_regex.match(line)
 105         if match:
 106             stable_lines.add(match.group("line"))
 107
 108     return has_stable, stable_lines, experimental_lines, internal_lines
 109
 110
 111 def __generate_stable_abi(f_out, abi_major, lines):
 112     # print ABI version header
 113     print("DPDK_{} {{".format(abi_major), file=f_out)
 114
 115     # print global section if it exists
 116     if lines:
 117         print("\tglobal:", file=f_out)
 118         # blank line
 119         print(file=f_out)
 120
 121         # print all stable lines, alphabetically sorted
 122         for line in sorted(lines):
 123             print("\t{}".format(line), file=f_out)
 124
 125         # another blank line
 126         print(file=f_out)
 127
 128     # print local section
 129     print("\tlocal: *;", file=f_out)
 130
 131     # end stable version
 132     print("};", file=f_out)
 133
 134
 135 def __generate_experimental_abi(f_out, lines):
 136     # start experimental section
 137     print("EXPERIMENTAL {", file=f_out)
 138
 139     # print all experimental lines as they were
 140     for line in lines:
 141         # don't print empty whitespace
 142         if not line:
 143             print("", file=f_out)
 144         else:
 145             print("\t{}".format(line), file=f_out)
 146
 147     # end section
 148     print("};", file=f_out)
 149
 150 def __generate_internal_abi(f_out, lines):
 151     # start internal section
 152     print("INTERNAL {", file=f_out)
 153
 154     # print all internal lines as they were
 155     for line in lines:
 156         # don't print empty whitespace
 157         if not line:
 158             print("", file=f_out)
 159         else:
 160             print("\t{}".format(line), file=f_out)
 161
 162     # end section
 163     print("};", file=f_out)
 164
 165 def __main():
 166     arg_parser = argparse.ArgumentParser(
 167         description='Merge versions in linker version script.')
 168
 169     arg_parser.add_argument("map_file", type=str,
 170                             help='path to linker version script file '
 171                                  '(pattern: version.map)')
 172     arg_parser.add_argument("abi_version", type=str,
 173                             help='target ABI version (pattern: MAJOR.MINOR)')
 174
 175     parsed = arg_parser.parse_args()
 176
 177     if not parsed.map_file.endswith('version.map'):
 178         print("Invalid input file: {}".format(parsed.map_file),
 179               file=sys.stderr)
 180         arg_parser.print_help()
 181         sys.exit(1)
 182
 183     if not re.match(r"\d{1,2}\.\d{1,2}", parsed.abi_version):
 184         print("Invalid ABI version: {}".format(parsed.abi_version),
 185               file=sys.stderr)
 186         arg_parser.print_help()
 187         sys.exit(1)
 188     abi_major = parsed.abi_version.split('.')[0]
 189
 190     with open(parsed.map_file) as f_in:
 191         has_stable, stable_lines, experimental_lines, internal_lines = __parse_map_file(f_in)
 192
 193     with open(parsed.map_file, 'w') as f_out:
 194         need_newline = has_stable and experimental_lines
 195         if has_stable:
 196             __generate_stable_abi(f_out, abi_major, stable_lines)
 197         if need_newline:
 198             # separate sections with a newline
 199             print(file=f_out)
 200         if experimental_lines:
 201             __generate_experimental_abi(f_out, experimental_lines)
 202         if internal_lines:
 203             if has_stable or experimental_lines:
 204               # separate sections with a newline
 205               print(file=f_out)
 206             __generate_internal_abi(f_out, internal_lines)
 207
 208
 209 if __name__ == "__main__":
 210     __main()