Sync tool code to BuildTools project r1739.

[mirror_edk2.git] / BaseTools / Source / Python / AutoGen / GenDepex.py

## @file\r
# This file is used to generate DEPEX file for module's dependency expression\r
#\r
# Copyright (c) 2007, Intel Corporation\r
# All rights reserved. This program and the accompanying materials\r
# are licensed and made available under the terms and conditions of the BSD License\r
# which accompanies this 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
## Import Modules\r
#\r
import sys\r
import os\r
import re\r
import traceback\r
\r
from StringIO import StringIO\r
from struct import pack\r
from Common.BuildToolError import *\r
from Common.Misc import SaveFileOnChange\r
from Common.Misc import GuidStructureStringToGuidString\r
from Common import EdkLogger as EdkLogger\r
\r
\r
## Regular expression for matching "DEPENDENCY_START ... DEPENDENCY_END"\r
gStartClosePattern = re.compile(".*DEPENDENCY_START(.+)DEPENDENCY_END.*", re.S)\r
\r
## Mapping between module type and EFI phase\r
gType2Phase = {\r
    "BASE"              :   None,\r
    "SEC"               :   "PEI",\r
    "PEI_CORE"          :   "PEI",\r
    "PEIM"              :   "PEI",\r
    "DXE_CORE"          :   "DXE",\r
    "DXE_DRIVER"        :   "DXE",\r
    "DXE_SMM_DRIVER"    :   "DXE",\r
    "DXE_RUNTIME_DRIVER":   "DXE",\r
    "DXE_SAL_DRIVER"    :   "DXE",\r
    "UEFI_DRIVER"       :   "DXE",\r
    "UEFI_APPLICATION"  :   "DXE",\r
    "SMM_CORE"          :   "DXE",\r
}\r
\r
## Convert dependency expression string into EFI internal representation\r
#\r
#   DependencyExpression class is used to parse dependency expression string and\r
# convert it into its binary form.\r
#\r
class DependencyExpression:\r
\r
    ArchProtocols = set([\r
                        '665e3ff6-46cc-11d4-9a38-0090273fc14d',     #   'gEfiBdsArchProtocolGuid'\r
                        '26baccb1-6f42-11d4-bce7-0080c73c8881',     #   'gEfiCpuArchProtocolGuid'\r
                        '26baccb2-6f42-11d4-bce7-0080c73c8881',     #   'gEfiMetronomeArchProtocolGuid'\r
                        '1da97072-bddc-4b30-99f1-72a0b56fff2a',     #   'gEfiMonotonicCounterArchProtocolGuid'\r
                        '27cfac87-46cc-11d4-9a38-0090273fc14d',     #   'gEfiRealTimeClockArchProtocolGuid'\r
                        '27cfac88-46cc-11d4-9a38-0090273fc14d',     #   'gEfiResetArchProtocolGuid'\r
                        'b7dfb4e1-052f-449f-87be-9818fc91b733',     #   'gEfiRuntimeArchProtocolGuid'\r
                        'a46423e3-4617-49f1-b9ff-d1bfa9115839',     #   'gEfiSecurityArchProtocolGuid'\r
                        '26baccb3-6f42-11d4-bce7-0080c73c8881',     #   'gEfiTimerArchProtocolGuid'\r
                        '6441f818-6362-4e44-b570-7dba31dd2453',     #   'gEfiVariableWriteArchProtocolGuid'\r
                        '1e5668e2-8481-11d4-bcf1-0080c73c8881',     #   'gEfiVariableArchProtocolGuid'\r
                        '665e3ff5-46cc-11d4-9a38-0090273fc14d'      #   'gEfiWatchdogTimerArchProtocolGuid'\r
                        ]\r
                    )\r
\r
    OpcodePriority = {\r
        "AND"   :   1,\r
        "OR"    :   1,\r
        "NOT"   :   2,\r
        # "SOR"   :   9,\r
        # "BEFORE":   9,\r
        # "AFTER" :   9,\r
    }\r
\r
    Opcode = {\r
        "PEI"   : {\r
            "PUSH"  :   0x02,\r
            "AND"   :   0x03,\r
            "OR"    :   0x04,\r
            "NOT"   :   0x05,\r
            "TRUE"  :   0x06,\r
            "FALSE" :   0x07,\r
            "END"   :   0x08\r
        },\r
\r
        "DXE"   : {\r
            "BEFORE":   0x00,\r
            "AFTER" :   0x01,\r
            "PUSH"  :   0x02,\r
            "AND"   :   0x03,\r
            "OR"    :   0x04,\r
            "NOT"   :   0x05,\r
            "TRUE"  :   0x06,\r
            "FALSE" :   0x07,\r
            "END"   :   0x08,\r
            "SOR"   :   0x09\r
        }\r
    }\r
\r
    # all supported op codes and operands\r
    SupportedOpcode = ["BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "END", "SOR"]\r
    SupportedOperand = ["TRUE", "FALSE"]\r
\r
    OpcodeWithSingleOperand = ['NOT', 'BEFORE', 'AFTER']\r
    OpcodeWithTwoOperand = ['AND', 'OR']\r
\r
    # op code that should not be the last one\r
    NonEndingOpcode = ["AND", "OR", "NOT", 'SOR']\r
    # op code must not present at the same time\r
    ExclusiveOpcode = ["BEFORE", "AFTER"]\r
    # op code that should be the first one if it presents\r
    AboveAllOpcode = ["SOR", "BEFORE", "AFTER"]\r
\r
    #\r
    # open and close brace must be taken as individual tokens\r
    #\r
    TokenPattern = re.compile("(\(|\)|\{[^{}]+\{?[^{}]+\}?[ ]*\}|\w+)")\r
\r
    ## Constructor\r
    #\r
    #   @param  Expression  The list or string of dependency expression\r
    #   @param  ModuleType  The type of the module using the dependency expression\r
    #\r
    def __init__(self, Expression, ModuleType, Optimize=False):\r
        self.ModuleType = ModuleType\r
        self.Phase = gType2Phase[ModuleType]\r
        if type(Expression) == type([]):\r
            self.ExpressionString = " ".join(Expression)\r
            self.TokenList = Expression\r
        else:\r
            self.ExpressionString = Expression\r
            self.GetExpressionTokenList()\r
\r
        self.PostfixNotation = []\r
        self.OpcodeList = []\r
\r
        self.GetPostfixNotation()\r
        self.ValidateOpcode()\r
\r
        EdkLogger.debug(EdkLogger.DEBUG_8, repr(self))\r
        if Optimize:\r
            self.Optimize()\r
            EdkLogger.debug(EdkLogger.DEBUG_8, "\n    Optimized: " + repr(self))\r
\r
    def __str__(self):\r
        return " ".join(self.TokenList)\r
\r
    def __repr__(self):\r
        WellForm = ''\r
        for Token in self.PostfixNotation:\r
            if Token in self.SupportedOpcode:\r
                WellForm += "\n    " + Token\r
            else:\r
                WellForm += ' ' + Token\r
        return WellForm\r
\r
    ## Split the expression string into token list\r
    def GetExpressionTokenList(self):\r
        self.TokenList = self.TokenPattern.findall(self.ExpressionString)\r
\r
    ## Convert token list into postfix notation\r
    def GetPostfixNotation(self):\r
        Stack = []\r
        LastToken = ''\r
        for Token in self.TokenList:\r
            if Token == "(":\r
                if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before open parentheses",\r
                                    ExtraData="Near %s" % LastToken)\r
                Stack.append(Token)\r
            elif Token == ")":\r
                if '(' not in Stack:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: mismatched parentheses",\r
                                    ExtraData=str(self))\r
                elif LastToken in self.SupportedOpcode + ['', None]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operand before close parentheses",\r
                                    ExtraData="Near %s" % LastToken)\r
                while len(Stack) > 0:\r
                    if Stack[-1] == '(':\r
                        Stack.pop()\r
                        break\r
                    self.PostfixNotation.append(Stack.pop())\r
            elif Token in self.OpcodePriority:\r
                if Token == "NOT":\r
                    if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before NOT",\r
                                        ExtraData="Near %s" % LastToken)\r
                elif LastToken in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operand before " + Token,\r
                                        ExtraData="Near %s" % LastToken)\r
\r
                while len(Stack) > 0:\r
                    if Stack[-1] == "(" or self.OpcodePriority[Token] >= self.OpcodePriority[Stack[-1]]:\r
                        break\r
                    self.PostfixNotation.append(Stack.pop())\r
                Stack.append(Token)\r
                self.OpcodeList.append(Token)\r
            else:\r
                if Token not in self.SupportedOpcode:\r
                    # not OP, take it as GUID\r
                    if LastToken not in self.SupportedOpcode + ['(', '', None]:\r
                        EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: missing operator before %s" % Token,\r
                                        ExtraData="Near %s" % LastToken)\r
                    if len(self.OpcodeList) == 0 or self.OpcodeList[-1] not in self.ExclusiveOpcode:\r
                        if Token not in self.SupportedOperand:\r
                            self.PostfixNotation.append("PUSH")\r
                # check if OP is valid in this phase\r
                elif Token in self.Opcode[self.Phase]:\r
                    if Token == "END":\r
                        break\r
                    self.OpcodeList.append(Token)\r
                else:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR,\r
                                    "Opcode=%s doesn't supported in %s stage " % (Token, self.Phase),\r
                                    ExtraData=str(self))\r
                self.PostfixNotation.append(Token)\r
            LastToken = Token\r
\r
        # there should not be parentheses in Stack\r
        if '(' in Stack or ')' in Stack:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid dependency expression: mismatched parentheses",\r
                            ExtraData=str(self))\r
        while len(Stack) > 0:\r
            self.PostfixNotation.append(Stack.pop())\r
        if self.PostfixNotation[-1] != 'END':\r
            self.PostfixNotation.append("END")\r
\r
    ## Validate the dependency expression\r
    def ValidateOpcode(self):\r
        for Op in self.AboveAllOpcode:\r
            if Op in self.PostfixNotation:\r
                if Op != self.PostfixNotation[0]:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "%s should be the first opcode in the expression" % Op,\r
                                    ExtraData=str(self))\r
                if len(self.PostfixNotation) < 3:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Missing operand for %s" % Op,\r
                                    ExtraData=str(self))\r
        for Op in self.ExclusiveOpcode:\r
            if Op in self.OpcodeList:\r
                if len(self.OpcodeList) > 1:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "%s should be the only opcode in the expression" % Op,\r
                                    ExtraData=str(self))\r
                if len(self.PostfixNotation) < 3:\r
                    EdkLogger.error("GenDepex", PARSER_ERROR, "Missing operand for %s" % Op,\r
                                    ExtraData=str(self))\r
        if self.TokenList[-1] != 'END' and self.TokenList[-1] in self.NonEndingOpcode:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra %s at the end of the dependency expression" % self.TokenList[-1],\r
                            ExtraData=str(self))\r
        if self.TokenList[-1] == 'END' and self.TokenList[-2] in self.NonEndingOpcode:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra %s at the end of the dependency expression" % self.TokenList[-2],\r
                            ExtraData=str(self))\r
        if "END" in self.TokenList and "END" != self.TokenList[-1]:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Extra expressions after END",\r
                            ExtraData=str(self))\r
\r
    ## Simply optimize the dependency expression by removing duplicated operands\r
    def Optimize(self):\r
        ValidOpcode = list(set(self.OpcodeList))\r
        if len(ValidOpcode) != 1 or ValidOpcode[0] not in ['AND', 'OR']:\r
            return\r
        Op = ValidOpcode[0]\r
        NewOperand = []\r
        AllOperand = set()\r
        for Token in self.PostfixNotation:\r
            if Token in self.SupportedOpcode or Token in NewOperand:\r
                continue\r
            AllOperand.add(Token)\r
            if Token == 'TRUE':\r
                if Op == 'AND':\r
                    continue\r
                else:\r
                    NewOperand.append(Token)\r
                    break\r
            elif Token == 'FALSE':\r
                if Op == 'OR':\r
                    continue\r
                else:\r
                    NewOperand.append(Token)\r
                    break\r
            NewOperand.append(Token)\r
\r
        # don't generate depex if only TRUE operand left\r
        if self.ModuleType == 'PEIM' and len(NewOperand) == 1 and NewOperand[0] == 'TRUE':\r
            self.PostfixNotation = []\r
            return            \r
\r
        # don't generate depex if all operands are architecture protocols\r
        if self.ModuleType in ['UEFI_DRIVER', 'DXE_DRIVER', 'DXE_RUNTIME_DRIVER', 'DXE_SAL_DRIVER', 'DXE_SMM_DRIVER'] and \\r
           Op == 'AND' and \\r
           self.ArchProtocols == set([GuidStructureStringToGuidString(Guid) for Guid in AllOperand]):\r
            self.PostfixNotation = []\r
            return\r
\r
        if len(NewOperand) == 0:\r
            self.TokenList = list(AllOperand)\r
        else:\r
            self.TokenList = []\r
            while True:\r
                self.TokenList.append(NewOperand.pop(0))\r
                if NewOperand == []:\r
                    break\r
                self.TokenList.append(Op)\r
        self.PostfixNotation = []\r
        self.GetPostfixNotation()\r
\r
\r
    ## Convert a GUID value in C structure format into its binary form\r
    #\r
    #   @param  Guid    The GUID value in C structure format\r
    #\r
    #   @retval array   The byte array representing the GUID value\r
    #\r
    def GetGuidValue(self, Guid):\r
        GuidValueString = Guid.replace("{", "").replace("}", "").replace(" ", "")\r
        GuidValueList = GuidValueString.split(",")\r
        if len(GuidValueList) != 11:\r
            EdkLogger.error("GenDepex", PARSER_ERROR, "Invalid GUID value string or opcode: %s" % Guid)\r
        return pack("1I2H8B", *(int(value, 16) for value in GuidValueList))\r
\r
    ## Save the binary form of dependency expression in file\r
    #\r
    #   @param  File    The path of file. If None is given, put the data on console\r
    #\r
    #   @retval True    If the file doesn't exist or file is changed\r
    #   @retval False   If file exists and is not changed.\r
    #\r
    def Generate(self, File=None):\r
        Buffer = StringIO()\r
        if len(self.PostfixNotation) == 0:\r
            return False\r
\r
        for Item in self.PostfixNotation:\r
            if Item in self.Opcode[self.Phase]:\r
                Buffer.write(pack("B", self.Opcode[self.Phase][Item]))\r
            elif Item in self.SupportedOpcode:\r
                EdkLogger.error("GenDepex", FORMAT_INVALID,\r
                                "Opcode [%s] is not expected in %s phase" % (Item, self.Phase),\r
                                ExtraData=self.ExpressionString)\r
            else:\r
                Buffer.write(self.GetGuidValue(Item))\r
\r
        FilePath = ""\r
        FileChangeFlag = True\r
        if File == None:\r
            sys.stdout.write(Buffer.getvalue())\r
            FilePath = "STDOUT"\r
        else:\r
            FileChangeFlag = SaveFileOnChange(File, Buffer.getvalue(), True)\r
\r
        Buffer.close()\r
        return FileChangeFlag\r
\r
versionNumber = "0.04"\r
__version__ = "%prog Version " + versionNumber\r
__copyright__ = "Copyright (c) 2007-2008, Intel Corporation  All rights reserved."\r
__usage__ = "%prog [options] [dependency_expression_file]"\r
\r
## Parse command line options\r
#\r
#   @retval OptionParser\r
#\r
def GetOptions():\r
    from optparse import OptionParser\r
\r
    Parser = OptionParser(description=__copyright__, version=__version__, usage=__usage__)\r
\r
    Parser.add_option("-o", "--output", dest="OutputFile", default=None, metavar="FILE",\r
                      help="Specify the name of depex file to be generated")\r
    Parser.add_option("-t", "--module-type", dest="ModuleType", default=None,\r
                      help="The type of module for which the dependency expression serves")\r
    Parser.add_option("-e", "--dependency-expression", dest="Expression", default="",\r
                      help="The string of dependency expression. If this option presents, the input file will be ignored.")\r
    Parser.add_option("-m", "--optimize", dest="Optimize", default=False, action="store_true",\r
                      help="Do some simple optimization on the expression.")\r
    Parser.add_option("-v", "--verbose", dest="verbose", default=False, action="store_true",\r
                      help="build with verbose information")\r
    Parser.add_option("-d", "--debug", action="store", type="int", help="Enable debug messages at specified level.")\r
    Parser.add_option("-q", "--quiet", dest="quiet", default=False, action="store_true",\r
                      help="build with little information")\r
\r
    return Parser.parse_args()\r
\r
\r
## Entrance method\r
#\r
# @retval 0     Tool was successful\r
# @retval 1     Tool failed\r
#\r
def Main():\r
    EdkLogger.Initialize()\r
    Option, Input = GetOptions()\r
\r
    # Set log level\r
    if Option.quiet:\r
        EdkLogger.SetLevel(EdkLogger.QUIET)\r
    elif Option.verbose:\r
        EdkLogger.SetLevel(EdkLogger.VERBOSE)\r
    elif Option.debug != None:\r
        EdkLogger.SetLevel(Option.debug + 1)\r
    else:\r
        EdkLogger.SetLevel(EdkLogger.INFO)\r
\r
    try:\r
        if Option.ModuleType == None or Option.ModuleType not in gType2Phase:\r
            EdkLogger.error("GenDepex", OPTION_MISSING, "Module type is not specified or supported")\r
\r
        DxsFile = ''\r
        if len(Input) > 0 and Option.Expression == "":\r
            DxsFile = Input[0]\r
            DxsString = open(DxsFile, 'r').read().replace("\n", " ").replace("\r", " ")\r
            DxsString = gStartClosePattern.sub("\\1", DxsString)\r
        elif Option.Expression != "":\r
            if Option.Expression[0] == '"':\r
                DxsString = Option.Expression[1:-1]\r
            else:\r
                DxsString = Option.Expression\r
        else:\r
            EdkLogger.error("GenDepex", OPTION_MISSING, "No expression string or file given")\r
\r
        Dpx = DependencyExpression(DxsString, Option.ModuleType, Option.Optimize)\r
        if Option.OutputFile != None:\r
            Dpx.Generate(Option.OutputFile)\r
        else:\r
            Dpx.Generate()\r
    except BaseException, X:\r
        EdkLogger.quiet("")\r
        if Option != None and Option.debug != None:\r
            EdkLogger.quiet(traceback.format_exc())\r
        else:\r
            EdkLogger.quiet(str(X))\r
        return 1\r
\r
    return 0\r
\r
if __name__ == '__main__':\r
    sys.exit(Main())\r
\r