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 --- .../Source/Python/Common/InfClassObjectLight.py | 876 +++++++++++++++++++++ 1 file changed, 876 insertions(+) create mode 100644 BaseTools/Source/Python/Common/InfClassObjectLight.py (limited to 'BaseTools/Source/Python/Common/InfClassObjectLight.py') diff --git a/BaseTools/Source/Python/Common/InfClassObjectLight.py b/BaseTools/Source/Python/Common/InfClassObjectLight.py new file mode 100644 index 0000000000..a655828e6a --- /dev/null +++ b/BaseTools/Source/Python/Common/InfClassObjectLight.py @@ -0,0 +1,876 @@ +## @file +# This file is used to define each component of INF file +# +# 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 re +import EdkLogger + +from CommonDataClass.ModuleClass import * +from CommonDataClass import CommonClass +from String import * +from DataType import * +from BuildToolError import * +from Misc import sdict +from Misc import GetFiles +from Parsing import * + +# Global variable +Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN, + TAB_INF_DEFINES.upper() : MODEL_META_DATA_HEADER, + TAB_BUILD_OPTIONS.upper() : MODEL_META_DATA_BUILD_OPTION, + TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE, + TAB_LIBRARIES.upper() : MODEL_EFI_LIBRARY_INSTANCE, + TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS, + TAB_PACKAGES.upper() : MODEL_META_DATA_PACKAGE, + TAB_NMAKE.upper() : MODEL_META_DATA_NMAKE, + TAB_INF_FIXED_PCD.upper() : MODEL_PCD_FIXED_AT_BUILD, + TAB_INF_PATCH_PCD.upper() : MODEL_PCD_PATCHABLE_IN_MODULE, + TAB_INF_FEATURE_PCD.upper() : MODEL_PCD_FEATURE_FLAG, + TAB_INF_PCD_EX.upper() : MODEL_PCD_DYNAMIC_EX, + TAB_INF_PCD.upper() : MODEL_PCD_DYNAMIC, + TAB_SOURCES.upper() : MODEL_EFI_SOURCE_FILE, + TAB_GUIDS.upper() : MODEL_EFI_GUID, + TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL, + TAB_PPIS.upper() : MODEL_EFI_PPI, + TAB_DEPEX.upper() : MODEL_EFI_DEPEX, + TAB_BINARIES.upper() : MODEL_EFI_BINARY_FILE, + TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION + } + +gComponentType2ModuleType = { + "LIBRARY" : "BASE", + "SECURITY_CORE" : "SEC", + "PEI_CORE" : "PEI_CORE", + "COMBINED_PEIM_DRIVER" : "PEIM", + "PIC_PEIM" : "PEIM", + "RELOCATABLE_PEIM" : "PEIM", + "PE32_PEIM" : "PEIM", + "BS_DRIVER" : "DXE_DRIVER", + "RT_DRIVER" : "DXE_RUNTIME_DRIVER", + "SAL_RT_DRIVER" : "DXE_SAL_DRIVER", + "APPLICATION" : "UEFI_APPLICATION", + "LOGO" : "BASE", +} + +class InfHeader(ModuleHeaderClass): + _Mapping_ = { + # Required Fields + TAB_INF_DEFINES_BASE_NAME : "Name", + TAB_INF_DEFINES_FILE_GUID : "Guid", + TAB_INF_DEFINES_MODULE_TYPE : "ModuleType", + TAB_INF_DEFINES_EFI_SPECIFICATION_VERSION : "EfiSpecificationVersion", + TAB_INF_DEFINES_EDK_RELEASE_VERSION : "EdkReleaseVersion", + + # Optional Fields + TAB_INF_DEFINES_INF_VERSION : "InfVersion", + TAB_INF_DEFINES_BINARY_MODULE : "BinaryModule", + TAB_INF_DEFINES_COMPONENT_TYPE : "ComponentType", + TAB_INF_DEFINES_MAKEFILE_NAME : "MakefileName", + TAB_INF_DEFINES_BUILD_NUMBER : "BuildNumber", + TAB_INF_DEFINES_BUILD_TYPE : "BuildType", + TAB_INF_DEFINES_FFS_EXT : "FfsExt", + TAB_INF_DEFINES_FV_EXT : "FvExt", + TAB_INF_DEFINES_SOURCE_FV : "SourceFv", + TAB_INF_DEFINES_VERSION_NUMBER : "VersionNumber", + TAB_INF_DEFINES_VERSION_STRING : "VersionString", + TAB_INF_DEFINES_VERSION : "Version", + TAB_INF_DEFINES_PCD_IS_DRIVER : "PcdIsDriver", + TAB_INF_DEFINES_TIANO_R8_FLASHMAP_H : "TianoR8FlashMap_h", + TAB_INF_DEFINES_SHADOW : "Shadow", + } + + def __init__(self): + ModuleHeaderClass.__init__(self) + self.VersionNumber = '' + self.VersionString = '' + #print self.__dict__ + def __setitem__(self, key, value): + self.__dict__[self._Mapping_[key]] = value + def __getitem__(self, key): + return self.__dict__[self._Mapping_[key]] + ## "in" test support + def __contains__(self, key): + return key in self._Mapping_ + +## InfObject +# +# This class defined basic Inf object which is used by inheriting +# +# @param object: Inherited from object class +# +class InfObject(object): + def __init__(self): + object.__init__() + +## Inf +# +# This class defined the structure used in Inf object +# +# @param InfObject: Inherited from InfObject class +# @param Ffilename: Input value for Ffilename of Inf file, default is None +# @param IsMergeAllArches: Input value for IsMergeAllArches +# True is to merge all arches +# Fales is not to merge all arches +# default is False +# @param IsToModule: Input value for IsToModule +# True is to transfer to ModuleObject automatically +# False is not to transfer to ModuleObject automatically +# default is False +# @param WorkspaceDir: Input value for current workspace directory, default is None +# +# @var Identification: To store value for Identification, it is a structure as Identification +# @var UserExtensions: To store value for UserExtensions +# @var Module: To store value for Module, it is a structure as ModuleClass +# @var WorkspaceDir: To store value for WorkspaceDir +# @var KeyList: To store value for KeyList, a list for all Keys used in Inf +# +class Inf(InfObject): + def __init__(self, Filename = None, IsToModule = False, WorkspaceDir = None, PackageDir = None, SupArchList = DataType.ARCH_LIST): + self.Identification = IdentificationClass() + self.Module = ModuleClass() + self.WorkspaceDir = WorkspaceDir + self.PackageDir = PackageDir + self.SupArchList = SupArchList + + self.KeyList = [ + TAB_SOURCES, TAB_BUILD_OPTIONS, TAB_BINARIES, TAB_INCLUDES, TAB_GUIDS, + TAB_PROTOCOLS, TAB_PPIS, TAB_LIBRARY_CLASSES, TAB_PACKAGES, TAB_INF_FIXED_PCD, + TAB_INF_PATCH_PCD, TAB_INF_FEATURE_PCD, TAB_INF_PCD, TAB_INF_PCD_EX, + TAB_DEPEX, TAB_INF_DEFINES + ] + # Upper all KEYs to ignore case sensitive when parsing + self.KeyList = map(lambda c: c.upper(), self.KeyList) + + # Init RecordSet + self.RecordSet = {} + for Key in self.KeyList: + self.RecordSet[Section[Key]] = [] + + # Init Comment + self.SectionHeaderCommentDict = {} + + # Load Inf file if filename is not None + if Filename != None: + self.LoadInfFile(Filename) + + # Transfer to Module Object if IsToModule is True + if IsToModule: + self.InfToModule() + + ## Module Object to INF file + def ModuleToInf(self, Module): + Inf = '' + InfList = sdict() + SectionHeaderCommentDict = {} + if Module == None: + return Inf + + ModuleHeader = Module.ModuleHeader + TmpList = [] + # Common define items + if ModuleHeader.Name: + TmpList.append(TAB_INF_DEFINES_BASE_NAME + ' = ' + ModuleHeader.Name) + if ModuleHeader.Guid: + TmpList.append(TAB_INF_DEFINES_FILE_GUID + ' = ' + ModuleHeader.Guid) + if ModuleHeader.Version: + TmpList.append(TAB_INF_DEFINES_VERSION_STRING + ' = ' + ModuleHeader.Version) + if ModuleHeader.ModuleType: + TmpList.append(TAB_INF_DEFINES_MODULE_TYPE + ' = ' + ModuleHeader.ModuleType) + if ModuleHeader.PcdIsDriver: + TmpList.append(TAB_INF_DEFINES_PCD_IS_DRIVER + ' = ' + ModuleHeader.PcdIsDriver) + # Externs + for Item in Module.Externs: + if Item.EntryPoint: + TmpList.append(TAB_INF_DEFINES_ENTRY_POINT + ' = ' + Item.EntryPoint) + if Item.UnloadImage: + TmpList.append(TAB_INF_DEFINES_UNLOAD_IMAGE + ' = ' + Item.UnloadImage) + if Item.Constructor: + TmpList.append(TAB_INF_DEFINES_CONSTRUCTOR + ' = ' + Item.Constructor) + if Item.Destructor: + TmpList.append(TAB_INF_DEFINES_DESTRUCTOR + ' = ' + Item.Destructor) + # Other define items + if Module.UserExtensions != None: + for Item in Module.UserExtensions.Defines: + TmpList.append(Item) + InfList['Defines'] = TmpList + if ModuleHeader.Description != '': + SectionHeaderCommentDict['Defines'] = ModuleHeader.Description + + if Module.UserExtensions != None: + InfList['BuildOptions'] = Module.UserExtensions.BuildOptions + + for Item in Module.Includes: + Key = 'Includes.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + Value.append(Item.FilePath) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.LibraryClasses: + Key = 'LibraryClasses.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + NewValue = Item.LibraryClass + if Item.RecommendedInstance: + NewValue = NewValue + '|' + Item.RecommendedInstance + if Item.FeatureFlag: + NewValue = NewValue + '|' + Item.FeatureFlag + Value.append(NewValue) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.PackageDependencies: + Key = 'Packages.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + Value.append(Item.FilePath) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.PcdCodes: + Key = 'Pcds' + Item.ItemType + '.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + NewValue = Item.TokenSpaceGuidCName + '.' + Item.CName + if Item.DefaultValue != '': + NewValue = NewValue + '|' + Item.DefaultValue + Value.append(NewValue) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.Sources: + Key = 'Sources.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + NewValue = Item.SourceFile + if Item.ToolChainFamily != '': + NewValue = NewValue + '|' + Item.ToolChainFamily + if Item.TagName != '': + NewValue = NewValue + '|' + Item.TagName + if Item.ToolCode != '': + NewValue = NewValue + '|' + Item.ToolCode + if Item.FeatureFlag != '': + NewValue = NewValue + '|' + Item.FeatureFlag + Value.append(NewValue) + if Item.HelpText != '': + SectionHeaderCommentDict[Key] = Item.HelpText + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.Guids: + Key = 'Guids.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + Value.append(Item.CName) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.Protocols: + Key = 'Protocols.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + Value.append(Item.CName) + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.Ppis: + Key = 'Ppis.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + Value.append(Item.CName) + GenMetaDatSectionItem(Key, Value, InfList) + + if Module.PeiDepex: + Key = 'Depex' + Value = Module.PeiDepex.Depex + GenMetaDatSectionItem(Key, Value, InfList) + + if Module.DxeDepex: + Key = 'Depex' + Value = Module.DxeDepex.Depex + GenMetaDatSectionItem(Key, Value, InfList) + + if Module.SmmDepex: + Key = 'Depex' + Value = Module.SmmDepex.Depex + GenMetaDatSectionItem(Key, Value, InfList) + + for Item in Module.Binaries: + Key = 'Binaries.' + GetStringOfList(Item.SupArchList) + Value = GetHelpTextList(Item.HelpTextList) + NewValue = Item.FileType + '|' + Item.BinaryFile + '|' + Item.Target + if Item.FeatureFlag != '': + NewValue = NewValue + '|' + Item.FeatureFlag + Value.append(NewValue) + GenMetaDatSectionItem(Key, Value, InfList) + + # Transfer Module to Inf + for Key in InfList: + if Key in SectionHeaderCommentDict: + List = SectionHeaderCommentDict[Key].split('\r') + for Item in List: + Inf = Inf + Item + '\n' + Inf = Inf + '[' + Key + ']' + '\n' + for Value in InfList[Key]: + if type(Value) == type([]): + for SubValue in Value: + Inf = Inf + ' ' + SubValue + '\n' + else: + Inf = Inf + ' ' + Value + '\n' + Inf = Inf + '\n' + + return Inf + + + ## Transfer to Module Object + # + # Transfer all contents of an Inf file to a standard Module Object + # + def InfToModule(self): + # Init global information for the file + ContainerFile = self.Identification.FullPath + + # Generate Module Header + self.GenModuleHeader(ContainerFile) + + # Generate BuildOptions + self.GenBuildOptions(ContainerFile) + + # Generate Includes + self.GenIncludes(ContainerFile) + + # Generate LibraryClasses + self.GenLibraryClasses(ContainerFile) + + # Generate Packages + self.GenPackages(ContainerFile) + + # Generate Pcds + self.GenPcds(ContainerFile) + + # Generate Sources + self.GenSources(ContainerFile) + + # Generate Guids + self.GenGuidProtocolPpis(DataType.TAB_GUIDS, ContainerFile) + + # Generate Protocols + self.GenGuidProtocolPpis(DataType.TAB_PROTOCOLS, ContainerFile) + + # Generate Ppis + self.GenGuidProtocolPpis(DataType.TAB_PPIS, ContainerFile) + + # Generate Depexes + self.GenDepexes(ContainerFile) + + # Generate Binaries + self.GenBinaries(ContainerFile) + + # Init MiscFiles + self.GenMiscFiles(ContainerFile) + + ## GenMiscFiles + # + def GenMiscFiles(self, ContainerFile): + MiscFiles = MiscFileClass() + MiscFiles.Name = 'ModuleFiles' + for Item in GetFiles(os.path.dirname(ContainerFile), ['CVS', '.svn'], False): + File = CommonClass.FileClass() + File.Filename = Item + MiscFiles.Files.append(File) + self.Module.MiscFiles = MiscFiles + + ## Load Inf file + # + # Load the file if it exists + # + # @param Filename: Input value for filename of Inf file + # + def LoadInfFile(self, Filename): + # Insert a record for file + Filename = NormPath(Filename) + + self.Identification.FullPath = Filename + (self.Identification.RelaPath, self.Identification.FileName) = os.path.split(Filename) + if self.Identification.FullPath.find(self.WorkspaceDir) > -1: + self.Identification.ModulePath = os.path.dirname(self.Identification.FullPath[len(self.WorkspaceDir) + 1:]) + if self.PackageDir: + self.Identification.PackagePath = self.PackageDir + if self.Identification.ModulePath.find(self.PackageDir) == 0: + self.Identification.ModulePath = self.Identification.ModulePath[len(self.PackageDir) + 1:] + + # Init common datas + IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \ + [], [], TAB_UNKNOWN, [], [], [] + LineNo = 0 + + # Parse file content + IsFindBlockComment = False + ReservedLine = '' + Comment = '' + for Line in open(Filename, 'r'): + LineNo = LineNo + 1 + # Remove comment block + if Line.find(TAB_COMMENT_R8_START) > -1: + ReservedLine = GetSplitValueList(Line, TAB_COMMENT_R8_START, 1)[0] + if ReservedLine.strip().startswith(TAB_COMMENT_SPLIT): + Comment = Comment + Line.strip() + '\n' + ReservedLine = '' + else: + Comment = Comment + Line[len(ReservedLine):] + '\n' + IsFindBlockComment = True + if not ReservedLine: + continue + if Line.find(TAB_COMMENT_R8_END) > -1: + Comment = Comment + Line[:Line.find(TAB_COMMENT_R8_END) + len(TAB_COMMENT_R8_END)] + '\n' + Line = ReservedLine + GetSplitValueList(Line, TAB_COMMENT_R8_END, 1)[1] + ReservedLine = '' + IsFindBlockComment = False + if IsFindBlockComment: + Comment = Comment + Line.strip() + '\n' + continue + + # Remove comments at tail and remove spaces again + if Line.strip().startswith(TAB_COMMENT_SPLIT) or Line.strip().startswith('--/'): + Comment = Comment + Line.strip() + '\n' + Line = CleanString(Line) + if Line == '': + continue + + ## Find a new section tab + # First insert previous section items + # And then parse the content of the new section + if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END): + if Line[1:3] == "--": + continue + Model = Section[CurrentSection.upper()] + # Insert items data of previous section + InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet) + + # Parse the new section + SectionItemList = [] + ArchList = [] + ThirdList = [] + + CurrentSection = '' + LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT) + for Item in LineList: + ItemList = GetSplitValueList(Item, TAB_SPLIT) + if CurrentSection == '': + CurrentSection = ItemList[0] + else: + if CurrentSection != ItemList[0]: + EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError) + if CurrentSection.upper() not in self.KeyList: + RaiseParserError(Line, CurrentSection, Filename, '', LineNo) + ItemList.append('') + ItemList.append('') + if len(ItemList) > 5: + RaiseParserError(Line, CurrentSection, Filename, '', LineNo) + else: + if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL: + EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError) + ArchList.append(ItemList[1].upper()) + ThirdList.append(ItemList[2]) + + if Comment: + if Comment.endswith('\n'): + Comment = Comment[:len(Comment) - len('\n')] + self.SectionHeaderCommentDict[Section[CurrentSection.upper()]] = Comment + Comment = '' + continue + + # Not in any defined section + if CurrentSection == TAB_UNKNOWN: + ErrorMsg = "%s is not in any defined section" % Line + EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError) + + # Add a section item + SectionItemList.append([Line, LineNo, Comment]) + Comment = '' + # End of parse + #End of For + + # Insert items data of last section + Model = Section[CurrentSection.upper()] + InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet) + if Comment != '': + self.SectionHeaderCommentDict[Model] = Comment + Comment = '' + + ## Show detailed information of Module + # + # Print all members and their values of Module class + # + def ShowModule(self): + M = self.Module + print 'Filename =', M.ModuleHeader.FileName + print 'FullPath =', M.ModuleHeader.FullPath + print 'RelaPath =', M.ModuleHeader.RelaPath + print 'PackagePath =', M.ModuleHeader.PackagePath + print 'ModulePath =', M.ModuleHeader.ModulePath + print 'CombinePath =', M.ModuleHeader.CombinePath + + print 'BaseName =', M.ModuleHeader.Name + print 'Guid =', M.ModuleHeader.Guid + print 'Version =', M.ModuleHeader.Version + + print '\nIncludes =' + for Item in M.Includes: + print Item.FilePath, Item.SupArchList + print '\nLibraryClasses =' + for Item in M.LibraryClasses: + print Item.LibraryClass, Item.RecommendedInstance, Item.RecommendedInstanceGuid, Item.RecommendedInstanceVersion, Item.FeatureFlag, Item.SupModuleList, Item.SupArchList, Item.Define + print '\nPackageDependencies =' + for Item in M.PackageDependencies: + print Item.FilePath, Item.SupArchList, Item.FeatureFlag + print '\nPcds =' + for Item in M.PcdCodes: + print '\tCName=',Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, Item.SupArchList + print '\nSources =' + for Source in M.Sources: + print Source.SourceFile, 'Fam=', Source.ToolChainFamily, 'Pcd=', Source.FeatureFlag, 'Tag=', Source.TagName, 'ToolCode=', Source.ToolCode, Source.SupArchList + print '\nGuids =' + for Item in M.Guids: + print Item.CName, Item.SupArchList, Item.FeatureFlag + print '\nProtocols =' + for Item in M.Protocols: + print Item.CName, Item.SupArchList, Item.FeatureFlag + print '\nPpis =' + for Item in M.Ppis: + print Item.CName, Item.SupArchList, Item.FeatureFlag + print '\nDepex =' + for Item in M.Depex: + print Item.Depex, Item.SupArchList, Item.Define + print '\nBinaries =' + for Binary in M.Binaries: + print 'Type=', Binary.FileType, 'Target=', Binary.Target, 'Name=', Binary.BinaryFile, 'FeatureFlag=', Binary.FeatureFlag, 'SupArchList=', Binary.SupArchList + print '\n*** FileList ***' + for Item in M.MiscFiles.Files: + print Item.Filename + print '****************\n' + + ## Convert [Defines] section content to ModuleHeaderClass + # + # Convert [Defines] section content to ModuleHeaderClass + # + # @param Defines The content under [Defines] section + # @param ModuleHeader An object of ModuleHeaderClass + # @param Arch The supported ARCH + # + def GenModuleHeader(self, ContainerFile): + EdkLogger.debug(2, "Generate ModuleHeader ...") + # Update all defines item in database + RecordSet = self.RecordSet[MODEL_META_DATA_HEADER] + + ModuleHeader = ModuleHeaderClass() + ModuleExtern = ModuleExternClass() + OtherDefines = [] + for Record in RecordSet: + ValueList = GetSplitValueList(Record[0], TAB_EQUAL_SPLIT) + if len(ValueList) != 2: + OtherDefines.append(Record[0]) + else: + Name = ValueList[0] + Value = ValueList[1] + if Name == TAB_INF_DEFINES_BASE_NAME: + ModuleHeader.Name = Value + ModuleHeader.BaseName = Value + elif Name == TAB_INF_DEFINES_FILE_GUID: + ModuleHeader.Guid = Value + elif Name == TAB_INF_DEFINES_VERSION_STRING: + ModuleHeader.Version = Value + elif Name == TAB_INF_DEFINES_PCD_IS_DRIVER: + ModuleHeader.PcdIsDriver = Value + elif Name == TAB_INF_DEFINES_MODULE_TYPE: + ModuleHeader.ModuleType = Value + elif Name == TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION: + ModuleHeader.UefiSpecificationVersion = Value + elif Name == TAB_INF_DEFINES_PI_SPECIFICATION_VERSION: + ModuleHeader.PiSpecificationVersion = Value + elif Name == TAB_INF_DEFINES_ENTRY_POINT: + ModuleExtern.EntryPoint = Value + elif Name == TAB_INF_DEFINES_UNLOAD_IMAGE: + ModuleExtern.UnloadImage = Value + elif Name == TAB_INF_DEFINES_CONSTRUCTOR: + ModuleExtern.Constructor = Value + elif Name == TAB_INF_DEFINES_DESTRUCTOR: + ModuleExtern.Destructor = Value + else: + OtherDefines.append(Record[0]) + ModuleHeader.FileName = self.Identification.FileName + ModuleHeader.FullPath = self.Identification.FullPath + ModuleHeader.RelaPath = self.Identification.RelaPath + ModuleHeader.PackagePath = self.Identification.PackagePath + ModuleHeader.ModulePath = self.Identification.ModulePath + ModuleHeader.CombinePath = os.path.normpath(os.path.join(ModuleHeader.PackagePath, ModuleHeader.ModulePath, ModuleHeader.FileName)) + + if MODEL_META_DATA_HEADER in self.SectionHeaderCommentDict: + ModuleHeader.Description = self.SectionHeaderCommentDict[MODEL_META_DATA_HEADER] + self.Module.ModuleHeader = ModuleHeader + self.Module.Externs.append(ModuleExtern) + UE = self.Module.UserExtensions + if UE == None: + UE = UserExtensionsClass() + UE.Defines = OtherDefines + self.Module.UserExtensions = UE + + ## GenBuildOptions + # + # Gen BuildOptions of Inf + # [:]=Flag + # + # @param ContainerFile: The Inf file full path + # + def GenBuildOptions(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_BUILD_OPTIONS) + BuildOptions = {} + # Get all BuildOptions + RecordSet = self.RecordSet[MODEL_META_DATA_BUILD_OPTION] + UE = self.Module.UserExtensions + if UE == None: + UE = UserExtensionsClass() + for Record in RecordSet: + UE.BuildOptions.append(Record[0]) + self.Module.UserExtensions = UE + + ## GenIncludes + # + # Gen Includes of Inf + # + # @param ContainerFile: The Inf file full path + # + def GenIncludes(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_INCLUDES) + Includes = sdict() + # Get all Includes + RecordSet = self.RecordSet[MODEL_EFI_INCLUDE] + for Record in RecordSet: + Include = IncludeClass() + Include.FilePath = Record[0] + Include.SupArchList = Record[1] + if GenerateHelpText(Record[5], ''): + Include.HelpTextList.append(GenerateHelpText(Record[5], '')) + self.Module.Includes.append(Include) + #self.Module.FileList.extend(GetFiles(os.path.normpath(os.path.join(self.Identification.FileRelativePath, Include.FilePath)), ['CVS', '.svn'])) + + ## GenLibraryClasses + # + # Get LibraryClass of Inf + # | + # + # @param ContainerFile: The Inf file full path + # + def GenLibraryClasses(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES) + LibraryClasses = {} + # Get all LibraryClasses + RecordSet = self.RecordSet[MODEL_EFI_LIBRARY_CLASS] + for Record in RecordSet: + (LibClassName, LibClassIns, Pcd, SupModelList) = GetLibraryClassOfInf([Record[0], Record[4]], ContainerFile, self.WorkspaceDir, Record[2]) + LibraryClass = CommonClass.LibraryClassClass() + LibraryClass.LibraryClass = LibClassName + LibraryClass.RecommendedInstance = LibClassIns + LibraryClass.FeatureFlag = Pcd + LibraryClass.SupArchList = Record[1] + LibraryClass.SupModuleList = Record[4] + if GenerateHelpText(Record[5], ''): + LibraryClass.HelpTextList.append(GenerateHelpText(Record[5], '')) + self.Module.LibraryClasses.append(LibraryClass) + + ## GenPackages + # + # Gen Packages of Inf + # + # @param ContainerFile: The Inf file full path + # + def GenPackages(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_PACKAGES) + Packages = {} + # Get all Packages + RecordSet = self.RecordSet[MODEL_META_DATA_PACKAGE] + for Record in RecordSet: + (PackagePath, Pcd) = GetPackage(Record[0], ContainerFile, self.WorkspaceDir, Record[2]) + Package = ModulePackageDependencyClass() + Package.FilePath = NormPath(PackagePath) + Package.SupArchList = Record[1] + Package.FeatureFlag = Pcd + if GenerateHelpText(Record[5], ''): + Package.HelpTextList.append(GenerateHelpText(Record[5], '')) + self.Module.PackageDependencies.append(Package) + + def AddPcd(self, CName, TokenSpaceGuidCName, DefaultValue, ItemType, Arch, HelpTextList): + Pcd = PcdClass() + Pcd.CName = CName + Pcd.TokenSpaceGuidCName = TokenSpaceGuidCName + Pcd.DefaultValue = DefaultValue + Pcd.ItemType = ItemType + Pcd.SupArchList = Arch + if GenerateHelpText(HelpTextList, ''): + Pcd.HelpTextList.append(GenerateHelpText(HelpTextList, '')) + self.Module.PcdCodes.append(Pcd) + + ## GenPcds + # + # Gen Pcds of Inf + # .[|] + # + # @param ContainerFile: The Dec file full path + # + def GenPcds(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_PCDS) + Pcds = {} + PcdToken = {} + + # Get all Pcds + RecordSet1 = self.RecordSet[MODEL_PCD_FIXED_AT_BUILD] + RecordSet2 = self.RecordSet[MODEL_PCD_PATCHABLE_IN_MODULE] + RecordSet3 = self.RecordSet[MODEL_PCD_FEATURE_FLAG] + RecordSet4 = self.RecordSet[MODEL_PCD_DYNAMIC_EX] + RecordSet5 = self.RecordSet[MODEL_PCD_DYNAMIC] + + # Go through each arch + for Record in RecordSet1: + (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FIXED_AT_BUILD, ContainerFile, Record[2]) + self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5]) + for Record in RecordSet2: + (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile, Record[2]) + self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5]) + for Record in RecordSet3: + (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_FEATURE_FLAG, ContainerFile, Record[2]) + self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5]) + for Record in RecordSet4: + (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], TAB_PCDS_DYNAMIC_EX, ContainerFile, Record[2]) + self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5]) + for Record in RecordSet5: + (TokenSpaceGuidCName, TokenName, Value, Type) = GetPcdOfInf(Record[0], '', ContainerFile, Record[2]) + self.AddPcd(TokenName, TokenSpaceGuidCName, Value, Type, Record[1], Record[5]) + + ## GenSources + # + # Gen Sources of Inf + # [|[|[|[|]]]] + # + # @param ContainerFile: The Dec file full path + # + def GenSources(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_SOURCES) + Sources = {} + + # Get all Sources + RecordSet = self.RecordSet[MODEL_EFI_SOURCE_FILE] + for Record in RecordSet: + (Filename, Family, TagName, ToolCode, Pcd) = GetSource(Record[0], ContainerFile, self.Identification.RelaPath, Record[2]) + Source = ModuleSourceFileClass(Filename, TagName, ToolCode, Family, Pcd, Record[1]) + if GenerateHelpText(Record[5], ''): + Source.HelpTextList.append(GenerateHelpText(Record[5], '')) + if MODEL_EFI_SOURCE_FILE in self.SectionHeaderCommentDict: + Source.HelpText = self.SectionHeaderCommentDict[MODEL_EFI_SOURCE_FILE] + self.Module.Sources.append(Source) + #self.Module.FileList.append(os.path.normpath(os.path.join(self.Identification.RelaPath, Filename))) + + ## GenDepexes + # + # Gen Depex of Inf + # + # @param ContainerFile: The Inf file full path + # + def GenDepexes(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_DEPEX) + Depex = {} + # Get all Depexes + RecordSet = self.RecordSet[MODEL_EFI_DEPEX] + DepexString = '' + for Record in RecordSet: + DepexString = DepexString + Record[0] + '\n' + Dep = ModuleDepexClass() + if DepexString.endswith('\n'): + DepexString = DepexString[:len(DepexString) - len('\n')] + Dep.Depex = DepexString + if self.Module.ModuleHeader.ModuleType in ['DXE_SMM_DRIVER']: + self.Module.SmmDepex = Dep + elif self.Module.ModuleHeader.ModuleType in ['PEI_CORE', 'PEIM']: + self.Module.PeiDepex = Dep + else: + self.Module.DxeDepex = Dep +# for Record in RecordSet: +# +# Dep = ModuleDepexClass() +# Dep.Depex = Record[0] +# Dep.SupArchList = Record[1] +# if GenerateHelpText(Record[5], ''): +# Dep.HelpTextList.append(GenerateHelpText(Record[5], '')) +# DepexString = DepexString + Dep +# List.append(Dep) +# self.Module.Depex = List +# if self.Module.ModuleHeader.ModuleType in ['DXE_SMM_DRIVER']: +# self.Module.SmmDepex = List +# elif self.Module.ModuleHeader.ModuleType in ['PEI_CORE', 'PEIM']: +# self.Module.PeiDepex = List +# else: +# self.Module.DxeDepex = List + + ## GenBinaries + # + # Gen Binary of Inf + # ||[|.] + # + # @param ContainerFile: The Dec file full path + # + def GenBinaries(self, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % TAB_BINARIES) + Binaries = {} + + # Get all Guids + RecordSet = self.RecordSet[MODEL_EFI_BINARY_FILE] + for Record in RecordSet: + (FileType, Filename, Target, Pcd) = GetBinary(Record[0], ContainerFile, self.Identification.RelaPath, Record[2]) + Binary = ModuleBinaryFileClass(Filename, FileType, Target, Pcd, Record[1]) + if GenerateHelpText(Record[5], ''): + Binary.HelpTextList.append(GenerateHelpText(Record[5], '')) + self.Module.Binaries.append(Binary) + #self.Module.FileList.append(os.path.normpath(os.path.join(self.Identification.RelaPath, Filename))) + + ## GenGuids + # + # Gen Guids of Inf + # = + # + # @param ContainerFile: The Inf file full path + # + def GenGuidProtocolPpis(self, Type, ContainerFile): + EdkLogger.debug(2, "Generate %s ..." % Type) + Lists = {} + # Get all Items + if Type == TAB_GUIDS: + ListMember = self.Module.Guids + elif Type == TAB_PROTOCOLS: + ListMember = self.Module.Protocols + elif Type == TAB_PPIS: + ListMember = self.Module.Ppis + + RecordSet = self.RecordSet[Section[Type.upper()]] + for Record in RecordSet: + (Name, Value) = GetGuidsProtocolsPpisOfInf(Record[0], Type, ContainerFile, Record[2]) + ListClass = GuidProtocolPpiCommonClass() + ListClass.CName = Name + ListClass.SupArchList = Record[1] + ListClass.FeatureFlag = Value + if GenerateHelpText(Record[5], ''): + ListClass.HelpTextList.append(GenerateHelpText(Record[5], '')) + ListMember.append(ListClass) + +## +# +# This acts like the main() function for the script, unless it is 'import'ed into another +# script. +# +if __name__ == '__main__': + EdkLogger.Initialize() + EdkLogger.SetLevel(EdkLogger.QUIET) + + W = os.getenv('WORKSPACE') + F = os.path.join(W, 'MdeModulePkg/Application/HelloWorld/HelloWorld.inf') + + P = Inf(os.path.normpath(F), True, W, 'MdeModulePkg') + P.ShowModule() + print P.ModuleToInf(P.Module) -- cgit v1.2.3