From 30fdf1140b8d1ce93f3821d986fa165552023440 Mon Sep 17 00:00:00 2001 From: lgao4 Date: Fri, 17 Jul 2009 09:10:31 +0000 Subject: Check In tool source code based on Build tool project revision r1655. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8964 6f19259b-4bc3-4df7-8a09-765794883524 --- BaseTools/Source/Python/Trim/Trim.py | 520 +++++++++++++++++++++++++++++++++++ 1 file changed, 520 insertions(+) create mode 100644 BaseTools/Source/Python/Trim/Trim.py (limited to 'BaseTools/Source/Python/Trim/Trim.py') diff --git a/BaseTools/Source/Python/Trim/Trim.py b/BaseTools/Source/Python/Trim/Trim.py new file mode 100644 index 0000000000..a55c136edb --- /dev/null +++ b/BaseTools/Source/Python/Trim/Trim.py @@ -0,0 +1,520 @@ +## @file +# Trim files preprocessed by compiler +# +# Copyright (c) 2007, Intel Corporation +# All rights reserved. This program and the accompanying materials +# are licensed and made available under the terms and conditions of the BSD License +# which accompanies this distribution. The full text of the license may be found at +# http://opensource.org/licenses/bsd-license.php +# +# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, +# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. +# + +## +# Import Modules +# +import os +import sys +import re + +from optparse import OptionParser +from optparse import make_option +from Common.BuildToolError import * +from Common.Misc import * + +import Common.EdkLogger as EdkLogger + +# Version and Copyright +__version_number__ = "0.10" +__version__ = "%prog Version " + __version_number__ +__copyright__ = "Copyright (c) 2007-2008, Intel Corporation. All rights reserved." + +## Regular expression for matching Line Control directive like "#line xxx" +gLineControlDirective = re.compile('^\s*#(?:line)?\s+([0-9]+)\s+"*([^"]*)"') +## Regular expression for matching "typedef struct" +gTypedefPattern = re.compile("^\s*typedef\s+struct\s*[{]*$", re.MULTILINE) +## Regular expression for matching "#pragma pack" +gPragmaPattern = re.compile("^\s*#pragma\s+pack", re.MULTILINE) +## Regular expression for matching HEX number +gHexNumberPattern = re.compile("0[xX]([0-9a-fA-F]+)") +## Regular expression for matching "Include ()" in asl file +gAslIncludePattern = re.compile("^(\s*)[iI]nclude\s*\(\"?([^\"\(\)]+)\"\)", re.MULTILINE) +## Patterns used to convert EDK conventions to EDK2 ECP conventions +gImportCodePatterns = [ + [ + re.compile('^(\s*)\(\*\*PeiServices\)\.PciCfg\s*=\s*([^;\s]+);', re.MULTILINE), + '''\\1{ +\\1 STATIC EFI_PEI_PPI_DESCRIPTOR gEcpPeiPciCfgPpiList = { +\\1 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST), +\\1 &gEcpPeiPciCfgPpiGuid, +\\1 \\2 +\\1 }; +\\1 (**PeiServices).InstallPpi (PeiServices, &gEcpPeiPciCfgPpiList); +\\1}''' + ], + + [ + re.compile('^(\s*)\(\*PeiServices\)->PciCfg\s*=\s*([^;\s]+);', re.MULTILINE), + '''\\1{ +\\1 STATIC EFI_PEI_PPI_DESCRIPTOR gEcpPeiPciCfgPpiList = { +\\1 (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST), +\\1 &gEcpPeiPciCfgPpiGuid, +\\1 \\2 +\\1 }; +\\1 (**PeiServices).InstallPpi (PeiServices, &gEcpPeiPciCfgPpiList); +\\1}''' + ], + + [ + re.compile("(\s*).+->Modify[\s\n]*\(", re.MULTILINE), + '\\1PeiLibPciCfgModify (' + ], + + [ + re.compile("(\W*)gRT->ReportStatusCode[\s\n]*\(", re.MULTILINE), + '\\1EfiLibReportStatusCode (' + ], + + [ + re.compile('#include\s+["<]LoadFile\.h[">]', re.MULTILINE), + '#include ' + ], + + [ + re.compile("(\s*)\S*CreateEvent\s*\([\s\n]*EFI_EVENT_SIGNAL_READY_TO_BOOT[^,]*,((?:[^;]+\n)+)(\s*\));", re.MULTILINE), + '\\1EfiCreateEventReadyToBoot (\\2\\3;' + ], + + [ + re.compile("(\s*)\S*CreateEvent\s*\([\s\n]*EFI_EVENT_SIGNAL_LEGACY_BOOT[^,]*,((?:[^;]+\n)+)(\s*\));", re.MULTILINE), + '\\1EfiCreateEventLegacyBoot (\\2\\3;' + ], +# [ +# re.compile("(\W)(PEI_PCI_CFG_PPI)(\W)", re.MULTILINE), +# '\\1ECP_\\2\\3' +# ] +] + +## file cache to avoid circular include in ASL file +gIncludedAslFile = [] + +## Trim preprocessed source code +# +# Remove extra content made by preprocessor. The preprocessor must enable the +# line number generation option when preprocessing. +# +# @param Source File to be trimmed +# @param Target File to store the trimmed content +# @param Convert If True, convert standard HEX format to MASM format +# +def TrimPreprocessedFile(Source, Target, Convert): + CreateDirectory(os.path.dirname(Target)) + try: + f = open (Source, 'r') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Source) + + # read whole file + Lines = f.readlines() + f.close() + + PreprocessedFile = "" + InjectedFile = "" + LineIndexOfOriginalFile = None + NewLines = [] + LineControlDirectiveFound = False + for Index in range(len(Lines)): + Line = Lines[Index] + # + # Find out the name of files injected by preprocessor from the lines + # with Line Control directive + # + MatchList = gLineControlDirective.findall(Line) + if MatchList != []: + MatchList = MatchList[0] + if len(MatchList) == 2: + LineNumber = int(MatchList[0], 0) + InjectedFile = MatchList[1] + # The first injetcted file must be the preprocessed file itself + if PreprocessedFile == "": + PreprocessedFile = InjectedFile + LineControlDirectiveFound = True + continue + elif PreprocessedFile == "" or InjectedFile != PreprocessedFile: + continue + + if LineIndexOfOriginalFile == None: + # + # Any non-empty lines must be from original preprocessed file. + # And this must be the first one. + # + LineIndexOfOriginalFile = Index + EdkLogger.verbose("Found original file content starting from line %d" + % (LineIndexOfOriginalFile + 1)) + + # convert HEX number format if indicated + if Convert: + Line = gHexNumberPattern.sub(r"0\1h", Line) + + if LineNumber != None: + EdkLogger.verbose("Got line directive: line=%d" % LineNumber) + # in case preprocessor removed some lines, like blank or comment lines + if LineNumber <= len(NewLines): + # possible? + NewLines[LineNumber - 1] = Line + else: + if LineNumber > (len(NewLines) + 1): + for LineIndex in range(len(NewLines), LineNumber-1): + NewLines.append(os.linesep) + NewLines.append(Line) + LineNumber = None + EdkLogger.verbose("Now we have lines: %d" % len(NewLines)) + else: + NewLines.append(Line) + + # in case there's no line directive or linemarker found + if (not LineControlDirectiveFound) and NewLines == []: + NewLines = Lines + + # save to file + try: + f = open (Target, 'wb') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Target) + f.writelines(NewLines) + f.close() + +## Trim preprocessed VFR file +# +# Remove extra content made by preprocessor. The preprocessor doesn't need to +# enable line number generation option when preprocessing. +# +# @param Source File to be trimmed +# @param Target File to store the trimmed content +# +def TrimPreprocessedVfr(Source, Target): + CreateDirectory(os.path.dirname(Target)) + + try: + f = open (Source,'r') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Source) + # read whole file + Lines = f.readlines() + f.close() + + FoundTypedef = False + Brace = 0 + TypedefStart = 0 + TypedefEnd = 0 + for Index in range(len(Lines)): + Line = Lines[Index] + # don't trim the lines from "formset" definition to the end of file + if Line.strip() == 'formset': + break + + if FoundTypedef == False and (Line.find('#line') == 0 or Line.find('# ') == 0): + # empty the line number directive if it's not aomong "typedef struct" + Lines[Index] = "\n" + continue + + if FoundTypedef == False and gTypedefPattern.search(Line) == None: + # keep "#pragram pack" directive + if gPragmaPattern.search(Line) == None: + Lines[Index] = "\n" + continue + elif FoundTypedef == False: + # found "typedef struct", keept its position and set a flag + FoundTypedef = True + TypedefStart = Index + + # match { and } to find the end of typedef definition + if Line.find("{") >= 0: + Brace += 1 + elif Line.find("}") >= 0: + Brace -= 1 + + # "typedef struct" must end with a ";" + if Brace == 0 and Line.find(";") >= 0: + FoundTypedef = False + TypedefEnd = Index + # keep all "typedef struct" except to GUID, EFI_PLABEL and PAL_CALL_RETURN + if Line.strip("} ;\r\n") in ["GUID", "EFI_PLABEL", "PAL_CALL_RETURN"]: + for i in range(TypedefStart, TypedefEnd+1): + Lines[i] = "\n" + + # save all lines trimmed + try: + f = open (Target,'w') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Target) + f.writelines(Lines) + f.close() + +## Read the content ASL file, including ASL included, recursively +# +# @param Source File to be read +# @param Indent Spaces before the Include() statement +# +def DoInclude(Source, Indent=''): + NewFileContent = [] + # avoid A "include" B and B "include" A + if Source in gIncludedAslFile: + EdkLogger.warn("Trim", "Circular include", + ExtraData= "%s -> %s" % (" -> ".join(gIncludedAslFile), Source)) + return [] + gIncludedAslFile.append(Source) + + try: + F = open(Source,'r') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Source) + + for Line in F: + Result = gAslIncludePattern.findall(Line) + if len(Result) == 0: + NewFileContent.append("%s%s" % (Indent, Line)) + continue + CurrentIndent = Indent + Result[0][0] + IncludedFile = Result[0][1] + NewFileContent.extend(DoInclude(IncludedFile, CurrentIndent)) + + gIncludedAslFile.pop() + F.close() + + return NewFileContent + + +## Trim ASL file +# +# Replace ASL include statement with the content the included file +# +# @param Source File to be trimmed +# @param Target File to store the trimmed content +# +def TrimAslFile(Source, Target): + CreateDirectory(os.path.dirname(Target)) + + Cwd = os.getcwd() + SourceDir = os.path.dirname(Source) + if SourceDir == '': + SourceDir = '.' + os.chdir(SourceDir) + Lines = DoInclude(Source) + os.chdir(Cwd) + + # save all lines trimmed + try: + f = open (Target,'w') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Target) + + f.writelines(Lines) + f.close() + +## Trim EDK source code file(s) +# +# +# @param Source File or directory to be trimmed +# @param Target File or directory to store the trimmed content +# +def TrimR8Sources(Source, Target): + if os.path.isdir(Source): + for CurrentDir, Dirs, Files in os.walk(Source): + if '.svn' in Dirs: + Dirs.remove('.svn') + elif "CVS" in Dirs: + Dirs.remove("CVS") + + for FileName in Files: + Dummy, Ext = os.path.splitext(FileName) + if Ext.upper() not in ['.C', '.H']: continue + if Target == None or Target == '': + TrimR8SourceCode( + os.path.join(CurrentDir, FileName), + os.path.join(CurrentDir, FileName) + ) + else: + TrimR8SourceCode( + os.path.join(CurrentDir, FileName), + os.path.join(Target, CurrentDir[len(Source)+1:], FileName) + ) + else: + TrimR8SourceCode(Source, Target) + +## Trim one EDK source code file +# +# Do following replacement: +# +# (**PeiServices\).PciCfg = <*>; +# => { +# STATIC EFI_PEI_PPI_DESCRIPTOR gEcpPeiPciCfgPpiList = { +# (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST), +# &gEcpPeiPciCfgPpiGuid, +# <*> +# }; +# (**PeiServices).InstallPpi (PeiServices, &gEcpPeiPciCfgPpiList); +# +# <*>Modify(<*>) +# => PeiLibPciCfgModify (<*>) +# +# gRT->ReportStatusCode (<*>) +# => EfiLibReportStatusCode (<*>) +# +# #include +# => #include +# +# CreateEvent (EFI_EVENT_SIGNAL_READY_TO_BOOT, <*>) +# => EfiCreateEventReadyToBoot (<*>) +# +# CreateEvent (EFI_EVENT_SIGNAL_LEGACY_BOOT, <*>) +# => EfiCreateEventLegacyBoot (<*>) +# +# @param Source File to be trimmed +# @param Target File to store the trimmed content +# +def TrimR8SourceCode(Source, Target): + EdkLogger.verbose("\t%s -> %s" % (Source, Target)) + CreateDirectory(os.path.dirname(Target)) + + try: + f = open (Source,'rb') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Source) + # read whole file + Lines = f.read() + f.close() + + NewLines = None + for Re,Repl in gImportCodePatterns: + if NewLines == None: + NewLines = Re.sub(Repl, Lines) + else: + NewLines = Re.sub(Repl, NewLines) + + # save all lines if trimmed + if Source == Target and NewLines == Lines: + return + + try: + f = open (Target,'wb') + except: + EdkLogger.error("Trim", FILE_OPEN_FAILURE, ExtraData=Target) + f.write(NewLines) + f.close() + + +## Parse command line options +# +# Using standard Python module optparse to parse command line option of this tool. +# +# @retval Options A optparse.Values object containing the parsed options +# @retval InputFile Path of file to be trimmed +# +def Options(): + OptionList = [ + make_option("-s", "--source-code", dest="FileType", const="SourceCode", action="store_const", + help="The input file is preprocessed source code, including C or assembly code"), + make_option("-r", "--vfr-file", dest="FileType", const="Vfr", action="store_const", + help="The input file is preprocessed VFR file"), + make_option("-a", "--asl-file", dest="FileType", const="Asl", action="store_const", + help="The input file is ASL file"), + make_option("-8", "--r8-source-code", dest="FileType", const="R8SourceCode", action="store_const", + help="The input file is source code for R8 to be trimmed for ECP"), + + make_option("-c", "--convert-hex", dest="ConvertHex", action="store_true", + help="Convert standard hex format (0xabcd) to MASM format (abcdh)"), + + make_option("-o", "--output", dest="OutputFile", + help="File to store the trimmed content"), + make_option("-v", "--verbose", dest="LogLevel", action="store_const", const=EdkLogger.VERBOSE, + help="Run verbosely"), + make_option("-d", "--debug", dest="LogLevel", type="int", + help="Run with debug information"), + make_option("-q", "--quiet", dest="LogLevel", action="store_const", const=EdkLogger.QUIET, + help="Run quietly"), + make_option("-?", action="help", help="show this help message and exit"), + ] + + # use clearer usage to override default usage message + UsageString = "%prog [-s|-r|-a] [-c] [-v|-d |-q] [-o ] " + + Parser = OptionParser(description=__copyright__, version=__version__, option_list=OptionList, usage=UsageString) + Parser.set_defaults(FileType="Vfr") + Parser.set_defaults(ConvertHex=False) + Parser.set_defaults(LogLevel=EdkLogger.INFO) + + Options, Args = Parser.parse_args() + + # error check + if len(Args) == 0: + EdkLogger.error("Trim", OPTION_MISSING, ExtraData=Parser.get_usage()) + if len(Args) > 1: + EdkLogger.error("Trim", OPTION_NOT_SUPPORTED, ExtraData=Parser.get_usage()) + + InputFile = Args[0] + return Options, InputFile + +## Entrance method +# +# This method mainly dispatch specific methods per the command line options. +# If no error found, return zero value so the caller of this tool can know +# if it's executed successfully or not. +# +# @retval 0 Tool was successful +# @retval 1 Tool failed +# +def Main(): + try: + EdkLogger.Initialize() + CommandOptions, InputFile = Options() + if CommandOptions.LogLevel < EdkLogger.DEBUG_9: + EdkLogger.SetLevel(CommandOptions.LogLevel + 1) + else: + EdkLogger.SetLevel(CommandOptions.LogLevel) + except FatalError, X: + return 1 + + try: + if CommandOptions.FileType == "Vfr": + if CommandOptions.OutputFile == None: + CommandOptions.OutputFile = os.path.splitext(InputFile)[0] + '.iii' + TrimPreprocessedVfr(InputFile, CommandOptions.OutputFile) + elif CommandOptions.FileType == "Asl": + if CommandOptions.OutputFile == None: + CommandOptions.OutputFile = os.path.splitext(InputFile)[0] + '.iii' + TrimAslFile(InputFile, CommandOptions.OutputFile) + elif CommandOptions.FileType == "R8SourceCode": + TrimR8Sources(InputFile, CommandOptions.OutputFile) + else : + if CommandOptions.OutputFile == None: + CommandOptions.OutputFile = os.path.splitext(InputFile)[0] + '.iii' + TrimPreprocessedFile(InputFile, CommandOptions.OutputFile, CommandOptions.ConvertHex) + except FatalError, X: + import platform + import traceback + if CommandOptions != None and CommandOptions.LogLevel <= EdkLogger.DEBUG_9: + EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc()) + return 1 + except: + import traceback + import platform + EdkLogger.error( + "\nTrim", + CODE_ERROR, + "Unknown fatal error when trimming [%s]" % InputFile, + ExtraData="\n(Please send email to dev@buildtools.tianocore.org for help, attaching following call stack trace!)\n", + RaiseError=False + ) + EdkLogger.quiet("(Python %s on %s) " % (platform.python_version(), sys.platform) + traceback.format_exc()) + return 1 + + return 0 + +if __name__ == '__main__': + r = Main() + ## 0-127 is a safe return range, and 1 is a standard default error + if r < 0 or r > 127: r = 1 + sys.exit(r) + -- cgit v1.2.3