1## @file
2# This file is used to define class objects of INF file [Binaries] section.
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'''
10InfBinaryObject
11'''
12
13import os
14
15from copy import deepcopy
16from Library import DataType as DT
17from Library import GlobalData
18import Logger.Log as Logger
19from Logger import ToolError
20from Logger import StringTable as ST
21from Library.Misc import Sdict
22
23from Object.Parser.InfCommonObject import InfSectionCommonDef
24from Object.Parser.InfCommonObject import CurrentLine
25from Library.Misc import ConvPathFromAbsToRel
26from Library.ExpressionValidate import IsValidFeatureFlagExp
27from Library.Misc import ValidFile
28from Library.ParserValidate import IsValidPath
29
30
31class InfBianryItem():
32    def __init__(self):
33        self.FileName = ''
34        self.Target = ''
35        self.FeatureFlagExp = ''
36        self.HelpString = ''
37        self.Type = ''
38        self.SupArchList = []
39
40    def SetFileName(self, FileName):
41        self.FileName = FileName
42    def GetFileName(self):
43        return self.FileName
44
45    def SetTarget(self, Target):
46        self.Target = Target
47    def GetTarget(self):
48        return self.Target
49
50    def SetFeatureFlagExp(self, FeatureFlagExp):
51        self.FeatureFlagExp = FeatureFlagExp
52    def GetFeatureFlagExp(self):
53        return self.FeatureFlagExp
54
55    def SetHelpString(self, HelpString):
56        self.HelpString = HelpString
57    def GetHelpString(self):
58        return self.HelpString
59
60    def SetType(self, Type):
61        self.Type = Type
62    def GetType(self):
63        return self.Type
64    def SetSupArchList(self, SupArchList):
65        self.SupArchList = SupArchList
66    def GetSupArchList(self):
67        return self.SupArchList
68
69class InfBianryVerItem(InfBianryItem, CurrentLine):
70    def __init__(self):
71        InfBianryItem.__init__(self)
72        CurrentLine.__init__(self)
73        self.VerTypeName = ''
74
75    def SetVerTypeName(self, VerTypeName):
76        self.VerTypeName = VerTypeName
77    def GetVerTypeName(self):
78        return self.VerTypeName
79
80class InfBianryUiItem(InfBianryItem, CurrentLine):
81    def __init__(self):
82        InfBianryItem.__init__(self)
83        CurrentLine.__init__(self)
84        self.UiTypeName = ''
85
86    def SetUiTypeName(self, UiTypeName):
87        self.UiTypeName = UiTypeName
88    def GetVerTypeName(self):
89        return self.UiTypeName
90
91class InfBianryCommonItem(InfBianryItem, CurrentLine):
92    def __init__(self):
93        self.CommonType = ''
94        self.TagName = ''
95        self.Family = ''
96        self.GuidValue = ''
97        InfBianryItem.__init__(self)
98        CurrentLine.__init__(self)
99
100    def SetCommonType(self, CommonType):
101        self.CommonType = CommonType
102    def GetCommonType(self):
103        return self.CommonType
104
105    def SetTagName(self, TagName):
106        self.TagName = TagName
107    def GetTagName(self):
108        return self.TagName
109
110    def SetFamily(self, Family):
111        self.Family = Family
112    def GetFamily(self):
113        return self.Family
114
115    def SetGuidValue(self, GuidValue):
116        self.GuidValue = GuidValue
117    def GetGuidValue(self):
118        return self.GuidValue
119
120##
121#
122#
123#
124class InfBinariesObject(InfSectionCommonDef):
125    def __init__(self):
126        self.Binaries = Sdict()
127        #
128        # Macro defined in this section should be only used in this section.
129        #
130        self.Macros = {}
131        InfSectionCommonDef.__init__(self)
132
133    ## CheckVer
134    #
135    #
136    def CheckVer(self, Ver, __SupArchList):
137        #
138        # Check Ver
139        #
140        for VerItem in Ver:
141            IsValidFileFlag = False
142            VerContent = VerItem[0]
143            VerComment = VerItem[1]
144            VerCurrentLine = VerItem[2]
145            GlobalData.gINF_CURRENT_LINE = VerCurrentLine
146            InfBianryVerItemObj = None
147            #
148            # Should not less than 2 elements
149            #
150            if len(VerContent) < 2:
151                Logger.Error("InfParser",
152                             ToolError.FORMAT_INVALID,
153                             ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (VerContent[0], 2),
154                             File=VerCurrentLine.GetFileName(),
155                             Line=VerCurrentLine.GetLineNo(),
156                             ExtraData=VerCurrentLine.GetLineString())
157                return False
158            if len(VerContent) > 4:
159                Logger.Error("InfParser",
160                             ToolError.FORMAT_INVALID,
161                             ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (VerContent[0], 4),
162                             File=VerCurrentLine.GetFileName(),
163                             Line=VerCurrentLine.GetLineNo(),
164                             ExtraData=VerCurrentLine.GetLineString())
165                return False
166            if len(VerContent) >= 2:
167                #
168                # Create a Ver Object.
169                #
170                InfBianryVerItemObj = InfBianryVerItem()
171
172                if VerContent[0] != DT.BINARY_FILE_TYPE_VER:
173                    Logger.Error("InfParser",
174                                 ToolError.FORMAT_INVALID,
175                                 ST.ERR_INF_PARSER_BINARY_VER_TYPE % DT.BINARY_FILE_TYPE_VER,
176                                 File=VerCurrentLine.GetFileName(),
177                                 Line=VerCurrentLine.GetLineNo(),
178                                 ExtraData=VerCurrentLine.GetLineString())
179
180                InfBianryVerItemObj.SetVerTypeName(VerContent[0])
181                InfBianryVerItemObj.SetType(VerContent[0])
182                #
183                # Verify File exist or not
184                #
185                FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
186                                                                              VerContent[1])))
187                if not (ValidFile(FullFileName) or ValidFile(VerContent[1])):
188                    Logger.Error("InfParser",
189                                 ToolError.FORMAT_INVALID,
190                                 ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (VerContent[1]),
191                                 File=VerCurrentLine.GetFileName(),
192                                 Line=VerCurrentLine.GetLineNo(),
193                                 ExtraData=VerCurrentLine.GetLineString())
194                #
195                # Validate file exist/format.
196                #
197                if IsValidPath(VerContent[1], GlobalData.gINF_MODULE_DIR):
198                    IsValidFileFlag = True
199                else:
200                    Logger.Error("InfParser",
201                                 ToolError.FORMAT_INVALID,
202                                 ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (VerContent[1]),
203                                 File=VerCurrentLine.GetFileName(),
204                                 Line=VerCurrentLine.GetLineNo(),
205                                 ExtraData=VerCurrentLine.GetLineString())
206                    return False
207                if IsValidFileFlag:
208                    VerContent[0] = ConvPathFromAbsToRel(VerContent[0],
209                                            GlobalData.gINF_MODULE_DIR)
210                    InfBianryVerItemObj.SetFileName(VerContent[1])
211            if len(VerContent) >= 3:
212                #
213                # Add Target information
214                #
215                InfBianryVerItemObj.SetTarget(VerContent[2])
216            if len(VerContent) == 4:
217                if VerContent[3].strip() == '':
218                    Logger.Error("InfParser",
219                                 ToolError.FORMAT_INVALID,
220                                 ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
221                                 File=VerCurrentLine.GetFileName(),
222                                 Line=VerCurrentLine.GetLineNo(),
223                                 ExtraData=VerCurrentLine.GetLineString())
224                #
225                # Validate Feature Flag Express
226                #
227                FeatureFlagRtv = IsValidFeatureFlagExp(VerContent[3].\
228                                                       strip())
229                if not FeatureFlagRtv[0]:
230                    Logger.Error("InfParser",
231                                 ToolError.FORMAT_INVALID,
232                                 ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
233                                 File=VerCurrentLine.GetFileName(),
234                                 Line=VerCurrentLine.GetLineNo(),
235                                 ExtraData=VerCurrentLine.GetLineString())
236                InfBianryVerItemObj.SetFeatureFlagExp(VerContent[3])
237
238            InfBianryVerItemObj.SetSupArchList(__SupArchList)
239
240            #
241            # Determine binary file name duplicate. Follow below rule:
242            #
243            # A binary filename must not be duplicated within
244            # a [Binaries] section. A binary filename may appear in
245            # multiple architectural [Binaries] sections. A binary
246            # filename listed in an architectural [Binaries] section
247            # must not be listed in the common architectural
248            # [Binaries] section.
249            #
250            # NOTE: This check will not report error now.
251            #
252            for Item in self.Binaries:
253                if Item.GetFileName() == InfBianryVerItemObj.GetFileName():
254                    ItemSupArchList = Item.GetSupArchList()
255                    for ItemArch in ItemSupArchList:
256                        for VerItemObjArch in __SupArchList:
257                            if ItemArch == VerItemObjArch:
258                                #
259                                # ST.ERR_INF_PARSER_ITEM_DUPLICATE
260                                #
261                                pass
262                            if ItemArch.upper() == 'COMMON' or VerItemObjArch.upper() == 'COMMON':
263                                #
264                                # ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
265                                #
266                                pass
267
268            if InfBianryVerItemObj is not None:
269                if (InfBianryVerItemObj) in self.Binaries:
270                    BinariesList = self.Binaries[InfBianryVerItemObj]
271                    BinariesList.append((InfBianryVerItemObj, VerComment))
272                    self.Binaries[InfBianryVerItemObj] = BinariesList
273                else:
274                    BinariesList = []
275                    BinariesList.append((InfBianryVerItemObj, VerComment))
276                    self.Binaries[InfBianryVerItemObj] = BinariesList
277
278    ## ParseCommonBinary
279    #
280    # ParseCommonBinary
281    #
282    def ParseCommonBinary(self, CommonBinary, __SupArchList):
283        #
284        # Check common binary definitions
285        # Type | FileName | Target | Family | TagName | FeatureFlagExp
286        #
287        for Item in CommonBinary:
288            IsValidFileFlag = False
289            ItemContent = Item[0]
290            ItemComment = Item[1]
291            CurrentLineOfItem = Item[2]
292            GlobalData.gINF_CURRENT_LINE = CurrentLineOfItem
293            InfBianryCommonItemObj = None
294            if ItemContent[0] == 'SUBTYPE_GUID':
295                if len(ItemContent) < 3:
296                    Logger.Error("InfParser",
297                                 ToolError.FORMAT_INVALID,
298                                 ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 3),
299                                 File=CurrentLineOfItem.GetFileName(),
300                                 Line=CurrentLineOfItem.GetLineNo(),
301                                 ExtraData=CurrentLineOfItem.GetLineString())
302                    return False
303            else:
304                if len(ItemContent) < 2:
305                    Logger.Error("InfParser",
306                                 ToolError.FORMAT_INVALID,
307                                 ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 2),
308                                 File=CurrentLineOfItem.GetFileName(),
309                                 Line=CurrentLineOfItem.GetLineNo(),
310                                 ExtraData=CurrentLineOfItem.GetLineString())
311                    return False
312
313            if len(ItemContent) > 7:
314                Logger.Error("InfParser",
315                             ToolError.FORMAT_INVALID,
316                             ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (ItemContent[0], 7),
317                             File=CurrentLineOfItem.GetFileName(),
318                             Line=CurrentLineOfItem.GetLineNo(),
319                             ExtraData=CurrentLineOfItem.GetLineString())
320                return False
321            if len(ItemContent) >= 2:
322                #
323                # Create a Common Object.
324                #
325                InfBianryCommonItemObj = InfBianryCommonItem()
326                #
327                # Convert Binary type.
328                #
329                BinaryFileType = ItemContent[0].strip()
330                if BinaryFileType == 'RAW' or BinaryFileType == 'ACPI' or BinaryFileType == 'ASL':
331                    BinaryFileType = 'BIN'
332
333                if BinaryFileType not in DT.BINARY_FILE_TYPE_LIST:
334                    Logger.Error("InfParser",
335                                 ToolError.FORMAT_INVALID,
336                                 ST.ERR_INF_PARSER_BINARY_ITEM_INVALID_FILETYPE % \
337                                 (DT.BINARY_FILE_TYPE_LIST.__str__()),
338                                 File=CurrentLineOfItem.GetFileName(),
339                                 Line=CurrentLineOfItem.GetLineNo(),
340                                 ExtraData=CurrentLineOfItem.GetLineString())
341
342                if BinaryFileType == 'SUBTYPE_GUID':
343                    BinaryFileType = 'FREEFORM'
344
345                if BinaryFileType == 'LIB' or BinaryFileType == 'UEFI_APP':
346                    Logger.Error("InfParser",
347                                 ToolError.FORMAT_INVALID,
348                                 ST.ERR_INF_PARSER_BINARY_ITEM_INVALID_FILETYPE % \
349                                 (DT.BINARY_FILE_TYPE_LIST.__str__()),
350                                 File=CurrentLineOfItem.GetFileName(),
351                                 Line=CurrentLineOfItem.GetLineNo(),
352                                 ExtraData=CurrentLineOfItem.GetLineString())
353
354                InfBianryCommonItemObj.SetType(BinaryFileType)
355                InfBianryCommonItemObj.SetCommonType(ItemContent[0])
356                FileName = ''
357                if BinaryFileType == 'FREEFORM':
358                    InfBianryCommonItemObj.SetGuidValue(ItemContent[1])
359                    if len(ItemContent) >= 3:
360                        FileName = ItemContent[2]
361                    else:
362                        Logger.Error("InfParser",
363                                 ToolError.FORMAT_INVALID,
364                                 ST.ERR_INF_PARSER_BINARY_ITEM_FILENAME_NOT_EXIST,
365                                 File=CurrentLineOfItem.GetFileName(),
366                                 Line=CurrentLineOfItem.GetLineNo(),
367                                 ExtraData=CurrentLineOfItem.GetLineString())
368                else:
369                    FileName = ItemContent[1]
370                #
371                # Verify File exist or not
372                #
373                FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
374                                                                              FileName)))
375                if not (ValidFile(FullFileName) or ValidFile(FileName)):
376                    Logger.Error("InfParser",
377                                 ToolError.FORMAT_INVALID,
378                                 ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (FileName),
379                                 File=CurrentLineOfItem.GetFileName(),
380                                 Line=CurrentLineOfItem.GetLineNo(),
381                                 ExtraData=CurrentLineOfItem.GetLineString())
382                #
383                # Validate file exist/format.
384                #
385                if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):
386                    IsValidFileFlag = True
387                else:
388                    Logger.Error("InfParser",
389                                ToolError.FORMAT_INVALID,
390                                ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (FileName),
391                                File=CurrentLineOfItem.GetFileName(),
392                                Line=CurrentLineOfItem.GetLineNo(),
393                                ExtraData=CurrentLineOfItem.GetLineString())
394                    return False
395                if IsValidFileFlag:
396                    ItemContent[0] = ConvPathFromAbsToRel(ItemContent[0], GlobalData.gINF_MODULE_DIR)
397                    InfBianryCommonItemObj.SetFileName(FileName)
398            if len(ItemContent) >= 3:
399                #
400                # Add Target information
401                #
402                if BinaryFileType != 'FREEFORM':
403                    InfBianryCommonItemObj.SetTarget(ItemContent[2])
404
405            if len(ItemContent) >= 4:
406                #
407                # Add Family information
408                #
409                if BinaryFileType != 'FREEFORM':
410                    InfBianryCommonItemObj.SetFamily(ItemContent[3])
411                else:
412                    InfBianryCommonItemObj.SetTarget(ItemContent[3])
413
414            if len(ItemContent) >= 5:
415                #
416                # TagName entries are build system specific. If there
417                # is content in the entry, the tool must exit
418                # gracefully with an error message that indicates build
419                # system specific content cannot be distributed using
420                # the UDP
421                #
422                if BinaryFileType != 'FREEFORM':
423                    if ItemContent[4].strip() != '':
424                        Logger.Error("InfParser",
425                                     ToolError.FORMAT_INVALID,
426                                     ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[4]),
427                                     File=CurrentLineOfItem.GetFileName(),
428                                     Line=CurrentLineOfItem.GetLineNo(),
429                                     ExtraData=CurrentLineOfItem.GetLineString())
430                else:
431                    InfBianryCommonItemObj.SetFamily(ItemContent[4])
432
433            if len(ItemContent) >= 6:
434                #
435                # Add FeatureFlagExp
436                #
437                if BinaryFileType != 'FREEFORM':
438                    if ItemContent[5].strip() == '':
439                        Logger.Error("InfParser",
440                                     ToolError.FORMAT_INVALID,
441                                     ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
442                                     File=CurrentLineOfItem.GetFileName(),
443                                     Line=CurrentLineOfItem.GetLineNo(),
444                                     ExtraData=CurrentLineOfItem.GetLineString())
445                    #
446                    # Validate Feature Flag Express
447                    #
448                    FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[5].strip())
449                    if not FeatureFlagRtv[0]:
450                        Logger.Error("InfParser",
451                                     ToolError.FORMAT_INVALID,
452                                     ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
453                                     File=CurrentLineOfItem.GetFileName(),
454                                     Line=CurrentLineOfItem.GetLineNo(),
455                                     ExtraData=CurrentLineOfItem.GetLineString())
456                    InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[5])
457                else:
458                    if ItemContent[5].strip() != '':
459                        Logger.Error("InfParser",
460                                     ToolError.FORMAT_INVALID,
461                                     ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[5]),
462                                     File=CurrentLineOfItem.GetFileName(),
463                                     Line=CurrentLineOfItem.GetLineNo(),
464                                     ExtraData=CurrentLineOfItem.GetLineString())
465
466            if len(ItemContent) == 7:
467                if ItemContent[6].strip() == '':
468                    Logger.Error("InfParser",
469                                     ToolError.FORMAT_INVALID,
470                                     ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
471                                     File=CurrentLineOfItem.GetFileName(),
472                                     Line=CurrentLineOfItem.GetLineNo(),
473                                     ExtraData=CurrentLineOfItem.GetLineString())
474                #
475                # Validate Feature Flag Express
476                #
477                FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[6].strip())
478                if not FeatureFlagRtv[0]:
479                    Logger.Error("InfParser",
480                                 ToolError.FORMAT_INVALID,
481                                 ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
482                                 File=CurrentLineOfItem.GetFileName(),
483                                 Line=CurrentLineOfItem.GetLineNo(),
484                                 ExtraData=CurrentLineOfItem.GetLineString())
485                InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[6])
486
487            InfBianryCommonItemObj.SetSupArchList(__SupArchList)
488
489            #
490            # Determine binary file name duplicate. Follow below rule:
491            #
492            # A binary filename must not be duplicated within
493            # a [Binaries] section. A binary filename may appear in
494            # multiple architectural [Binaries] sections. A binary
495            # filename listed in an architectural [Binaries] section
496            # must not be listed in the common architectural
497            # [Binaries] section.
498            #
499            # NOTE: This check will not report error now.
500            #
501#            for Item in self.Binaries:
502#                if Item.GetFileName() == InfBianryCommonItemObj.GetFileName():
503#                    ItemSupArchList = Item.GetSupArchList()
504#                    for ItemArch in ItemSupArchList:
505#                        for ComItemObjArch in __SupArchList:
506#                            if ItemArch == ComItemObjArch:
507#                                #
508#                                # ST.ERR_INF_PARSER_ITEM_DUPLICATE
509#                                #
510#                                pass
511#
512#                            if ItemArch.upper() == 'COMMON' or ComItemObjArch.upper() == 'COMMON':
513#                                #
514#                                # ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
515#                                #
516#                                pass
517
518            if InfBianryCommonItemObj is not None:
519                if (InfBianryCommonItemObj) in self.Binaries:
520                    BinariesList = self.Binaries[InfBianryCommonItemObj]
521                    BinariesList.append((InfBianryCommonItemObj, ItemComment))
522                    self.Binaries[InfBianryCommonItemObj] = BinariesList
523                else:
524                    BinariesList = []
525                    BinariesList.append((InfBianryCommonItemObj, ItemComment))
526                    self.Binaries[InfBianryCommonItemObj] = BinariesList
527
528    def SetBinary(self, UiInf=None, Ver=None, CommonBinary=None, ArchList=None):
529
530        __SupArchList = []
531        for ArchItem in ArchList:
532            #
533            # Validate Arch
534            #
535            if (ArchItem == '' or ArchItem is None):
536                ArchItem = 'COMMON'
537            __SupArchList.append(ArchItem)
538
539        if UiInf is not None:
540            if len(UiInf) > 0:
541                #
542                # Check UI
543                #
544                for UiItem in UiInf:
545                    IsValidFileFlag = False
546                    InfBianryUiItemObj = None
547                    UiContent = UiItem[0]
548                    UiComment = UiItem[1]
549                    UiCurrentLine = UiItem[2]
550                    GlobalData.gINF_CURRENT_LINE = deepcopy(UiItem[2])
551                    #
552                    # Should not less than 2 elements
553                    #
554                    if len(UiContent) < 2:
555                        Logger.Error("InfParser",
556                                     ToolError.FORMAT_INVALID,
557                                     ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (UiContent[0], 2),
558                                     File=UiCurrentLine.GetFileName(),
559                                     Line=UiCurrentLine.GetLineNo(),
560                                     ExtraData=UiCurrentLine.GetLineString())
561                        return False
562
563                    if len(UiContent) > 4:
564                        Logger.Error("InfParser",
565                                     ToolError.FORMAT_INVALID,
566                                     ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (UiContent[0], 4),
567                                     File=UiCurrentLine.GetFileName(),
568                                     Line=UiCurrentLine.GetLineNo(),
569                                     ExtraData=UiCurrentLine.GetLineString())
570                        return False
571                    if len(UiContent) >= 2:
572                        #
573                        # Create an Ui Object.
574                        #
575                        InfBianryUiItemObj = InfBianryUiItem()
576                        if UiContent[0] != 'UI':
577                            Logger.Error("InfParser",
578                                         ToolError.FORMAT_INVALID,
579                                         ST.ERR_INF_PARSER_BINARY_VER_TYPE % ('UI'),
580                                         File=UiCurrentLine.GetFileName(),
581                                         Line=UiCurrentLine.GetLineNo(),
582                                         ExtraData=UiCurrentLine.GetLineString())
583                        InfBianryUiItemObj.SetUiTypeName(UiContent[0])
584                        InfBianryUiItemObj.SetType(UiContent[0])
585                        #
586                        # Verify File exist or not
587                        #
588                        FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,
589                                                                                      UiContent[1])))
590                        if not (ValidFile(FullFileName) or ValidFile(UiContent[1])):
591                            Logger.Error("InfParser",
592                                         ToolError.FORMAT_INVALID,
593                                         ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (UiContent[1]),
594                                         File=UiCurrentLine.GetFileName(),
595                                         Line=UiCurrentLine.GetLineNo(),
596                                         ExtraData=UiCurrentLine.GetLineString())
597                        #
598                        # Validate file exist/format.
599                        #
600                        if IsValidPath(UiContent[1], GlobalData.gINF_MODULE_DIR):
601                            IsValidFileFlag = True
602                        else:
603                            Logger.Error("InfParser",
604                                         ToolError.FORMAT_INVALID,
605                                         ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (UiContent[1]),
606                                         File=UiCurrentLine.GetFileName(),
607                                         Line=UiCurrentLine.GetLineNo(),
608                                         ExtraData=UiCurrentLine.GetLineString())
609                            return False
610                        if IsValidFileFlag:
611                            UiContent[0] = ConvPathFromAbsToRel(UiContent[0], GlobalData.gINF_MODULE_DIR)
612                            InfBianryUiItemObj.SetFileName(UiContent[1])
613                    if len(UiContent) >= 3:
614                        #
615                        # Add Target information
616                        #
617                        InfBianryUiItemObj.SetTarget(UiContent[2])
618                    if len(UiContent) == 4:
619                        if UiContent[3].strip() == '':
620                            Logger.Error("InfParser",
621                                         ToolError.FORMAT_INVALID,
622                                         ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,
623                                         File=UiCurrentLine.GetFileName(),
624                                         Line=UiCurrentLine.GetLineNo(),
625                                         ExtraData=UiCurrentLine.GetLineString())
626                        #
627                        # Validate Feature Flag Express
628                        #
629                        FeatureFlagRtv = IsValidFeatureFlagExp(UiContent[3].strip())
630                        if not FeatureFlagRtv[0]:
631                            Logger.Error("InfParser",
632                                         ToolError.FORMAT_INVALID,
633                                         ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),
634                                         File=UiCurrentLine.GetFileName(),
635                                         Line=UiCurrentLine.GetLineNo(),
636                                         ExtraData=UiCurrentLine.GetLineString())
637                        InfBianryUiItemObj.SetFeatureFlagExp(UiContent[3])
638
639                    InfBianryUiItemObj.SetSupArchList(__SupArchList)
640
641                    #
642                    # Determine binary file name duplicate. Follow below rule:
643                    #
644                    # A binary filename must not be duplicated within
645                    # a [Binaries] section. A binary filename may appear in
646                    # multiple architectural [Binaries] sections. A binary
647                    # filename listed in an architectural [Binaries] section
648                    # must not be listed in the common architectural
649                    # [Binaries] section.
650                    #
651                    # NOTE: This check will not report error now.
652                    #
653#                    for Item in self.Binaries:
654#                        if Item.GetFileName() == InfBianryUiItemObj.GetFileName():
655#                            ItemSupArchList = Item.GetSupArchList()
656#                            for ItemArch in ItemSupArchList:
657#                                for UiItemObjArch in __SupArchList:
658#                                    if ItemArch == UiItemObjArch:
659#                                        #
660#                                        # ST.ERR_INF_PARSER_ITEM_DUPLICATE
661#                                        #
662#                                        pass
663#                                    if ItemArch.upper() == 'COMMON' or UiItemObjArch.upper() == 'COMMON':
664#                                        #
665#                                        # ERR_INF_PARSER_ITEM_DUPLICATE_COMMON
666#                                        #
667#                                        pass
668
669                    if InfBianryUiItemObj is not None:
670                        if (InfBianryUiItemObj) in self.Binaries:
671                            BinariesList = self.Binaries[InfBianryUiItemObj]
672                            BinariesList.append((InfBianryUiItemObj, UiComment))
673                            self.Binaries[InfBianryUiItemObj] = BinariesList
674                        else:
675                            BinariesList = []
676                            BinariesList.append((InfBianryUiItemObj, UiComment))
677                            self.Binaries[InfBianryUiItemObj] = BinariesList
678        if Ver is not None and len(Ver) > 0:
679            self.CheckVer(Ver, __SupArchList)
680        if CommonBinary and len(CommonBinary) > 0:
681            self.ParseCommonBinary(CommonBinary, __SupArchList)
682
683        return True
684
685    def GetBinary(self):
686        return self.Binaries
687