156 lines
6.2 KiB
Python
156 lines
6.2 KiB
Python
#! python
|
|
#
|
|
# This file contains 'Framework Code' and is licensed as such
|
|
# under the terms of your license agreement with Intel or your
|
|
# vendor. This file may not be modified, except as allowed by
|
|
# additional terms of your license agreement.
|
|
#
|
|
## @file
|
|
# gen_dec.py
|
|
#
|
|
# INTEL CONFIDENTIAL
|
|
# Copyright (c) 2017 - 2020, Intel Corporation. All rights reserved.
|
|
# This software and associated documentation (if any) is furnished
|
|
# under a license and may only be used or copied in accordance
|
|
# with the terms of the license. Except as permitted by such
|
|
# license, no part of this software or documentation may be
|
|
# reproduced, stored in a retrieval system, or transmitted in any
|
|
# form or by any means without the express written consent of
|
|
# Intel Corporation.
|
|
#
|
|
|
|
import argparse
|
|
import re
|
|
import sys
|
|
import traceback
|
|
import os
|
|
import subprocess
|
|
|
|
_section_regex = re.compile(r"^[^#]*?\[(.+)\](.*)")
|
|
_comment_strip = re.compile(r"^([^#]*)[#]*.*?")
|
|
_arch = ["IA32", "X64", "IPF", "ARM", "AARCH64", "EBC"]
|
|
try:
|
|
basestring
|
|
except NameError:
|
|
basestring = str
|
|
|
|
def _find_sections(dec_file, section_name, flatten=True):
|
|
sections = []
|
|
for section_entry in dec_file:
|
|
if section_entry[0][0] == section_name or str(section_entry[0][0]).lower() == section_name.lower():
|
|
sections.append(section_entry[1])
|
|
if flatten:
|
|
lines = []
|
|
for section in sections:
|
|
lines.extend(section)
|
|
return lines
|
|
else:
|
|
return sections
|
|
|
|
def read_dec_file(dec_file_name):
|
|
with open(dec_file_name) as f:
|
|
lines = f.readlines()
|
|
dec_file = [ ((0, ""), []) ]
|
|
current_section = dec_file[0][1]
|
|
for line in lines:
|
|
data = _section_regex.match(line)
|
|
if data:
|
|
current_section = []
|
|
dec_file.append(((data.group(1), data.group(2)), current_section))
|
|
else:
|
|
current_section.append(line)
|
|
return dec_file
|
|
|
|
def get_formations(dec_file):
|
|
forms = _find_sections(dec_file, "Products")
|
|
formations = set()
|
|
for formation in forms:
|
|
data = _comment_strip.match(formation)
|
|
if data:
|
|
form = data.group(1)
|
|
else:
|
|
raise ValueError("regex error")
|
|
form = form.strip()
|
|
if form != "":
|
|
formations.add(form)
|
|
return formations
|
|
|
|
def generate_dec_file(dec_file, selected_formation):
|
|
dec_file[-1][-1][-1] += '\n'
|
|
if len(dec_file[0][1]) > 0 and dec_file[0][1][0].rfind("\r\n") != -1:
|
|
line_ending = "\r\n"
|
|
else:
|
|
line_ending = "\n"
|
|
formations = get_formations(dec_file)
|
|
if selected_formation not in formations:
|
|
raise ValueError("Formation {} does not exist".format(selected_formation))
|
|
remaining_dec = []
|
|
for section in dec_file:
|
|
if section[0][0] != 0:
|
|
if section[0][0].lower() == "products":
|
|
continue
|
|
headers = section[0][0].split(",")
|
|
headers = [header.strip() for header in headers]
|
|
remaining_headers = set()
|
|
for header in headers:
|
|
has_formation_specifier = False
|
|
for formation in formations:
|
|
if header.endswith(".{}".format(formation)):
|
|
has_formation_specifier = True
|
|
if formation == selected_formation:
|
|
remaining_headers.add(header[0:header.rfind(".{}".format(formation))])
|
|
if not has_formation_specifier:
|
|
remaining_headers.add(header)
|
|
if set(headers) == remaining_headers:
|
|
remaining_headers = headers
|
|
if len(remaining_headers) > 0:
|
|
new_header = "[{}]".format(", ".join(remaining_headers))
|
|
create_section = True
|
|
for new_section in remaining_dec:
|
|
if isinstance(new_section[0][0], basestring) and new_section[0][0].strip().lower() == new_header.strip().lower():
|
|
if section[0][1].lower().find("restricted") == -1 and section[0][1].lower().find("internalonly") == -1:
|
|
if new_section[0][1].lower().find("restricted") == -1 and new_section[0][1].lower().find("internalonly") == -1:
|
|
create_section = False
|
|
new_section[1].extend(section[1])
|
|
if create_section:
|
|
remaining_dec.append(((new_header, section[0][1]), section[1]))
|
|
else:
|
|
remaining_dec.append(section)
|
|
output = []
|
|
for section in remaining_dec:
|
|
if section[0][0] != 0:
|
|
output.append("{}{}{}".format(section[0][0], section[0][1], line_ending))
|
|
output.extend(section[1])
|
|
return output
|
|
|
|
def main():
|
|
try:
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("dec_file_template", help="Template file that will be used to generate the DEC file")
|
|
parser.add_argument("selected_formation", help="Selects which form of the DEC file to create, must be present in the [Formations] section of the template")
|
|
parser.add_argument("output_dec_file", nargs="?", help="Name of the DEC file to be created")
|
|
parser.add_argument("--pcd", action="append", dest="OptionPcd", help="Set PCD value by command line. Format: \"PcdName=Value\" ")
|
|
parsed_args = parser.parse_args()
|
|
output_dec_file = parsed_args.output_dec_file
|
|
if output_dec_file is None:
|
|
if parsed_args.dec_file_template.rfind(".template") != -1:
|
|
output_dec_file = parsed_args.dec_file_template
|
|
output_dec_file = output_dec_file[0:output_dec_file.rfind(".template")]
|
|
if output_dec_file.rfind(".dec") == -1:
|
|
output_dec_file = "{}.dec".format(output_dec_file)
|
|
else:
|
|
print("Error: Input file extension is not .template, please specify output file name explicitly")
|
|
return 1
|
|
dec = generate_dec_file(read_dec_file(parsed_args.dec_file_template), parsed_args.selected_formation)
|
|
#convert name from .template to .dec and save file
|
|
with open(output_dec_file, "w") as out:
|
|
out.write("".join(dec))
|
|
return 0
|
|
except Exception as e:
|
|
traceback.print_exc()
|
|
print ("Error: {}".format(str(e)))
|
|
return 1
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|