[mirror_edk2.git] / BaseTools / Source / Python / UPT / Parser / InfParser.py

## @file\r
# This file contained the parser for INF file\r
#\r
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available\r
# under the terms and conditions of the BSD License which accompanies this\r
# distribution. The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
'''\r
InfParser\r
'''\r
\r
##\r
# Import Modules\r
#\r
import re\r
import os\r
from copy import deepcopy\r
\r
from Library.StringUtils import GetSplitValueList\r
from Library.StringUtils import ConvertSpecialChar\r
from Library.Misc import ProcessLineExtender\r
from Library.Misc import ProcessEdkComment\r
from Library.Parsing import NormPath\r
from Library.ParserValidate import IsValidInfMoudleTypeList\r
from Library.ParserValidate import IsValidArch\r
from Library import DataType as DT\r
from Library import GlobalData\r
\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Logger.ToolError import FORMAT_INVALID\r
from Logger.ToolError import FILE_READ_FAILURE\r
from Logger.ToolError import PARSER_ERROR\r
\r
from Object.Parser.InfCommonObject import InfSectionCommonDef\r
from Parser.InfSectionParser import InfSectionParser\r
from Parser.InfParserMisc import gINF_SECTION_DEF\r
from Parser.InfParserMisc import IsBinaryInf\r
\r
## OpenInfFile\r
#\r
#\r
def OpenInfFile(Filename):\r
    FileLinesList = []\r
\r
    try:\r
        FInputfile = open(Filename, "r")\r
        try:\r
            FileLinesList = FInputfile.readlines()\r
        except BaseException:\r
            Logger.Error("InfParser",\r
                         FILE_READ_FAILURE,\r
                         ST.ERR_FILE_OPEN_FAILURE,\r
                         File=Filename)\r
        finally:\r
            FInputfile.close()\r
    except BaseException:\r
        Logger.Error("InfParser",\r
                     FILE_READ_FAILURE,\r
                     ST.ERR_FILE_OPEN_FAILURE,\r
                     File=Filename)\r
\r
    return FileLinesList\r
\r
## InfParser\r
#\r
# This class defined the structure used in InfParser object\r
#\r
# @param InfObject:         Inherited from InfSectionParser class\r
# @param Filename:          Input value for Filename of INF file, default is\r
#                           None\r
# @param WorkspaceDir:      Input value for current workspace directory,\r
#                           default is None\r
#\r
class InfParser(InfSectionParser):\r
\r
    def __init__(self, Filename = None, WorkspaceDir = None):\r
\r
        #\r
        # Call parent class construct function\r
        #\r
        super().__init__()\r
\r
        self.WorkspaceDir    = WorkspaceDir\r
        self.SupArchList     = DT.ARCH_LIST\r
        self.EventList    = []\r
        self.HobList      = []\r
        self.BootModeList = []\r
\r
        #\r
        # Load Inf file if filename is not None\r
        #\r
        if Filename is not None:\r
            self.ParseInfFile(Filename)\r
\r
    ## Parse INF file\r
    #\r
    # Parse the file if it exists\r
    #\r
    # @param Filename:  Input value for filename of INF file\r
    #\r
    def ParseInfFile(self, Filename):\r
\r
        Filename = NormPath(Filename)\r
        (Path, Name) = os.path.split(Filename)\r
        self.FullPath = Filename\r
        self.RelaPath = Path\r
        self.FileName = Name\r
        GlobalData.gINF_MODULE_DIR = Path\r
        GlobalData.gINF_MODULE_NAME = self.FullPath\r
        GlobalData.gIS_BINARY_INF = False\r
        #\r
        # Initialize common data\r
        #\r
        LineNo             = 0\r
        CurrentSection     = DT.MODEL_UNKNOWN\r
        SectionLines       = []\r
\r
        #\r
        # Flags\r
        #\r
        HeaderCommentStart = False\r
        HeaderCommentEnd   = False\r
        HeaderStarLineNo = -1\r
        BinaryHeaderCommentStart = False\r
        BinaryHeaderCommentEnd   = False\r
        BinaryHeaderStarLineNo = -1\r
\r
        #\r
        # While Section ends. parse whole section contents.\r
        #\r
        NewSectionStartFlag = False\r
        FirstSectionStartFlag = False\r
\r
        #\r
        # Parse file content\r
        #\r
        CommentBlock       = []\r
\r
        #\r
        # Variables for Event/Hob/BootMode\r
        #\r
        self.EventList    = []\r
        self.HobList      = []\r
        self.BootModeList = []\r
        SectionType = ''\r
\r
        FileLinesList = OpenInfFile (Filename)\r
\r
        #\r
        # One INF file can only has one [Defines] section.\r
        #\r
        DefineSectionParsedFlag = False\r
\r
        #\r
        # Convert special characters in lines to space character.\r
        #\r
        FileLinesList = ConvertSpecialChar(FileLinesList)\r
\r
        #\r
        # Process Line Extender\r
        #\r
        FileLinesList = ProcessLineExtender(FileLinesList)\r
\r
        #\r
        # Process EdkI INF style comment if found\r
        #\r
        OrigLines = [Line for Line in FileLinesList]\r
        FileLinesList, EdkCommentStartPos = ProcessEdkComment(FileLinesList)\r
\r
        #\r
        # Judge whether the INF file is Binary INF or not\r
        #\r
        if IsBinaryInf(FileLinesList):\r
            GlobalData.gIS_BINARY_INF = True\r
\r
        InfSectionCommonDefObj = None\r
\r
        for Line in FileLinesList:\r
            LineNo   = LineNo + 1\r
            Line     = Line.strip()\r
            if (LineNo < len(FileLinesList) - 1):\r
                NextLine = FileLinesList[LineNo].strip()\r
\r
            #\r
            # blank line\r
            #\r
            if (Line == '' or not Line) and LineNo == len(FileLinesList):\r
                LastSectionFalg = True\r
\r
            #\r
            # check whether file header comment section started\r
            #\r
            if Line.startswith(DT.TAB_SPECIAL_COMMENT) and \\r
               (Line.find(DT.TAB_HEADER_COMMENT) > -1) and \\r
               not HeaderCommentStart and not HeaderCommentEnd:\r
\r
                CurrentSection = DT.MODEL_META_DATA_FILE_HEADER\r
                #\r
                # Append the first line to section lines.\r
                #\r
                HeaderStarLineNo = LineNo\r
                SectionLines.append((Line, LineNo))\r
                HeaderCommentStart = True\r
                continue\r
\r
            #\r
            # Collect Header content.\r
            #\r
            if (Line.startswith(DT.TAB_COMMENT_SPLIT) and CurrentSection == DT.MODEL_META_DATA_FILE_HEADER) and\\r
                HeaderCommentStart and not Line.startswith(DT.TAB_SPECIAL_COMMENT) and not\\r
                HeaderCommentEnd and NextLine != '':\r
                SectionLines.append((Line, LineNo))\r
                continue\r
            #\r
            # Header content end\r
            #\r
            if (Line.startswith(DT.TAB_SPECIAL_COMMENT) or not Line.strip().startswith("#")) and HeaderCommentStart \\r
                and not HeaderCommentEnd:\r
                HeaderCommentEnd = True\r
                BinaryHeaderCommentStart = False\r
                BinaryHeaderCommentEnd   = False\r
                HeaderCommentStart = False\r
                if Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1:\r
                    self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName)\r
                    SectionLines = []\r
                else:\r
                    SectionLines.append((Line, LineNo))\r
                    #\r
                    # Call Header comment parser.\r
                    #\r
                    self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName)\r
                    SectionLines = []\r
                    continue\r
\r
            #\r
            # check whether binary header comment section started\r
            #\r
            if Line.startswith(DT.TAB_SPECIAL_COMMENT) and \\r
                (Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1) and \\r
                not BinaryHeaderCommentStart:\r
                SectionLines = []\r
                CurrentSection = DT.MODEL_META_DATA_FILE_HEADER\r
                #\r
                # Append the first line to section lines.\r
                #\r
                BinaryHeaderStarLineNo = LineNo\r
                SectionLines.append((Line, LineNo))\r
                BinaryHeaderCommentStart = True\r
                HeaderCommentEnd = True\r
                continue\r
\r
            #\r
            # check whether there are more than one binary header exist\r
            #\r
            if Line.startswith(DT.TAB_SPECIAL_COMMENT) and BinaryHeaderCommentStart and \\r
                not BinaryHeaderCommentEnd and (Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1):\r
                Logger.Error('Parser',\r
                             FORMAT_INVALID,\r
                             ST.ERR_MULTIPLE_BINARYHEADER_EXIST,\r
                             File=Filename)\r
\r
            #\r
            # Collect Binary Header content.\r
            #\r
            if (Line.startswith(DT.TAB_COMMENT_SPLIT) and CurrentSection == DT.MODEL_META_DATA_FILE_HEADER) and\\r
                BinaryHeaderCommentStart and not Line.startswith(DT.TAB_SPECIAL_COMMENT) and not\\r
                BinaryHeaderCommentEnd and NextLine != '':\r
                SectionLines.append((Line, LineNo))\r
                continue\r
            #\r
            # Binary Header content end\r
            #\r
            if (Line.startswith(DT.TAB_SPECIAL_COMMENT) or not Line.strip().startswith(DT.TAB_COMMENT_SPLIT)) and \\r
                BinaryHeaderCommentStart and not BinaryHeaderCommentEnd:\r
                SectionLines.append((Line, LineNo))\r
                BinaryHeaderCommentStart = False\r
                #\r
                # Call Binary Header comment parser.\r
                #\r
                self.InfHeaderParser(SectionLines, self.InfBinaryHeader, self.FileName, True)\r
                SectionLines = []\r
                BinaryHeaderCommentEnd   = True\r
                continue\r
            #\r
            # Find a new section tab\r
            # Or at the last line of INF file,\r
            # need to process the last section.\r
            #\r
            LastSectionFalg = False\r
            if LineNo == len(FileLinesList):\r
                LastSectionFalg = True\r
\r
            if Line.startswith(DT.TAB_COMMENT_SPLIT) and not Line.startswith(DT.TAB_SPECIAL_COMMENT):\r
                SectionLines.append((Line, LineNo))\r
                if not LastSectionFalg:\r
                    continue\r
\r
            #\r
            # Encountered a section. start with '[' and end with ']'\r
            #\r
            if (Line.startswith(DT.TAB_SECTION_START) and \\r
               Line.find(DT.TAB_SECTION_END) > -1) or LastSectionFalg:\r
\r
                HeaderCommentEnd = True\r
                BinaryHeaderCommentEnd = True\r
\r
                if not LastSectionFalg:\r
                    #\r
                    # check to prevent '#' inside section header\r
                    #\r
                    HeaderContent = Line[1:Line.find(DT.TAB_SECTION_END)]\r
                    if HeaderContent.find(DT.TAB_COMMENT_SPLIT) != -1:\r
                        Logger.Error("InfParser",\r
                                     FORMAT_INVALID,\r
                                     ST.ERR_INF_PARSER_DEFINE_SECTION_HEADER_INVALID,\r
                                     File=self.FullPath,\r
                                     Line=LineNo,\r
                                     ExtraData=Line)\r
\r
                    #\r
                    # Keep last time section header content for section parser\r
                    # usage.\r
                    #\r
                    self.LastSectionHeaderContent = deepcopy(self.SectionHeaderContent)\r
\r
                    #\r
                    # TailComments in section define.\r
                    #\r
                    TailComments = ''\r
                    CommentIndex = Line.find(DT.TAB_COMMENT_SPLIT)\r
                    if  CommentIndex > -1:\r
                        TailComments = Line[CommentIndex:]\r
                        Line = Line[:CommentIndex]\r
\r
                    InfSectionCommonDefObj = InfSectionCommonDef()\r
                    if TailComments != '':\r
                        InfSectionCommonDefObj.SetTailComments(TailComments)\r
                    if CommentBlock != '':\r
                        InfSectionCommonDefObj.SetHeaderComments(CommentBlock)\r
                        CommentBlock = []\r
                    #\r
                    # Call section parser before section header parer to avoid encounter EDKI INF file\r
                    #\r
                    if CurrentSection == DT.MODEL_META_DATA_DEFINE:\r
                        DefineSectionParsedFlag = self._CallSectionParsers(CurrentSection,\r
                                                                   DefineSectionParsedFlag, SectionLines,\r
                                                                   InfSectionCommonDefObj, LineNo)\r
                    #\r
                    # Compare the new section name with current\r
                    #\r
                    self.SectionHeaderParser(Line, self.FileName, LineNo)\r
\r
                    self._CheckSectionHeaders(Line, LineNo)\r
\r
                    SectionType = _ConvertSecNameToType(self.SectionHeaderContent[0][0])\r
\r
                if not FirstSectionStartFlag:\r
                    CurrentSection = SectionType\r
                    FirstSectionStartFlag = True\r
                else:\r
                    NewSectionStartFlag = True\r
            else:\r
                SectionLines.append((Line, LineNo))\r
                continue\r
\r
            if LastSectionFalg:\r
                SectionLines, CurrentSection = self._ProcessLastSection(SectionLines, Line, LineNo, CurrentSection)\r
\r
            #\r
            # End of section content collect.\r
            # Parser the section content collected previously.\r
            #\r
            if NewSectionStartFlag or LastSectionFalg:\r
                if CurrentSection != DT.MODEL_META_DATA_DEFINE or \\r
                    (LastSectionFalg and CurrentSection == DT.MODEL_META_DATA_DEFINE):\r
                    DefineSectionParsedFlag = self._CallSectionParsers(CurrentSection,\r
                                                                       DefineSectionParsedFlag, SectionLines,\r
                                                                       InfSectionCommonDefObj, LineNo)\r
\r
                CurrentSection = SectionType\r
                #\r
                # Clear section lines\r
                #\r
                SectionLines = []\r
\r
        if HeaderStarLineNo == -1:\r
            Logger.Error("InfParser",\r
                        FORMAT_INVALID,\r
                        ST.ERR_NO_SOURCE_HEADER,\r
                        File=self.FullPath)\r
        if BinaryHeaderStarLineNo > -1 and HeaderStarLineNo > -1  and HeaderStarLineNo > BinaryHeaderStarLineNo:\r
            Logger.Error("InfParser",\r
                        FORMAT_INVALID,\r
                        ST.ERR_BINARY_HEADER_ORDER,\r
                        File=self.FullPath)\r
        #\r
        # EDKII INF should not have EDKI style comment\r
        #\r
        if EdkCommentStartPos != -1:\r
            Logger.Error("InfParser",\r
                         FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_EDKI_COMMENT_IN_EDKII,\r
                         File=self.FullPath,\r
                         Line=EdkCommentStartPos + 1,\r
                         ExtraData=OrigLines[EdkCommentStartPos])\r
\r
        #\r
        # extract [Event] [Hob] [BootMode] sections\r
        #\r
        self._ExtractEventHobBootMod(FileLinesList)\r
\r
    ## _CheckSectionHeaders\r
    #\r
    #\r
    def _CheckSectionHeaders(self, Line, LineNo):\r
        if len(self.SectionHeaderContent) == 0:\r
            Logger.Error("InfParser",\r
                         FORMAT_INVALID,\r
                         ST.ERR_INF_PARSER_DEFINE_SECTION_HEADER_INVALID,\r
                         File=self.FullPath,\r
                         Line=LineNo, ExtraData=Line)\r
        else:\r
            for SectionItem in self.SectionHeaderContent:\r
                ArchList = []\r
                #\r
                # Not cover Depex/UserExtension section header\r
                # check.\r
                #\r
                if SectionItem[0].strip().upper() == DT.TAB_INF_FIXED_PCD.upper() or \\r
                    SectionItem[0].strip().upper() == DT.TAB_INF_PATCH_PCD.upper() or \\r
                    SectionItem[0].strip().upper() == DT.TAB_INF_PCD_EX.upper() or \\r
                    SectionItem[0].strip().upper() == DT.TAB_INF_PCD.upper() or \\r
                    SectionItem[0].strip().upper() == DT.TAB_INF_FEATURE_PCD.upper():\r
                    ArchList = GetSplitValueList(SectionItem[1].strip(), ' ')\r
                else:\r
                    ArchList = [SectionItem[1].strip()]\r
\r
                for Arch in ArchList:\r
                    if (not IsValidArch(Arch)) and \\r
                        (SectionItem[0].strip().upper() != DT.TAB_DEPEX.upper()) and \\r
                        (SectionItem[0].strip().upper() != DT.TAB_USER_EXTENSIONS.upper()) and \\r
                        (SectionItem[0].strip().upper() != DT.TAB_COMMON_DEFINES.upper()):\r
                        Logger.Error("InfParser",\r
                                     FORMAT_INVALID,\r
                                     ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(SectionItem[1]),\r
                                     File=self.FullPath,\r
                                     Line=LineNo, ExtraData=Line)\r
                #\r
                # Check if the ModuleType is valid\r
                #\r
                ChkModSectionList = ['LIBRARYCLASSES']\r
                if (self.SectionHeaderContent[0][0].upper() in ChkModSectionList):\r
                    if SectionItem[2].strip().upper():\r
                        MoudleTypeList = GetSplitValueList(\r
                                    SectionItem[2].strip().upper())\r
                        if (not IsValidInfMoudleTypeList(MoudleTypeList)):\r
                            Logger.Error("InfParser",\r
                                         FORMAT_INVALID,\r
                                         ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(SectionItem[2]),\r
                                         File=self.FullPath, Line=LineNo,\r
                                         ExtraData=Line)\r
\r
    ## _CallSectionParsers\r
    #\r
    #\r
    def _CallSectionParsers(self, CurrentSection, DefineSectionParsedFlag,\r
                            SectionLines, InfSectionCommonDefObj, LineNo):\r
        if CurrentSection == DT.MODEL_META_DATA_DEFINE:\r
            if not DefineSectionParsedFlag:\r
                self.InfDefineParser(SectionLines,\r
                                     self.InfDefSection,\r
                                     self.FullPath,\r
                                     InfSectionCommonDefObj)\r
                DefineSectionParsedFlag = True\r
            else:\r
                Logger.Error("Parser",\r
                             PARSER_ERROR,\r
                             ST.ERR_INF_PARSER_MULTI_DEFINE_SECTION,\r
                             File=self.FullPath,\r
                             RaiseError = Logger.IS_RAISE_ERROR)\r
\r
        elif CurrentSection == DT.MODEL_META_DATA_BUILD_OPTION:\r
            self.InfBuildOptionParser(SectionLines,\r
                                      self.InfBuildOptionSection,\r
                                      self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_LIBRARY_CLASS:\r
            self.InfLibraryParser(SectionLines,\r
                                  self.InfLibraryClassSection,\r
                                  self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_META_DATA_PACKAGE:\r
            self.InfPackageParser(SectionLines,\r
                                  self.InfPackageSection,\r
                                  self.FullPath)\r
        #\r
        # [Pcd] Sections, put it together\r
        #\r
        elif CurrentSection == DT.MODEL_PCD_FIXED_AT_BUILD or \\r
             CurrentSection == DT.MODEL_PCD_PATCHABLE_IN_MODULE or \\r
             CurrentSection == DT.MODEL_PCD_FEATURE_FLAG or \\r
             CurrentSection == DT.MODEL_PCD_DYNAMIC_EX or \\r
             CurrentSection == DT.MODEL_PCD_DYNAMIC:\r
            self.InfPcdParser(SectionLines,\r
                              self.InfPcdSection,\r
                              self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_SOURCE_FILE:\r
            self.InfSourceParser(SectionLines,\r
                                 self.InfSourcesSection,\r
                                 self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_META_DATA_USER_EXTENSION:\r
            self.InfUserExtensionParser(SectionLines,\r
                                        self.InfUserExtensionSection,\r
                                        self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_PROTOCOL:\r
            self.InfProtocolParser(SectionLines,\r
                                   self.InfProtocolSection,\r
                                   self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_PPI:\r
            self.InfPpiParser(SectionLines,\r
                              self.InfPpiSection,\r
                              self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_GUID:\r
            self.InfGuidParser(SectionLines,\r
                               self.InfGuidSection,\r
                               self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_DEPEX:\r
            self.InfDepexParser(SectionLines,\r
                                self.InfDepexSection,\r
                                self.FullPath)\r
\r
        elif CurrentSection == DT.MODEL_EFI_BINARY_FILE:\r
            self.InfBinaryParser(SectionLines,\r
                                 self.InfBinariesSection,\r
                                 self.FullPath)\r
        #\r
        # Unknown section type found, raise error.\r
        #\r
        else:\r
            if len(self.SectionHeaderContent) >= 1:\r
                Logger.Error("Parser",\r
                             PARSER_ERROR,\r
                             ST.ERR_INF_PARSER_UNKNOWN_SECTION,\r
                             File=self.FullPath, Line=LineNo,\r
                             RaiseError = Logger.IS_RAISE_ERROR)\r
            else:\r
                Logger.Error("Parser",\r
                             PARSER_ERROR,\r
                             ST.ERR_INF_PARSER_NO_SECTION_ERROR,\r
                             File=self.FullPath, Line=LineNo,\r
                             RaiseError = Logger.IS_RAISE_ERROR)\r
\r
        return DefineSectionParsedFlag\r
\r
    def _ExtractEventHobBootMod(self, FileLinesList):\r
        SpecialSectionStart = False\r
        CheckLocation = False\r
        GFindSpecialCommentRe = \\r
        re.compile(r"""#(?:\s*)\[(.*?)\](?:.*)""", re.DOTALL)\r
        GFindNewSectionRe2 = \\r
        re.compile(r"""#?(\s*)\[(.*?)\](.*)""", re.DOTALL)\r
        LineNum = 0\r
        Element = []\r
        for Line in FileLinesList:\r
            Line = Line.strip()\r
            LineNum += 1\r
            MatchObject = GFindSpecialCommentRe.search(Line)\r
            if MatchObject:\r
                SpecialSectionStart = True\r
                Element = []\r
                if MatchObject.group(1).upper().startswith("EVENT"):\r
                    List = self.EventList\r
                elif MatchObject.group(1).upper().startswith("HOB"):\r
                    List = self.HobList\r
                elif MatchObject.group(1).upper().startswith("BOOTMODE"):\r
                    List = self.BootModeList\r
                else:\r
                    SpecialSectionStart = False\r
                    CheckLocation = False\r
                if SpecialSectionStart:\r
                    Element.append([Line, LineNum])\r
                    List.append(Element)\r
            else:\r
                #\r
                # if currently in special section, try to detect end of current section\r
                #\r
                MatchObject = GFindNewSectionRe2.search(Line)\r
                if SpecialSectionStart:\r
                    if MatchObject:\r
                        SpecialSectionStart = False\r
                        CheckLocation = False\r
                        Element = []\r
                    elif not Line:\r
                        SpecialSectionStart = False\r
                        CheckLocation = True\r
                        Element = []\r
                    else:\r
                        if not Line.startswith(DT.TAB_COMMENT_SPLIT):\r
                            Logger.Warn("Parser",\r
                                         ST.WARN_SPECIAL_SECTION_LOCATION_WRONG,\r
                                         File=self.FullPath, Line=LineNum)\r
                            SpecialSectionStart = False\r
                            CheckLocation = False\r
                            Element = []\r
                        else:\r
                            Element.append([Line, LineNum])\r
                else:\r
                    if CheckLocation:\r
                        if MatchObject:\r
                            CheckLocation = False\r
                        elif Line:\r
                            Logger.Warn("Parser",\r
                                         ST.WARN_SPECIAL_SECTION_LOCATION_WRONG,\r
                                         File=self.FullPath, Line=LineNum)\r
                            CheckLocation = False\r
\r
        if len(self.BootModeList) >= 1:\r
            self.InfSpecialCommentParser(self.BootModeList,\r
                                         self.InfSpecialCommentSection,\r
                                         self.FileName,\r
                                         DT.TYPE_BOOTMODE_SECTION)\r
\r
        if len(self.EventList) >= 1:\r
            self.InfSpecialCommentParser(self.EventList,\r
                                         self.InfSpecialCommentSection,\r
                                         self.FileName,\r
                                         DT.TYPE_EVENT_SECTION)\r
\r
        if len(self.HobList) >= 1:\r
            self.InfSpecialCommentParser(self.HobList,\r
                                         self.InfSpecialCommentSection,\r
                                         self.FileName,\r
                                         DT.TYPE_HOB_SECTION)\r
    ## _ProcessLastSection\r
    #\r
    #\r
    def _ProcessLastSection(self, SectionLines, Line, LineNo, CurrentSection):\r
        #\r
        # The last line is a section header. will discard it.\r
        #\r
        if not (Line.startswith(DT.TAB_SECTION_START) and Line.find(DT.TAB_SECTION_END) > -1):\r
            SectionLines.append((Line, LineNo))\r
\r
        if len(self.SectionHeaderContent) >= 1:\r
            TemSectionName = self.SectionHeaderContent[0][0].upper()\r
            if TemSectionName.upper() not in gINF_SECTION_DEF.keys():\r
                Logger.Error("InfParser",\r
                             FORMAT_INVALID,\r
                             ST.ERR_INF_PARSER_UNKNOWN_SECTION,\r
                             File=self.FullPath,\r
                             Line=LineNo,\r
                             ExtraData=Line,\r
                             RaiseError = Logger.IS_RAISE_ERROR\r
                             )\r
            else:\r
                CurrentSection = gINF_SECTION_DEF[TemSectionName]\r
                self.LastSectionHeaderContent = self.SectionHeaderContent\r
\r
        return SectionLines, CurrentSection\r
\r
## _ConvertSecNameToType\r
#\r
#\r
def _ConvertSecNameToType(SectionName):\r
    SectionType = ''\r
    if SectionName.upper() not in gINF_SECTION_DEF.keys():\r
        SectionType = DT.MODEL_UNKNOWN\r
    else:\r
        SectionType = gINF_SECTION_DEF[SectionName.upper()]\r
\r
    return SectionType\r
\r