2 # SPDX-License-Identifier: BSD-3-Clause
3 # Copyright(c) 2019 Intel Corporation
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.
12 from __future__ import print_function
18 def __parse_map_file(f_in):
19 # match function name, followed by semicolon, followed by EOL, optionally
20 # with whitespace in between each item
21 func_line_regex = re.compile(r"\s*"
22 r"(?P<func>[a-zA-Z_0-9]+)"
27 # match section name, followed by opening bracked, followed by EOL,
28 # optionally with whitespace in between each item
29 section_begin_regex = re.compile(r"\s*"
30 r"(?P<version>[a-zA-Z0-9_\.]+)"
35 # match closing bracket, optionally followed by section name (for when we
36 # inherit from another ABI version), followed by semicolon, followed by
37 # EOL, optionally with whitespace in between each item
38 section_end_regex = re.compile(r"\s*"
41 r"(?P<parent>[a-zA-Z0-9_\.]+)?"
47 # for stable ABI, we don't care about which version introduced which
48 # function, we just flatten the list. there are dupes in certain files, so
49 # use a set instead of a list
51 # copy experimental section as is
52 experimental_lines = []
53 # copy internal section as is
55 in_experimental = False
59 # gather all functions
62 line = line.strip('\n').strip()
64 # is this an end of section?
65 match = section_end_regex.match(line)
67 # whatever section this was, it's not active any more
68 in_experimental = False
72 # if we're in the middle of experimental section, we need to copy
73 # the section verbatim, so just add the line
75 experimental_lines += [line]
78 # if we're in the middle of internal section, we need to copy
79 # the section verbatim, so just add the line
81 internal_lines += [line]
88 # is this a beginning of a new section?
89 match = section_begin_regex.match(line)
91 cur_section = match.group("version")
93 in_experimental = cur_section == "EXPERIMENTAL"
95 in_internal = cur_section == "INTERNAL"
96 if not in_experimental and not in_internal:
100 # is this a function?
101 match = func_line_regex.match(line)
103 stable_lines.add(match.group("func"))
105 return has_stable, stable_lines, experimental_lines, internal_lines
108 def __generate_stable_abi(f_out, abi_version, lines):
109 # print ABI version header
110 print("DPDK_{} {{".format(abi_version), file=f_out)
112 # print global section if it exists
114 print("\tglobal:", file=f_out)
118 # print all stable lines, alphabetically sorted
119 for line in sorted(lines):
120 print("\t{};".format(line), file=f_out)
125 # print local section
126 print("\tlocal: *;", file=f_out)
129 print("};", file=f_out)
132 def __generate_experimental_abi(f_out, lines):
133 # start experimental section
134 print("EXPERIMENTAL {", file=f_out)
136 # print all experimental lines as they were
138 # don't print empty whitespace
140 print("", file=f_out)
142 print("\t{}".format(line), file=f_out)
145 print("};", file=f_out)
147 def __generate_internal_abi(f_out, lines):
148 # start internal section
149 print("INTERNAL {", file=f_out)
151 # print all internal lines as they were
153 # don't print empty whitespace
155 print("", file=f_out)
157 print("\t{}".format(line), file=f_out)
160 print("};", file=f_out)
163 arg_parser = argparse.ArgumentParser(
164 description='Merge versions in linker version script.')
166 arg_parser.add_argument("map_file", type=str,
167 help='path to linker version script file '
168 '(pattern: *version.map)')
169 arg_parser.add_argument("abi_version", type=str,
170 help='target ABI version (pattern: MAJOR.MINOR)')
172 parsed = arg_parser.parse_args()
174 if not parsed.map_file.endswith('version.map'):
175 print("Invalid input file: {}".format(parsed.map_file),
177 arg_parser.print_help()
180 if not re.match(r"\d{1,2}\.\d{1,2}", parsed.abi_version):
181 print("Invalid ABI version: {}".format(parsed.abi_version),
183 arg_parser.print_help()
186 with open(parsed.map_file) as f_in:
187 has_stable, stable_lines, experimental_lines, internal_lines = __parse_map_file(f_in)
189 with open(parsed.map_file, 'w') as f_out:
190 need_newline = has_stable and experimental_lines
192 __generate_stable_abi(f_out, parsed.abi_version, stable_lines)
194 # separate sections with a newline
196 if experimental_lines:
197 __generate_experimental_abi(f_out, experimental_lines)
199 if has_stable or experimental_lines:
200 # separate sections with a newline
202 __generate_internal_abi(f_out, internal_lines)
205 if __name__ == "__main__":