BaseTools/Source/Python/UPT/Object/Parser/InfDefineObject.py

   1 ## @file
   2 # This file is used to define class objects of [Defines] section for INF file.
   3 # It will consumed by InfParser
   4 #
   5 # Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>
   6 #
   7 # SPDX-License-Identifier: BSD-2-Clause-Patent
   8
   9 '''
  10 InfDefineObject
  11 '''
  12
  13 import os
  14 import re
  15
  16 from Logger import StringTable as ST
  17 from Logger import ToolError
  18 from Library import GlobalData
  19 from Library import DataType as DT
  20 from Library.StringUtils import GetSplitValueList
  21 from Library.Misc import CheckGuidRegFormat
  22 from Library.Misc import Sdict
  23 from Library.Misc import ConvPathFromAbsToRel
  24 from Library.Misc import ValidateUNIFilePath
  25 from Library.ExpressionValidate import IsValidFeatureFlagExp
  26 from Library.ParserValidate import IsValidWord
  27 from Library.ParserValidate import IsValidInfMoudleType
  28 from Library.ParserValidate import IsValidHex
  29 from Library.ParserValidate import IsValidHexVersion
  30 from Library.ParserValidate import IsValidDecVersion
  31 from Library.ParserValidate import IsValidCVariableName
  32 from Library.ParserValidate import IsValidBoolType
  33 from Library.ParserValidate import IsValidPath
  34 from Library.ParserValidate import IsValidFamily
  35 from Library.ParserValidate import IsValidIdentifier
  36 from Library.ParserValidate import IsValidDecVersionVal
  37 from Object.Parser.InfCommonObject import InfLineCommentObject
  38 from Object.Parser.InfCommonObject import CurrentLine
  39 from Object.Parser.InfCommonObject import InfSectionCommonDef
  40 from Object.Parser.InfMisc import ErrorInInf
  41 from Object.Parser.InfDefineCommonObject import InfDefineLibraryItem
  42 from Object.Parser.InfDefineCommonObject import InfDefineEntryPointItem
  43 from Object.Parser.InfDefineCommonObject import InfDefineUnloadImageItem
  44 from Object.Parser.InfDefineCommonObject import InfDefineConstructorItem
  45 from Object.Parser.InfDefineCommonObject import InfDefineDestructorItem
  46
  47 class InfDefSectionOptionRomInfo():
  48     def __init__(self):
  49         self.PciVendorId                = None
  50         self.PciDeviceId                = None
  51         self.PciClassCode               = None
  52         self.PciRevision                = None
  53         self.PciCompress                = None
  54         self.CurrentLine                = ['', -1, '']
  55     def SetPciVendorId(self, PciVendorId, Comments):
  56         #
  57         # Value has been set before.
  58         #
  59         if self.PciVendorId is not None:
  60             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_VENDOR_ID),
  61                        LineInfo=self.CurrentLine)
  62             return False
  63         #
  64         # The PciVendorId should be hex string.
  65         #
  66         if (IsValidHex(PciVendorId)):
  67             self.PciVendorId = InfDefMember()
  68             self.PciVendorId.SetValue(PciVendorId)
  69             self.PciVendorId.Comments = Comments
  70             return True
  71         else:
  72             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciVendorId),
  73                        LineInfo=self.CurrentLine)
  74             return False
  75
  76     def GetPciVendorId(self):
  77         return self.PciVendorId
  78
  79     def SetPciDeviceId(self, PciDeviceId, Comments):
  80         #
  81         # Value has been set before.
  82         #
  83         if self.PciDeviceId is not None:
  84             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_DEVICE_ID),
  85                        LineInfo=self.CurrentLine)
  86             return False
  87         #
  88         # The PciDeviceId should be hex string.
  89         #
  90         if (IsValidHex(PciDeviceId)):
  91             self.PciDeviceId = InfDefMember()
  92             self.PciDeviceId.SetValue(PciDeviceId)
  93             self.PciDeviceId.Comments = Comments
  94             return True
  95         else:
  96             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciDeviceId),
  97                        LineInfo=self.CurrentLine)
  98             return False
  99
 100     def GetPciDeviceId(self):
 101         return self.PciDeviceId
 102
 103     def SetPciClassCode(self, PciClassCode, Comments):
 104         #
 105         # Value has been set before.
 106         #
 107         if self.PciClassCode is not None:
 108             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_CLASS_CODE),
 109                        LineInfo=self.CurrentLine)
 110             return False
 111         #
 112         # The PciClassCode should be 4 bytes hex string.
 113         #
 114         if (IsValidHex(PciClassCode)):
 115             self.PciClassCode = InfDefMember()
 116             self.PciClassCode.SetValue(PciClassCode)
 117             self.PciClassCode.Comments = Comments
 118             return True
 119         else:
 120             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
 121                        (PciClassCode),
 122                        LineInfo=self.CurrentLine)
 123             return False
 124
 125     def GetPciClassCode(self):
 126         return self.PciClassCode
 127
 128     def SetPciRevision(self, PciRevision, Comments):
 129         #
 130         # Value has been set before.
 131         #
 132         if self.PciRevision is not None:
 133             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_REVISION),
 134                        LineInfo=self.CurrentLine)
 135             return False
 136         #
 137         # The PciRevision should be 4 bytes hex string.
 138         #
 139         if (IsValidHex(PciRevision)):
 140             self.PciRevision = InfDefMember()
 141             self.PciRevision.SetValue(PciRevision)
 142             self.PciRevision.Comments = Comments
 143             return True
 144         else:
 145             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciRevision),
 146                        LineInfo=self.CurrentLine)
 147             return False
 148
 149     def GetPciRevision(self):
 150         return self.PciRevision
 151
 152     def SetPciCompress(self, PciCompress, Comments):
 153         #
 154         # Value has been set before.
 155         #
 156         if self.PciCompress is not None:
 157             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_PCI_COMPRESS),
 158                        LineInfo=self.CurrentLine)
 159             return False
 160
 161         #
 162         # The PciCompress should be 'TRUE' or 'FALSE'.
 163         #
 164         if (PciCompress == 'TRUE' or PciCompress == 'FALSE'):
 165             self.PciCompress = InfDefMember()
 166             self.PciCompress.SetValue(PciCompress)
 167             self.PciCompress.Comments = Comments
 168             return True
 169         else:
 170             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PciCompress),
 171                        LineInfo=self.CurrentLine)
 172             return False
 173     def GetPciCompress(self):
 174         return self.PciCompress
 175 ##
 176 # INF [Define] section Object
 177 #
 178 class InfDefSection(InfDefSectionOptionRomInfo):
 179     def __init__(self):
 180         self.BaseName                   = None
 181         self.FileGuid                   = None
 182         self.ModuleType                 = None
 183         self.ModuleUniFileName          = None
 184         self.InfVersion                 = None
 185         self.EdkReleaseVersion          = None
 186         self.UefiSpecificationVersion   = None
 187         self.PiSpecificationVersion     = None
 188         self.LibraryClass               = []
 189         self.Package                    = None
 190         self.VersionString              = None
 191         self.PcdIsDriver                = None
 192         self.EntryPoint                 = []
 193         self.UnloadImages               = []
 194         self.Constructor                = []
 195         self.Destructor                 = []
 196         self.Shadow                     = None
 197         self.CustomMakefile             = []
 198         self.Specification              = []
 199         self.UefiHiiResourceSection     = None
 200         self.DpxSource                  = []
 201         self.CurrentLine                = ['', -1, '']
 202         InfDefSectionOptionRomInfo.__init__(self)
 203
 204     ## SetHeadComment
 205     #
 206     # @param BaseName: BaseName
 207     #
 208     def SetBaseName(self, BaseName, Comments):
 209         #
 210         # Value has been set before.
 211         #
 212         if self.BaseName is not None:
 213             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_BASE_NAME),
 214                        LineInfo=self.CurrentLine)
 215             return False
 216         if not (BaseName == '' or BaseName is None):
 217             if IsValidWord(BaseName) and not BaseName.startswith("_"):
 218                 self.BaseName = InfDefMember()
 219                 self.BaseName.SetValue(BaseName)
 220                 self.BaseName.Comments = Comments
 221                 return True
 222             else:
 223                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_NAME_INVALID%(BaseName),
 224                            LineInfo=self.CurrentLine)
 225                 return False
 226
 227     ## GetBaseName
 228     #
 229     def GetBaseName(self):
 230         return self.BaseName
 231
 232     ## SetFileGuid
 233     #
 234     # @param FileGuid: FileGuid
 235     #
 236     def SetFileGuid(self, FileGuid, Comments):
 237         #
 238         # Value has been set before.
 239         #
 240         if self.FileGuid is not None:
 241             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 242                        %(DT.TAB_INF_DEFINES_FILE_GUID),
 243                        LineInfo=self.CurrentLine)
 244             return False
 245         #
 246         # Do verification of GUID content/format
 247         #
 248         if (CheckGuidRegFormat(FileGuid)):
 249             self.FileGuid = InfDefMember()
 250             self.FileGuid.SetValue(FileGuid)
 251             self.FileGuid.Comments = Comments
 252             return True
 253         else:
 254             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_GUID_INVALID%(FileGuid),
 255                        LineInfo=self.CurrentLine)
 256             return False
 257
 258     ## GetFileGuid
 259     #
 260     def GetFileGuid(self):
 261         return self.FileGuid
 262
 263     ## SetModuleType
 264     #
 265     # @param ModuleType: ModuleType
 266     #
 267     def SetModuleType(self, ModuleType, Comments):
 268         #
 269         # Value has been set before.
 270         #
 271         if self.ModuleType is not None:
 272             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 273                        %(DT.TAB_INF_DEFINES_MODULE_TYPE),
 274                        LineInfo=self.CurrentLine)
 275             return False
 276         #
 277         # Valid Module Type or not
 278         #
 279         if (IsValidInfMoudleType(ModuleType)):
 280             self.ModuleType = InfDefMember()
 281             self.ModuleType.SetValue(ModuleType)
 282             self.ModuleType.CurrentLine = CurrentLine()
 283             self.ModuleType.CurrentLine.SetLineNo(self.CurrentLine[1])
 284             self.ModuleType.CurrentLine.SetLineString(self.CurrentLine[2])
 285             self.ModuleType.CurrentLine.SetFileName(self.CurrentLine[0])
 286             self.ModuleType.Comments = Comments
 287             return True
 288         else:
 289             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%\
 290                        (ModuleType),
 291                        LineInfo=self.CurrentLine)
 292             return False
 293
 294     ## GetModuleType
 295     #
 296     def GetModuleType(self):
 297         return self.ModuleType
 298
 299     ## SetModuleUniFileName
 300     #
 301     # @param ModuleUniFileName: ModuleUniFileName
 302     #
 303     def SetModuleUniFileName(self, ModuleUniFileName, Comments):
 304         if Comments:
 305             pass
 306         if self.ModuleUniFileName is not None:
 307             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_MODULE_UNI_FILE),
 308                        LineInfo=self.CurrentLine)
 309         self.ModuleUniFileName = ModuleUniFileName
 310
 311     ## GetModuleType
 312     #
 313     def GetModuleUniFileName(self):
 314         return self.ModuleUniFileName
 315
 316     ## SetInfVersion
 317     #
 318     # @param InfVersion: InfVersion
 319     #
 320     def SetInfVersion(self, InfVersion, Comments):
 321         #
 322         # Value has been set before.
 323         #
 324         if self.InfVersion is not None:
 325             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 326                        %(DT.TAB_INF_DEFINES_INF_VERSION),
 327                        LineInfo=self.CurrentLine)
 328             return False
 329         #
 330         # The InfVersion should be 4 bytes hex string.
 331         #
 332         if (IsValidHex(InfVersion)):
 333             if (InfVersion < '0x00010005'):
 334                 ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
 335                            ErrorCode=ToolError.EDK1_INF_ERROR,
 336                            LineInfo=self.CurrentLine)
 337         elif IsValidDecVersionVal(InfVersion):
 338             if (InfVersion < 65541):
 339                 ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
 340                            ErrorCode=ToolError.EDK1_INF_ERROR,
 341                            LineInfo=self.CurrentLine)
 342         else:
 343             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(InfVersion),
 344                        LineInfo=self.CurrentLine)
 345             return False
 346
 347         self.InfVersion = InfDefMember()
 348         self.InfVersion.SetValue(InfVersion)
 349         self.InfVersion.Comments = Comments
 350         return True
 351
 352     ## GetInfVersion
 353     #
 354     def GetInfVersion(self):
 355         return self.InfVersion
 356
 357     ## SetEdkReleaseVersion
 358     #
 359     # @param EdkReleaseVersion: EdkReleaseVersion
 360     #
 361     def SetEdkReleaseVersion(self, EdkReleaseVersion, Comments):
 362         #
 363         # Value has been set before.
 364         #
 365         if self.EdkReleaseVersion is not None:
 366             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 367                        %(DT.TAB_INF_DEFINES_EDK_RELEASE_VERSION),
 368                        LineInfo=self.CurrentLine)
 369             return False
 370         #
 371         # The EdkReleaseVersion should be 4 bytes hex string.
 372         #
 373         if IsValidHexVersion(EdkReleaseVersion) or \
 374            IsValidDecVersionVal(EdkReleaseVersion):
 375             self.EdkReleaseVersion = InfDefMember()
 376             self.EdkReleaseVersion.SetValue(EdkReleaseVersion)
 377             self.EdkReleaseVersion.Comments = Comments
 378             return True
 379         else:
 380             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
 381                        %(EdkReleaseVersion),
 382                        LineInfo=self.CurrentLine)
 383             return False
 384
 385     ## GetEdkReleaseVersion
 386     #
 387     def GetEdkReleaseVersion(self):
 388         return self.EdkReleaseVersion
 389
 390     ## SetUefiSpecificationVersion
 391     #
 392     # @param UefiSpecificationVersion: UefiSpecificationVersion
 393     #
 394     def SetUefiSpecificationVersion(self, UefiSpecificationVersion, Comments):
 395         #
 396         # Value has been set before.
 397         #
 398         if self.UefiSpecificationVersion is not None:
 399             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 400                        %(DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION),
 401                        LineInfo=self.CurrentLine)
 402             return False
 403         #
 404         # The EdkReleaseVersion should be 4 bytes hex string.
 405         #
 406         if IsValidHexVersion(UefiSpecificationVersion) or \
 407            IsValidDecVersionVal(UefiSpecificationVersion):
 408             self.UefiSpecificationVersion = InfDefMember()
 409             self.UefiSpecificationVersion.SetValue(UefiSpecificationVersion)
 410             self.UefiSpecificationVersion.Comments = Comments
 411             return True
 412         else:
 413             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
 414                        %(UefiSpecificationVersion),
 415                        LineInfo=self.CurrentLine)
 416             return False
 417
 418     ## GetUefiSpecificationVersion
 419     #
 420     def GetUefiSpecificationVersion(self):
 421         return self.UefiSpecificationVersion
 422
 423     ## SetPiSpecificationVersion
 424     #
 425     # @param PiSpecificationVersion: PiSpecificationVersion
 426     #
 427     def SetPiSpecificationVersion(self, PiSpecificationVersion, Comments):
 428         #
 429         # Value has been set before.
 430         #
 431         if self.PiSpecificationVersion is not None:
 432             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 433                        %(DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION),
 434                        LineInfo=self.CurrentLine)
 435             return False
 436         #
 437         # The EdkReleaseVersion should be 4 bytes hex string.
 438         #
 439         if IsValidHexVersion(PiSpecificationVersion) or \
 440            IsValidDecVersionVal(PiSpecificationVersion):
 441             self.PiSpecificationVersion = InfDefMember()
 442             self.PiSpecificationVersion.SetValue(PiSpecificationVersion)
 443             self.PiSpecificationVersion.Comments = Comments
 444             return True
 445         else:
 446             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
 447                        %(PiSpecificationVersion),
 448                        LineInfo=self.CurrentLine)
 449             return False
 450
 451     ## GetPiSpecificationVersion
 452     #
 453     def GetPiSpecificationVersion(self):
 454         return self.PiSpecificationVersion
 455
 456     ## SetLibraryClass
 457     #
 458     # @param LibraryClass: LibraryClass
 459     #
 460     def SetLibraryClass(self, LibraryClass, Comments):
 461         ValueList = GetSplitValueList(LibraryClass)
 462         Name = ValueList[0]
 463         if IsValidWord(Name):
 464             InfDefineLibraryItemObj = InfDefineLibraryItem()
 465             InfDefineLibraryItemObj.SetLibraryName(Name)
 466             InfDefineLibraryItemObj.Comments = Comments
 467             if len(ValueList) == 2:
 468                 Type = ValueList[1]
 469                 TypeList = GetSplitValueList(Type, ' ')
 470                 TypeList = [Type for Type in TypeList if Type != '']
 471                 for Item in TypeList:
 472                     if Item not in DT.MODULE_LIST:
 473                         ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Item),
 474                                    LineInfo=self.CurrentLine)
 475                         return False
 476                 InfDefineLibraryItemObj.SetTypes(TypeList)
 477             self.LibraryClass.append(InfDefineLibraryItemObj)
 478         else:
 479             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Name),
 480                        LineInfo=self.CurrentLine)
 481             return False
 482
 483         return True
 484
 485     def GetLibraryClass(self):
 486         return self.LibraryClass
 487
 488     def SetVersionString(self, VersionString, Comments):
 489         #
 490         # Value has been set before.
 491         #
 492         if self.VersionString is not None:
 493             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 494                        %(DT.TAB_INF_DEFINES_VERSION_STRING),
 495                        LineInfo=self.CurrentLine)
 496             return False
 497         if not IsValidDecVersion(VersionString):
 498             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID\
 499                        %(VersionString),
 500                        LineInfo=self.CurrentLine)
 501         self.VersionString = InfDefMember()
 502         self.VersionString.SetValue(VersionString)
 503         self.VersionString.Comments = Comments
 504         return True
 505
 506
 507     def GetVersionString(self):
 508         return self.VersionString
 509
 510     def SetPcdIsDriver(self, PcdIsDriver, Comments):
 511         #
 512         # Value has been set before.
 513         #
 514         if self.PcdIsDriver is not None:
 515             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND\
 516                        %(DT.TAB_INF_DEFINES_PCD_IS_DRIVER),
 517                        LineInfo=self.CurrentLine)
 518             return False
 519         if PcdIsDriver == 'PEI_PCD_DRIVER' or PcdIsDriver == 'DXE_PCD_DRIVER':
 520             self.PcdIsDriver = InfDefMember()
 521             self.PcdIsDriver.SetValue(PcdIsDriver)
 522             self.PcdIsDriver.Comments = Comments
 523             return True
 524         else:
 525             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(PcdIsDriver),
 526                        LineInfo=self.CurrentLine)
 527             return False
 528
 529     def GetPcdIsDriver(self):
 530         return self.PcdIsDriver
 531
 532     #
 533     # SetEntryPoint
 534     #
 535     def SetEntryPoint(self, EntryPoint, Comments):
 536         #
 537         # It can be a list
 538         #
 539         ValueList = []
 540         TokenList = GetSplitValueList(EntryPoint, DT.TAB_VALUE_SPLIT)
 541         ValueList[0:len(TokenList)] = TokenList
 542         InfDefineEntryPointItemObj = InfDefineEntryPointItem()
 543         if not IsValidCVariableName(ValueList[0]):
 544             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
 545                        (ValueList[0]),
 546                        LineInfo=self.CurrentLine)
 547         InfDefineEntryPointItemObj.SetCName(ValueList[0])
 548         if len(ValueList) == 2:
 549             if ValueList[1].strip() == '':
 550                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\
 551                            (ValueList[1]),
 552                            LineInfo=self.CurrentLine)
 553             #
 554             # Validate FFE
 555             #
 556             FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[1].strip())
 557             if not FeatureFlagRtv[0]:
 558                 ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%\
 559                            (FeatureFlagRtv[1]),
 560                            LineInfo=self.CurrentLine)
 561             InfDefineEntryPointItemObj.SetFeatureFlagExp(ValueList[1])
 562         if len(ValueList) > 2:
 563             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(EntryPoint),
 564                        LineInfo=self.CurrentLine)
 565         InfDefineEntryPointItemObj.Comments = Comments
 566         self.EntryPoint.append(InfDefineEntryPointItemObj)
 567
 568     def GetEntryPoint(self):
 569         return self.EntryPoint
 570
 571     #
 572     # SetUnloadImages
 573     #
 574     def SetUnloadImages(self, UnloadImages, Comments):
 575         #
 576         # It can be a list
 577         #
 578         ValueList = []
 579         TokenList = GetSplitValueList(UnloadImages, DT.TAB_VALUE_SPLIT)
 580         ValueList[0:len(TokenList)] = TokenList
 581         InfDefineUnloadImageItemObj = InfDefineUnloadImageItem()
 582         if not IsValidCVariableName(ValueList[0]):
 583             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
 584                        LineInfo=self.CurrentLine)
 585         InfDefineUnloadImageItemObj.SetCName(ValueList[0])
 586         if len(ValueList) == 2:
 587             if ValueList[1].strip() == '':
 588                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
 589                            LineInfo=self.CurrentLine)
 590             #
 591             # Validate FFE
 592             #
 593             FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[1].strip())
 594             if not FeatureFlagRtv[0]:
 595                 ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[1]),
 596                            LineInfo=self.CurrentLine)
 597             InfDefineUnloadImageItemObj.SetFeatureFlagExp(ValueList[1])
 598
 599         if len(ValueList) > 2:
 600             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(UnloadImages),
 601                        LineInfo=self.CurrentLine)
 602         InfDefineUnloadImageItemObj.Comments = Comments
 603         self.UnloadImages.append(InfDefineUnloadImageItemObj)
 604
 605     def GetUnloadImages(self):
 606         return self.UnloadImages
 607
 608     #
 609     # SetConstructor
 610     #
 611     def SetConstructor(self, Constructor, Comments):
 612         #
 613         # It can be a list
 614         #
 615         ValueList = []
 616         TokenList = GetSplitValueList(Constructor, DT.TAB_VALUE_SPLIT)
 617         ValueList[0:len(TokenList)] = TokenList
 618         InfDefineConstructorItemObj = InfDefineConstructorItem()
 619         if not IsValidCVariableName(ValueList[0]):
 620             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
 621                        LineInfo=self.CurrentLine)
 622         InfDefineConstructorItemObj.SetCName(ValueList[0])
 623         if len(ValueList) >= 2:
 624             ModList = GetSplitValueList(ValueList[1], ' ')
 625             if ValueList[1].strip() == '':
 626                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
 627                            LineInfo=self.CurrentLine)
 628             for ModItem in ModList:
 629                 if ModItem not in DT.MODULE_LIST:
 630                     ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%(ModItem),
 631                                LineInfo=self.CurrentLine)
 632             InfDefineConstructorItemObj.SetSupModList(ModList)
 633         if len(ValueList) == 3:
 634             if ValueList[2].strip() == '':
 635                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[2]),
 636                            LineInfo=self.CurrentLine)
 637             #
 638             # Validate FFE
 639             #
 640             FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[2].strip())
 641             if not FeatureFlagRtv[0]:
 642                 ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[2]),
 643                            LineInfo=self.CurrentLine)
 644             InfDefineConstructorItemObj.SetFeatureFlagExp(ValueList[2])
 645
 646         if len(ValueList) > 3:
 647             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Constructor),
 648                        LineInfo=self.CurrentLine)
 649         InfDefineConstructorItemObj.Comments = Comments
 650         self.Constructor.append(InfDefineConstructorItemObj)
 651
 652     def GetConstructor(self):
 653         return self.Constructor
 654
 655     #
 656     # SetDestructor
 657     #
 658     def SetDestructor(self, Destructor, Comments):
 659         #
 660         # It can be a list and only 1 set to TRUE
 661         #
 662         ValueList = []
 663         TokenList = GetSplitValueList(Destructor, DT.TAB_VALUE_SPLIT)
 664         ValueList[0:len(TokenList)] = TokenList
 665         InfDefineDestructorItemObj = InfDefineDestructorItem()
 666         if not IsValidCVariableName(ValueList[0]):
 667             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),
 668                        LineInfo=self.CurrentLine)
 669         InfDefineDestructorItemObj.SetCName(ValueList[0])
 670         if len(ValueList) >= 2:
 671             ModList = GetSplitValueList(ValueList[1].strip(), ' ')
 672             if ValueList[1].strip() == '':
 673                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[1]),
 674                            LineInfo=self.CurrentLine)
 675             for ModItem in ModList:
 676                 if ModItem not in DT.MODULE_LIST:
 677                     ErrorInInf(ST.ERR_INF_PARSER_DEFINE_MODULETYPE_INVALID%(ModItem),
 678                                LineInfo=self.CurrentLine)
 679             InfDefineDestructorItemObj.SetSupModList(ModList)
 680         if len(ValueList) == 3:
 681             if ValueList[2].strip() == '':
 682                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[2]),
 683                            LineInfo=self.CurrentLine)
 684             #
 685             # Validate FFE
 686             #
 687             FeatureFlagRtv = IsValidFeatureFlagExp(ValueList[2].strip())
 688             if not FeatureFlagRtv[0]:
 689                 ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[1]),
 690                            LineInfo=self.CurrentLine)
 691             InfDefineDestructorItemObj.SetFeatureFlagExp(ValueList[2])
 692
 693         if len(ValueList) > 3:
 694             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Destructor),
 695                        LineInfo=self.CurrentLine)
 696
 697         InfDefineDestructorItemObj.Comments = Comments
 698         self.Destructor.append(InfDefineDestructorItemObj)
 699
 700     def GetDestructor(self):
 701         return self.Destructor
 702
 703     def SetShadow(self, Shadow, Comments):
 704         #
 705         # Value has been set before.
 706         #
 707         if self.Shadow is not None:
 708             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_SHADOW),
 709                        LineInfo=self.CurrentLine)
 710             return False
 711         if (IsValidBoolType(Shadow)):
 712             self.Shadow = InfDefMember()
 713             self.Shadow.SetValue(Shadow)
 714             self.Shadow.Comments = Comments
 715             return True
 716         else:
 717             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Shadow),
 718                        LineInfo=self.CurrentLine)
 719             return False
 720     def GetShadow(self):
 721         return self.Shadow
 722
 723     #
 724     # <Family>               ::=  {"MSFT"} {"GCC"}
 725     # <CustomMake>           ::=  [<Family> "|"] <Filename>
 726     #
 727     def SetCustomMakefile(self, CustomMakefile, Comments):
 728         if not (CustomMakefile == '' or CustomMakefile is None):
 729             ValueList = GetSplitValueList(CustomMakefile)
 730             if len(ValueList) == 1:
 731                 FileName = ValueList[0]
 732                 Family = ''
 733             else:
 734                 Family = ValueList[0]
 735                 FileName = ValueList[1]
 736             Family = Family.strip()
 737             if Family != '':
 738                 if not IsValidFamily(Family):
 739                     ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Family),
 740                                LineInfo=self.CurrentLine)
 741                     return False
 742             #
 743             # The MakefileName specified file should exist
 744             #
 745             IsValidFileFlag = False
 746             ModulePath = os.path.split(self.CurrentLine[0])[0]
 747             if IsValidPath(FileName, ModulePath):
 748                 IsValidFileFlag = True
 749             else:
 750                 ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(FileName),
 751                            LineInfo=self.CurrentLine)
 752                 return False
 753             if IsValidFileFlag:
 754                 FileName = ConvPathFromAbsToRel(FileName, GlobalData.gINF_MODULE_DIR)
 755                 self.CustomMakefile.append((Family, FileName, Comments))
 756                 IsValidFileFlag = False
 757             return True
 758         else:
 759             return False
 760
 761     def GetCustomMakefile(self):
 762         return self.CustomMakefile
 763
 764     #
 765     # ["SPEC" <Spec> <EOL>]*{0,}
 766     # <Spec>                 ::=  <Word> "=" <VersionVal>
 767     # <VersionVal>           ::=  {<HexVersion>] {<DecVersion>}
 768     # <HexNumber>            ::=  "0x" [<HexDigit>]{1,}
 769     # <DecVersion>           ::=  (0-9){1,} ["." (0-9){1,2}]
 770     #
 771     def SetSpecification(self, Specification, Comments):
 772         #
 773         # Valid the value of Specification
 774         #
 775         __ValueList = []
 776         TokenList = GetSplitValueList(Specification, DT.TAB_EQUAL_SPLIT, 1)
 777         __ValueList[0:len(TokenList)] = TokenList
 778         if len(__ValueList) != 2:
 779             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_NO_NAME + ' Or ' + ST.ERR_INF_PARSER_DEFINE_ITEM_NO_VALUE,
 780                        LineInfo=self.CurrentLine)
 781         Name = __ValueList[0].strip()
 782         Version = __ValueList[1].strip()
 783         if IsValidIdentifier(Name):
 784             if IsValidDecVersion(Version):
 785                 self.Specification.append((Name, Version, Comments))
 786                 return True
 787             else:
 788                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Version),
 789                            LineInfo=self.CurrentLine)
 790                 return False
 791         else:
 792             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Name),
 793                        LineInfo=self.CurrentLine)
 794             return False
 795         return True
 796
 797     def GetSpecification(self):
 798         return self.Specification
 799
 800     #
 801     # [<UefiHiiResource> <EOL>]{0,1}
 802     # <UefiHiiResource>      ::=  "UEFI_HII_RESOURCE_SECTION" "=" <BoolType>
 803     #
 804     def SetUefiHiiResourceSection(self, UefiHiiResourceSection, Comments):
 805         #
 806         # Value has been set before.
 807         #
 808         if self.UefiHiiResourceSection is not None:
 809             ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND
 810                        %(DT.TAB_INF_DEFINES_UEFI_HII_RESOURCE_SECTION),
 811                        LineInfo=self.CurrentLine)
 812             return False
 813         if not (UefiHiiResourceSection == '' or UefiHiiResourceSection is None):
 814             if (IsValidBoolType(UefiHiiResourceSection)):
 815                 self.UefiHiiResourceSection = InfDefMember()
 816                 self.UefiHiiResourceSection.SetValue(UefiHiiResourceSection)
 817                 self.UefiHiiResourceSection.Comments = Comments
 818                 return True
 819             else:
 820                 ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(UefiHiiResourceSection),
 821                            LineInfo=self.CurrentLine)
 822                 return False
 823         else:
 824             return False
 825
 826     def GetUefiHiiResourceSection(self):
 827         return self.UefiHiiResourceSection
 828
 829     def SetDpxSource(self, DpxSource, Comments):
 830         #
 831         # The MakefileName specified file should exist
 832         #
 833         IsValidFileFlag = False
 834         ModulePath = os.path.split(self.CurrentLine[0])[0]
 835         if IsValidPath(DpxSource, ModulePath):
 836             IsValidFileFlag = True
 837         else:
 838             ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(DpxSource),
 839                        LineInfo=self.CurrentLine)
 840             return False
 841         if IsValidFileFlag:
 842             DpxSource = ConvPathFromAbsToRel(DpxSource,
 843                             GlobalData.gINF_MODULE_DIR)
 844             self.DpxSource.append((DpxSource, Comments))
 845             IsValidFileFlag = False
 846         return True
 847
 848     def GetDpxSource(self):
 849         return self.DpxSource
 850
 851 gFUNCTION_MAPPING_FOR_DEFINE_SECTION = {
 852     #
 853     # Required Fields
 854     #
 855     DT.TAB_INF_DEFINES_BASE_NAME                   : InfDefSection.SetBaseName,
 856     DT.TAB_INF_DEFINES_FILE_GUID                   : InfDefSection.SetFileGuid,
 857     DT.TAB_INF_DEFINES_MODULE_TYPE                 : InfDefSection.SetModuleType,
 858     #
 859     # Required by EDKII style INF file
 860     #
 861     DT.TAB_INF_DEFINES_INF_VERSION                 : InfDefSection.SetInfVersion,
 862     #
 863     # Optional Fields
 864     #
 865     DT.TAB_INF_DEFINES_MODULE_UNI_FILE             : InfDefSection.SetModuleUniFileName,
 866     DT.TAB_INF_DEFINES_EDK_RELEASE_VERSION         : InfDefSection.SetEdkReleaseVersion,
 867     DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION  : InfDefSection.SetUefiSpecificationVersion,
 868     DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION    : InfDefSection.SetPiSpecificationVersion,
 869     DT.TAB_INF_DEFINES_LIBRARY_CLASS               : InfDefSection.SetLibraryClass,
 870     DT.TAB_INF_DEFINES_VERSION_STRING              : InfDefSection.SetVersionString,
 871     DT.TAB_INF_DEFINES_PCD_IS_DRIVER               : InfDefSection.SetPcdIsDriver,
 872     DT.TAB_INF_DEFINES_ENTRY_POINT                 : InfDefSection.SetEntryPoint,
 873     DT.TAB_INF_DEFINES_UNLOAD_IMAGE                : InfDefSection.SetUnloadImages,
 874     DT.TAB_INF_DEFINES_CONSTRUCTOR                 : InfDefSection.SetConstructor,
 875     DT.TAB_INF_DEFINES_DESTRUCTOR                  : InfDefSection.SetDestructor,
 876     DT.TAB_INF_DEFINES_SHADOW                      : InfDefSection.SetShadow,
 877     DT.TAB_INF_DEFINES_PCI_VENDOR_ID               : InfDefSection.SetPciVendorId,
 878     DT.TAB_INF_DEFINES_PCI_DEVICE_ID               : InfDefSection.SetPciDeviceId,
 879     DT.TAB_INF_DEFINES_PCI_CLASS_CODE              : InfDefSection.SetPciClassCode,
 880     DT.TAB_INF_DEFINES_PCI_REVISION                : InfDefSection.SetPciRevision,
 881     DT.TAB_INF_DEFINES_PCI_COMPRESS                : InfDefSection.SetPciCompress,
 882     DT.TAB_INF_DEFINES_CUSTOM_MAKEFILE             : InfDefSection.SetCustomMakefile,
 883     DT.TAB_INF_DEFINES_SPEC                        : InfDefSection.SetSpecification,
 884     DT.TAB_INF_DEFINES_UEFI_HII_RESOURCE_SECTION   : InfDefSection.SetUefiHiiResourceSection,
 885     DT.TAB_INF_DEFINES_DPX_SOURCE                  : InfDefSection.SetDpxSource
 886 }
 887
 888 ## InfDefMember
 889 #
 890 #
 891 class InfDefMember():
 892     def __init__(self, Name='', Value=''):
 893         self.Comments = InfLineCommentObject()
 894         self.Name  = Name
 895         self.Value = Value
 896         self.CurrentLine = CurrentLine()
 897     def GetName(self):
 898         return self.Name
 899     def SetName(self, Name):
 900         self.Name = Name
 901     def GetValue(self):
 902         return self.Value
 903     def SetValue(self, Value):
 904         self.Value = Value
 905
 906 ## InfDefObject
 907 #
 908 #
 909 class InfDefObject(InfSectionCommonDef):
 910     def __init__(self):
 911         self.Defines = Sdict()
 912         InfSectionCommonDef.__init__(self)
 913     def SetDefines(self, DefineContent, Arch = None):
 914         #
 915         # Validate Arch
 916         #
 917         HasFoundInfVersionFalg = False
 918         LineInfo = ['', -1, '']
 919         ArchListString = ' '.join(Arch)
 920         #
 921         # Parse Define items.
 922         #
 923         for InfDefMemberObj in DefineContent:
 924             ProcessFunc = None
 925             Name = InfDefMemberObj.GetName()
 926             Value = InfDefMemberObj.GetValue()
 927             if Name == DT.TAB_INF_DEFINES_MODULE_UNI_FILE:
 928                 ValidateUNIFilePath(Value)
 929                 Value = os.path.join(os.path.dirname(InfDefMemberObj.CurrentLine.FileName), Value)
 930                 if not os.path.isfile(Value) or not os.path.exists(Value):
 931                     LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
 932                     LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
 933                     LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
 934                     ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Name),
 935                                    LineInfo=LineInfo)
 936             InfLineCommentObj = InfLineCommentObject()
 937             InfLineCommentObj.SetHeaderComments(InfDefMemberObj.Comments.GetHeaderComments())
 938             InfLineCommentObj.SetTailComments(InfDefMemberObj.Comments.GetTailComments())
 939             if Name == 'COMPONENT_TYPE':
 940                 ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
 941                            ErrorCode=ToolError.EDK1_INF_ERROR,
 942                            RaiseError=True)
 943             if Name == DT.TAB_INF_DEFINES_INF_VERSION:
 944                 HasFoundInfVersionFalg = True
 945             if not (Name == '' or Name is None):
 946                 #
 947                 # Process "SPEC" Keyword definition.
 948                 #
 949                 ReName = re.compile(r"SPEC ", re.DOTALL)
 950                 if ReName.match(Name):
 951                     SpecValue = Name[Name.find("SPEC") + len("SPEC"):].strip()
 952                     Name = "SPEC"
 953                     Value = SpecValue + " = " + Value
 954                 if ArchListString in self.Defines:
 955                     DefineList = self.Defines[ArchListString]
 956                     LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
 957                     LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
 958                     LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
 959                     DefineList.CurrentLine = LineInfo
 960                     #
 961                     # Found the process function from mapping table.
 962                     #
 963                     if Name not in gFUNCTION_MAPPING_FOR_DEFINE_SECTION.keys():
 964                         ErrorInInf(ST.ERR_INF_PARSER_DEFINE_SECTION_KEYWORD_INVALID%(Name),
 965                                    LineInfo=LineInfo)
 966                     else:
 967                         ProcessFunc = gFUNCTION_MAPPING_FOR_DEFINE_SECTION[Name]
 968                     if (ProcessFunc is not None):
 969                         ProcessFunc(DefineList, Value, InfLineCommentObj)
 970                     self.Defines[ArchListString] = DefineList
 971                 else:
 972                     DefineList = InfDefSection()
 973                     LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()
 974                     LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()
 975                     LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()
 976                     DefineList.CurrentLine = LineInfo
 977                     #
 978                     # Found the process function from mapping table.
 979                     #
 980                     if Name not in gFUNCTION_MAPPING_FOR_DEFINE_SECTION.keys():
 981                         ErrorInInf(ST.ERR_INF_PARSER_DEFINE_SECTION_KEYWORD_INVALID%(Name),
 982                                    LineInfo=LineInfo)
 983                     #
 984                     # Found the process function from mapping table.
 985                     #
 986                     else:
 987                         ProcessFunc = gFUNCTION_MAPPING_FOR_DEFINE_SECTION[Name]
 988                     if (ProcessFunc is not None):
 989                         ProcessFunc(DefineList, Value, InfLineCommentObj)
 990                     self.Defines[ArchListString] = DefineList
 991         #
 992         # After set, check whether INF_VERSION defined.
 993         #
 994         if not HasFoundInfVersionFalg:
 995             ErrorInInf(ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF,
 996                        ErrorCode=ToolError.EDK1_INF_ERROR,
 997                        RaiseError=True)
 998         return True
 999
1000     def GetDefines(self):
1001         return self.Defines
1002