def SetLibraryClass(self, LibraryClass, Comments): ValueList = GetSplitValueList(LibraryClass) Name = ValueList[0] if IsValidWord(Name): InfDefineLibraryItemObj = InfDefineLibraryItem() InfDefineLibraryItemObj.SetLibraryName(Name) InfDefineLibraryItemObj.Comments = Comments if len(ValueList) == 2: Type = ValueList[1] TypeList = GetSplitValueList(Type, ' ') TypeList = [Type for Type in TypeList if Type != ''] for Item in TypeList: if Item not in DT.MODULE_LIST: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (Item), LineInfo=self.CurrentLine) return False InfDefineLibraryItemObj.SetTypes(TypeList) self.LibraryClass.append(InfDefineLibraryItemObj) else: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (Name), LineInfo=self.CurrentLine) return False return True
def ParseDecPcdTailComment(TailCommentList, ContainerFile): assert (len(TailCommentList) == 1) TailComment = TailCommentList[0][0] LineNum = TailCommentList[0][1] Comment = TailComment.lstrip(" #") ReFindFirstWordRe = re.compile(r"""^([^ #]*)""", re.DOTALL) # # get first word and compare with SUP_MODULE_LIST # MatchObject = ReFindFirstWordRe.match(Comment) if not (MatchObject and MatchObject.group(1) in SUP_MODULE_LIST): return None, Comment # # parse line, it must have supported module type specified # if Comment.find(TAB_COMMENT_SPLIT) == -1: Comment += TAB_COMMENT_SPLIT SupMode, HelpStr = GetSplitValueList(Comment, TAB_COMMENT_SPLIT, 1) SupModuleList = [] for Mod in GetSplitValueList(SupMode, TAB_SPACE_SPLIT): if not Mod: continue elif Mod not in SUP_MODULE_LIST: Logger.Error("UPT", FORMAT_INVALID, ST.WRN_INVALID_MODULE_TYPE % Mod, ContainerFile, LineNum) else: SupModuleList.append(Mod) return SupModuleList, HelpStr
def GetPcdOfInf(Item, Type, File, LineNo): Format = '<TokenSpaceGuidCName>.<PcdCName>[|<Value>]' TokenGuid, TokenName, Value, InfType = '', '', '', '' if Type == DataType.TAB_PCDS_FIXED_AT_BUILD: InfType = DataType.TAB_INF_FIXED_PCD elif Type == DataType.TAB_PCDS_PATCHABLE_IN_MODULE: InfType = DataType.TAB_INF_PATCH_PCD elif Type == DataType.TAB_PCDS_FEATURE_FLAG: InfType = DataType.TAB_INF_FEATURE_PCD elif Type == DataType.TAB_PCDS_DYNAMIC_EX: InfType = DataType.TAB_INF_PCD_EX elif Type == DataType.TAB_PCDS_DYNAMIC: InfType = DataType.TAB_INF_PCD List = GetSplitValueList(Item, DataType.TAB_VALUE_SPLIT, 1) TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT) if len(TokenInfo) != 2: RaiseParserError(Item, InfType, File, Format, LineNo) else: TokenGuid = TokenInfo[0] TokenName = TokenInfo[1] if len(List) > 1: Value = List[1] else: Value = None return (TokenGuid, TokenName, Value, InfType)
def testNormalCase2(self): TestCommentLines = \ '''## hello world # second line # @ValidList 1, 2, 3 # other line''' CommentList = GetSplitValueList(TestCommentLines, "\n") LineNum = 0 TestCommentLinesList = [] for Comment in CommentList: LineNum += 1 TestCommentLinesList.append((Comment, LineNum)) (HelpTxt, PcdErr) = \ ParseDecPcdGenericComment(TestCommentLinesList, 'UnitTest') self.failIf(not HelpTxt) self.failIf(not PcdErr) self.assertEqual(HelpTxt, 'hello world\n' + 'second line\n' + 'other line') ExpectedList = GetSplitValueList('1 2 3', TAB_SPACE_SPLIT) ActualList = [item for item in \ GetSplitValueList(PcdErr.GetValidValue(), TAB_SPACE_SPLIT) if item] self.assertEqual(ExpectedList, ActualList) self.failIf(PcdErr.GetExpression()) self.failIf(PcdErr.GetValidValueRange())
def FromXml(self, Item, Key): if Key: pass self.Usage = XmlAttribute(Item, 'Usage') self.SupArchList = \ [Arch for Arch in GetSplitValueList(XmlAttribute(Item, 'SupArchList'), DataType.TAB_SPACE_SPLIT) if Arch] self.SupModList = \ [Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod] self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))
def GetLibInstanceInfo(String, WorkSpace, LineNo, CurrentInfFileName): FileGuidString = "" VerString = "" OriginalString = String String = String.strip() if not String: return None, None # # Remove "#" characters at the beginning # String = GetHelpStringByRemoveHashKey(String) String = String.strip() # # To deal with library instance specified by GUID and version # RegFormatGuidPattern = re.compile("\s*([0-9a-fA-F]){8}-" "([0-9a-fA-F]){4}-" "([0-9a-fA-F]){4}-" "([0-9a-fA-F]){4}-" "([0-9a-fA-F]){12}\s*") VersionPattern = re.compile('[\t\s]*\d+(\.\d+)?[\t\s]*') GuidMatchedObj = RegFormatGuidPattern.search(String) if String.upper().startswith( 'GUID') and GuidMatchedObj and 'Version' in String: VersionStr = String[String.upper().find('VERSION') + 8:] VersionMatchedObj = VersionPattern.search(VersionStr) if VersionMatchedObj: Guid = GuidMatchedObj.group().strip() Version = VersionMatchedObj.group().strip() return Guid, Version # # To deal with library instance specified by file name # FileLinesList = GetFileLineContent(String, WorkSpace, LineNo, OriginalString) ReFindFileGuidPattern = re.compile("^\s*FILE_GUID\s*=.*$") ReFindVerStringPattern = re.compile("^\s*VERSION_STRING\s*=.*$") for Line in FileLinesList: if ReFindFileGuidPattern.match(Line): FileGuidString = Line if ReFindVerStringPattern.match(Line): VerString = Line if FileGuidString: FileGuidString = GetSplitValueList(FileGuidString, '=', 1)[1] if VerString: VerString = GetSplitValueList(VerString, '=', 1)[1] return FileGuidString, VerString
def GetDynamicVpdPcd(Item, Type, ContainerFile, LineNo= -1): TokenGuid, TokenName, List1, List2 = '', '', '', '' List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT) if len(List) < 3 or len(List) > 4: RaiseParserError(Item, 'Pcds' + Type, ContainerFile, \ '<PcdTokenSpaceGuidCName>.<TokenCName>|<VpdOffset>\ [|<MaximumDatumSize>]', LineNo) else: List1, List2 = List[1], List[2] if CheckPcdTokenInfo(List[0], 'Pcds' + Type, ContainerFile, LineNo): (TokenGuid, TokenName) = GetSplitValueList(List[0], DataType.TAB_SPLIT) return (TokenName, TokenGuid, List1, List2, Type)
def GetFeatureFlagPcd(Item, Type, ContainerFile, LineNo= -1): TokenGuid, TokenName, Value = '', '', '' List = GetSplitValueList(Item) if len(List) != 2: RaiseParserError(Item, 'Pcds' + Type, ContainerFile, \ '<PcdTokenSpaceGuidCName>.<TokenCName>|TRUE/FALSE', \ LineNo) else: Value = List[1] if CheckPcdTokenInfo(List[0], 'Pcds' + Type, ContainerFile, LineNo): (TokenGuid, TokenName) = GetSplitValueList(List[0], DataType.TAB_SPLIT) return (TokenName, TokenGuid, Value, Type)
def GetDynamicDefaultPcd(Item, Type, ContainerFile, LineNo= -1): TokenGuid, TokenName, Value, DatumTyp, MaxDatumSize = '', '', '', '', '' List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT * 2) if len(List) < 4 or len(List) > 8: RaiseParserError(Item, 'Pcds' + Type, ContainerFile, \ '<PcdTokenSpaceGuidCName>.<TokenCName>|<Value>\ [|<DatumTyp>[|<MaxDatumSize>]]', LineNo) else: Value = List[1] DatumTyp = List[2] MaxDatumSize = List[3] if CheckPcdTokenInfo(List[0], 'Pcds' + Type, ContainerFile, LineNo): (TokenGuid, TokenName) = GetSplitValueList(List[0], DataType.TAB_SPLIT) return (TokenName, TokenGuid, Value, DatumTyp, MaxDatumSize, Type)
def _MacroParser(self, String): TokenList = GetSplitValueList(String, ' ', 1) if len(TokenList) < 2 or TokenList[1] == '': self._LoggerError(ST.ERR_DECPARSE_MACRO_PAIR) TokenList = GetSplitValueList(TokenList[1], DT.TAB_EQUAL_SPLIT, 1) if TokenList[0] == '': self._LoggerError(ST.ERR_DECPARSE_MACRO_NAME) elif not IsValidToken(MACRO_PATTERN, TokenList[0]): self._LoggerError(ST.ERR_DECPARSE_MACRO_NAME_UPPER % TokenList[0]) if len(TokenList) == 1: self._LocalMacro[TokenList[0]] = '' else: self._LocalMacro[TokenList[0]] = self._ReplaceMacro(TokenList[1])
def SetPcdName(PcdItem, CurrentLineOfPcdItem, PcdItemObj): # # Only PCD Name specified # <PcdName> ::= <TokenSpaceGuidCName> "." <TokenCName> # PcdId = GetSplitValueList(PcdItem[0], DT.TAB_SPLIT) if len(PcdId) != 2: Logger.Error("InfParser", ToolError.FORMAT_INVALID, ST.ERR_INF_PARSER_PCD_NAME_FORMAT_ERROR, File=CurrentLineOfPcdItem[2], Line=CurrentLineOfPcdItem[1], ExtraData=CurrentLineOfPcdItem[0]) else: # # Validate PcdTokenSpaceGuidCName # if not IsValidCVariableName(PcdId[0]): Logger.Error("InfParser", ToolError.FORMAT_INVALID, ST.ERR_INF_PARSER_PCD_CVAR_GUID, File=CurrentLineOfPcdItem[2], Line=CurrentLineOfPcdItem[1], ExtraData=PcdId[0]) if not IsValidCVariableName(PcdId[1]): Logger.Error("InfParser", ToolError.FORMAT_INVALID, ST.ERR_INF_PARSER_PCD_CVAR_PCDCNAME, File=CurrentLineOfPcdItem[2], Line=CurrentLineOfPcdItem[1], ExtraData=PcdId[1]) PcdItemObj.SetTokenSpaceGuidCName(PcdId[0]) PcdItemObj.SetCName(PcdId[1]) return PcdItemObj
def _ParseItem(self): Line = self._RawData.CurrentLine TokenList = GetSplitValueList(Line, DT.TAB_VALUE_SPLIT) if len(TokenList) != 2: self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_SPLIT) if TokenList[0] == '' or TokenList[1] == '': self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_EMPTY) if not IsValidToken('[A-Z][0-9A-Za-z]*', TokenList[0]): self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_LIB) self._CheckReDefine(TokenList[0]) Value = TokenList[1] # # Must end with .h # if not Value.endswith('.h'): self._LoggerError(ST.ERR_DECPARSE_LIBCLASS_PATH_EXT) # # Path must be existed # if not IsValidPath(Value, self._RawData.PackagePath): self._LoggerError(ST.ERR_DECPARSE_INCLUDE % Value) Item = DecLibraryclassItemObject( TokenList[0], StripRoot(self._RawData.PackagePath, Value), self._RawData.PackagePath) self.ItemObject.AddItem(Item, self._RawData.CurrentScope) return Item
def SetSpecification(self, Specification, Comments): # # Valid the value of Specification # __ValueList = [] TokenList = GetSplitValueList(Specification, DT.TAB_EQUAL_SPLIT, 1) __ValueList[0:len(TokenList)] = TokenList if len(__ValueList) != 2: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_NO_NAME + ' Or ' + ST.ERR_INF_PARSER_DEFINE_ITEM_NO_VALUE, LineInfo=self.CurrentLine) Name = __ValueList[0].strip() Version = __ValueList[1].strip() if IsValidIdentifier(Name): if IsValidDecVersion(Version): self.Specification.append((Name, Version, Comments)) return True else: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (Version), LineInfo=self.CurrentLine) return False else: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (Name), LineInfo=self.CurrentLine) return False return True
def SetUnloadImages(self, UnloadImages, Comments): # # It can be a list # ValueList = [] TokenList = GetSplitValueList(UnloadImages, DT.TAB_VALUE_SPLIT) ValueList[0:len(TokenList)] = TokenList InfDefineUnloadImageItemObj = InfDefineUnloadImageItem() if not IsValidCVariableName(ValueList[0]): ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ValueList[0]), LineInfo=self.CurrentLine) InfDefineUnloadImageItemObj.SetCName(ValueList[0]) if len(ValueList) == 2: if ValueList[1].strip() == '': ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ValueList[1]), LineInfo=self.CurrentLine) # # Validate FFE # FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[1].strip()) if not FeatureFlagRtv[0]: ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]), LineInfo=self.CurrentLine) InfDefineUnloadImageItemObj.SetFeatureFlagExp(ValueList[1]) if len(ValueList) > 2: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (UnloadImages), LineInfo=self.CurrentLine) InfDefineUnloadImageItemObj.Comments = Comments self.UnloadImages.append(InfDefineUnloadImageItemObj)
def GenTailCommentLines(TailCommentLines, LeadingSpaceNum=0): TailCommentLines = TailCommentLines.rstrip(END_OF_LINE) CommentStr = TAB_SPACE_SPLIT*2 + TAB_SPECIAL_COMMENT + TAB_SPACE_SPLIT + \ (END_OF_LINE + LeadingSpaceNum * TAB_SPACE_SPLIT + TAB_SPACE_SPLIT*2 + TAB_SPECIAL_COMMENT + \ TAB_SPACE_SPLIT).join(GetSplitValueList(TailCommentLines, END_OF_LINE)) return CommentStr
def IsValidBuildOptionName(BuildOptionName): if not BuildOptionName: return False ToolOptionList = GetSplitValueList(BuildOptionName, '_', 4) if len(ToolOptionList) != 5: return False ReIsValidBuildOption1 = re.compile(r"^\s*(\*)|([A-Z][a-zA-Z0-9]*)$") ReIsValidBuildOption2 = re.compile(r"^\s*(\*)|([a-zA-Z][a-zA-Z0-9]*)$") if ReIsValidBuildOption1.match(ToolOptionList[0]) is None: return False if ReIsValidBuildOption1.match(ToolOptionList[1]) is None: return False if ReIsValidBuildOption2.match(ToolOptionList[2]) is None: return False if ToolOptionList[3] == "*" and ToolOptionList[4] not in [ 'FAMILY', 'DLL', 'DPATH' ]: return False return True
def GenGenericComment(CommentLines): if not CommentLines: return '' CommentLines = CommentLines.rstrip(END_OF_LINE) CommentStr = TAB_SPECIAL_COMMENT + TAB_SPACE_SPLIT + (END_OF_LINE + TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT).join\ (GetSplitValueList(CommentLines, END_OF_LINE)) + END_OF_LINE return CommentStr
def ParserPcdInfoInDec(String): ValueList = GetSplitValueList(String, DT.TAB_VALUE_SPLIT, 3) # # DatumType, Token # return ValueList[2], ValueList[3]
def GetDynamicHiiPcd(Item, Type, ContainerFile, LineNo= -1): TokenGuid, TokenName, List1, List2, List3, List4, List5 = \ '', '', '', '', '', '', '' List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT * 2) if len(List) < 6 or len(List) > 8: RaiseParserError(Item, 'Pcds' + Type, ContainerFile, \ '<PcdTokenSpaceGuidCName>.<TokenCName>|<String>|\ <VariableGuidCName>|<VariableOffset>[|<DefaultValue>\ [|<MaximumDatumSize>]]', LineNo) else: List1, List2, List3, List4, List5 = \ List[1], List[2], List[3], List[4], List[5] if CheckPcdTokenInfo(List[0], 'Pcds' + Type, ContainerFile, LineNo): (TokenGuid, TokenName) = GetSplitValueList(List[0], DataType.TAB_SPLIT) return (TokenName, TokenGuid, List1, List2, List3, List4, List5, Type)
def testErrorCase2(self): TestCommentLines = \ ''' ## @file # Abstract # this is invalid line # Description # # Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR> # License # ##''' CommentList = GetSplitValueList(TestCommentLines, "\n") LineNum = 0 TestCommentLinesList = [] for Comment in CommentList: LineNum += 1 TestCommentLinesList.append((Comment, LineNum)) self.assertRaises(Logger.FatalError, ParseHeaderCommentSection, TestCommentLinesList, "PhonyFile")
def MacroParser(Line, FileName, SectionType, FileLocalMacros): MacroDefPattern = re.compile("^(DEFINE)[ \t]+") LineContent = Line[0] LineNo = Line[1] Match = MacroDefPattern.match(LineContent) if not Match: # # Not 'DEFINE/EDK_GLOBAL' statement, call decorated method # return None, None TokenList = GetSplitValueList(LineContent[Match.end(1):], \ DataType.TAB_EQUAL_SPLIT, 1) # # Syntax check # if not TokenList[0]: Logger.Error('Parser', FORMAT_INVALID, ST.ERR_MACRONAME_NOGIVEN, ExtraData=LineContent, File=FileName, Line=LineNo) if len(TokenList) < 2: Logger.Error('Parser', FORMAT_INVALID, ST.ERR_MACROVALUE_NOGIVEN, ExtraData=LineContent, File=FileName, Line=LineNo) Name, Value = TokenList # # DEFINE defined macros # if SectionType == DataType.MODEL_META_DATA_HEADER: FileLocalMacros[Name] = Value ReIsValidMacroName = re.compile(r"^[A-Z][A-Z0-9_]*$", re.DOTALL) if ReIsValidMacroName.match(Name) is None: Logger.Error('Parser', FORMAT_INVALID, ST.ERR_MACRONAME_INVALID % (Name), ExtraData=LineContent, File=FileName, Line=LineNo) # Validate MACRO Value # # <MacroDefinition> ::= [<Comments>]{0,} # "DEFINE" <MACRO> "=" [{<PATH>} {<VALUE>}] <EOL> # <Value> ::= {<NumVal>} {<Boolean>} {<AsciiString>} {<GUID>} # {<CString>} {<UnicodeString>} {<CArray>} # # The definition of <NumVal>, <PATH>, <Boolean>, <GUID>, <CString>, # <UnicodeString>, <CArray> are subset of <AsciiString>. # ReIsValidMacroValue = re.compile(r"^[\x20-\x7e]*$", re.DOTALL) if ReIsValidMacroValue.match(Value) is None: Logger.Error('Parser', FORMAT_INVALID, ST.ERR_MACROVALUE_INVALID % (Value), ExtraData=LineContent, File=FileName, Line=LineNo) return Name, Value
def _CheckSectionHeaders(self, Line, LineNo): if len(self.SectionHeaderContent) == 0: Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_SECTION_HEADER_INVALID, File=self.FullPath, Line=LineNo, ExtraData=Line) else: for SectionItem in self.SectionHeaderContent: ArchList = [] # # Not cover Depex/UserExtension section header # check. # if SectionItem[0].strip().upper() == DT.TAB_INF_FIXED_PCD.upper() or \ SectionItem[0].strip().upper() == DT.TAB_INF_PATCH_PCD.upper() or \ SectionItem[0].strip().upper() == DT.TAB_INF_PCD_EX.upper() or \ SectionItem[0].strip().upper() == DT.TAB_INF_PCD.upper() or \ SectionItem[0].strip().upper() == DT.TAB_INF_FEATURE_PCD.upper(): ArchList = GetSplitValueList(SectionItem[1].strip(), ' ') else: ArchList = [SectionItem[1].strip()] for Arch in ArchList: if (not IsValidArch(Arch)) and \ (SectionItem[0].strip().upper() != DT.TAB_DEPEX.upper()) and \ (SectionItem[0].strip().upper() != DT.TAB_USER_EXTENSIONS.upper()) and \ (SectionItem[0].strip().upper() != DT.TAB_COMMON_DEFINES.upper()): Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(SectionItem[1]), File=self.FullPath, Line=LineNo, ExtraData=Line) # # Check if the ModuleType is valid # ChkModSectionList = ['LIBRARYCLASSES'] if (self.SectionHeaderContent[0][0].upper() in ChkModSectionList): if SectionItem[2].strip().upper(): MoudleTypeList = GetSplitValueList( SectionItem[2].strip().upper()) if (not IsValidInfMoudleTypeList(MoudleTypeList)): Logger.Error("InfParser", FORMAT_INVALID, ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(SectionItem[2]), File=self.FullPath, Line=LineNo, ExtraData=Line)
def SetDestructor(self, Destructor, Comments): # # It can be a list and only 1 set to TRUE # ValueList = [] TokenList = GetSplitValueList(Destructor, DT.TAB_VALUE_SPLIT) ValueList[0:len(TokenList)] = TokenList InfDefineDestructorItemObj = InfDefineDestructorItem() if not IsValidCVariableName(ValueList[0]): ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ValueList[0]), LineInfo=self.CurrentLine) InfDefineDestructorItemObj.SetCName(ValueList[0]) if len(ValueList) >= 2: ModList = GetSplitValueList(ValueList[1].strip(), ' ') if ValueList[1].strip() == '': ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ValueList[1]), LineInfo=self.CurrentLine) for ModItem in ModList: if ModItem not in DT.MODULE_LIST: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID % (ModItem), LineInfo=self.CurrentLine) InfDefineDestructorItemObj.SetSupModList(ModList) if len(ValueList) == 3: if ValueList[2].strip() == '': ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ValueList[2]), LineInfo=self.CurrentLine) # # Validate FFE # FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[2].strip()) if not FeatureFlagRtv[0]: ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]), LineInfo=self.CurrentLine) InfDefineDestructorItemObj.SetFeatureFlagExp(ValueList[2]) if len(ValueList) > 3: ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (Destructor), LineInfo=self.CurrentLine) InfDefineDestructorItemObj.Comments = Comments self.Destructor.append(InfDefineDestructorItemObj)
def CheckPcdTokenInfo(TokenInfoString, Section, File, LineNo= -1): Format = '<TokenSpaceGuidCName>.<PcdCName>' if TokenInfoString != '' and TokenInfoString is not None: TokenInfoList = GetSplitValueList(TokenInfoString, DataType.TAB_SPLIT) if len(TokenInfoList) == 2: return True RaiseParserError(TokenInfoString, Section, File, Format, LineNo)
def GetPcdOfDec(Item, Type, File, LineNo= -1): Format = '<TokenSpaceGuidCName>.<PcdCName>|<Value>|<DatumType>|<Token>' TokenGuid, TokenName, Value, DatumType, Token = '', '', '', '', '' List = GetSplitValueList(Item) if len(List) != 4: RaiseParserError(Item, 'Pcds' + Type, File, Format, LineNo) else: Value = List[1] DatumType = List[2] Token = List[3] TokenInfo = GetSplitValueList(List[0], DataType.TAB_SPLIT) if len(TokenInfo) != 2: RaiseParserError(Item, 'Pcds' + Type, File, Format, LineNo) else: TokenGuid = TokenInfo[0] TokenName = TokenInfo[1] return (TokenGuid, TokenName, Value, DatumType, Token, Type)
def GetPackage(Item, ContainerFile, FileRelativePath, LineNo= -1): ItemNew = Item + DataType.TAB_VALUE_SPLIT List = GetSplitValueList(ItemNew) CheckFileType(List[0], '.Dec', ContainerFile, 'package', List[0], LineNo) CheckFileExist(FileRelativePath, List[0], ContainerFile, 'Packages', \ List[0], LineNo) if List[1] != '': CheckPcdTokenInfo(List[1], 'Packages', ContainerFile, LineNo) return (List[0], List[1])
def GenSection(SectionName, SectionDict, SplitArch=True, NeedBlankLine=False): Content = '' for SectionAttrs in SectionDict: StatementList = SectionDict[SectionAttrs] if SectionAttrs and SectionName != 'Defines' and SectionAttrs.strip().upper() != DataType.TAB_ARCH_COMMON: if SplitArch: ArchList = GetSplitValueList(SectionAttrs, DataType.TAB_SPACE_SPLIT) else: if SectionName != 'UserExtensions': ArchList = GetSplitValueList(SectionAttrs, DataType.TAB_COMMENT_SPLIT) else: ArchList = [SectionAttrs] for Index in range(0, len(ArchList)): ArchList[Index] = ConvertArchForInstall(ArchList[Index]) Section = '[' + SectionName + '.' + (', ' + SectionName + '.').join(ArchList) + ']' else: Section = '[' + SectionName + ']' Content += '\n' + Section + '\n' if StatementList is not None: for Statement in StatementList: LineList = Statement.split('\n') NewStatement = "" for Line in LineList: # ignore blank comment if not Line.replace("#", '').strip() and SectionName not in ('Defines', 'Hob', 'Event', 'BootMode'): continue # add two space before non-comments line except the comments in Defines section if Line.strip().startswith('#') and SectionName == 'Defines': NewStatement += "%s\n" % Line continue NewStatement += " %s\n" % Line if NeedBlankLine: Content += NewStatement + '\n' else: Content += NewStatement if NeedBlankLine: Content = Content[:-1] if not Content.replace('\\n', '').strip(): return '' return Content
def ParseDefine(LineValue, StartLine, Table, FileID, SectionName, \ SectionModel, Arch): Logger.Debug(Logger.DEBUG_2, ST.MSG_DEFINE_STATEMENT_FOUND % (LineValue, \ SectionName)) Define = \ GetSplitValueList(CleanString\ (LineValue[LineValue.upper().\ find(DataType.TAB_DEFINE.upper() + ' ') + \ len(DataType.TAB_DEFINE + ' ') : ]), \ DataType.TAB_EQUAL_SPLIT, 1) Table.Insert(DataType.MODEL_META_DATA_DEFINE, Define[0], Define[1], '', \ '', '', Arch, SectionModel, FileID, StartLine, -1, \ StartLine, -1, 0)
def GenHeaderCommentSection(Abstract, Description, Copyright, License, IsBinaryHeader=False, \ CommChar=TAB_COMMENT_SPLIT): Content = '' # # Convert special character to (c), (r) and (tm). # Abstract = ConvertSpecialUnicodes(Abstract) Description = ConvertSpecialUnicodes(Description) if IsBinaryHeader: Content += CommChar * 2 + TAB_SPACE_SPLIT + TAB_BINARY_HEADER_COMMENT + '\r\n' elif CommChar == TAB_COMMENT_EDK1_SPLIT: Content += CommChar + TAB_SPACE_SPLIT + TAB_COMMENT_EDK1_START + TAB_STAR + TAB_SPACE_SPLIT +\ TAB_HEADER_COMMENT + '\r\n' else: Content += CommChar * 2 + TAB_SPACE_SPLIT + TAB_HEADER_COMMENT + '\r\n' if Abstract: Abstract = Abstract.rstrip('\r\n') Content += CommChar + TAB_SPACE_SPLIT + ('\r\n' + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\ (Abstract, '\n')) Content += '\r\n' + CommChar + '\r\n' else: Content += CommChar + '\r\n' if Description: Description = Description.rstrip('\r\n') Content += CommChar + TAB_SPACE_SPLIT + ('\r\n' + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\ (Description, '\n')) Content += '\r\n' + CommChar + '\r\n' # # There is no '#\n' line to separate multiple copyright lines in code base # if Copyright: Copyright = Copyright.rstrip('\r\n') Content += CommChar + TAB_SPACE_SPLIT + ('\r\n' + CommChar + TAB_SPACE_SPLIT).join\ (GetSplitValueList(Copyright, '\n')) Content += '\r\n' + CommChar + '\r\n' if License: License = License.rstrip('\r\n') Content += CommChar + TAB_SPACE_SPLIT + ('\r\n' + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\ (License, '\n')) Content += '\r\n' + CommChar + '\r\n' if CommChar == TAB_COMMENT_EDK1_SPLIT: Content += CommChar + TAB_SPACE_SPLIT + TAB_STAR + TAB_COMMENT_EDK1_END + '\r\n' else: Content += CommChar * 2 + '\r\n' return Content
def GetBinary(Item, ContainerFile, LineNo= -1): ItemNew = Item + DataType.TAB_VALUE_SPLIT List = GetSplitValueList(ItemNew) if len(List) < 3 or len(List) > 5: RaiseParserError(Item, 'Binaries', ContainerFile, \ "<FileType>|<Filename>[|<Target>\ [|<TokenSpaceGuidCName>.<PcdCName>]]", LineNo) if len(List) >= 4: if List[3] != '': CheckPcdTokenInfo(List[3], 'Binaries', ContainerFile, LineNo) return (List[0], List[1], List[2], List[3]) elif len(List) == 3: return (List[0], List[1], List[2], '')