This patch is going to:

1.	Add a recovery mode for UPT failure
2.	Add UNI file support
3.	Add binary file header support
4.	Add support for PCD error message
5.	Add support for replace
6.	Format generated INF/DEC files
7.	Update dependency check
8.	Other minor fixes


Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Hess Chen <hesheng.chen@intel.com>
Reviewed-by: Gao, Liming <liming.gao@intel.com>

git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@15896 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 188 insertions, 38 deletions

diff --git a/BaseTools/Source/Python/UPT/Library/CommentParsing.py b/BaseTools/Source/Python/UPT/Library/CommentParsing.py
index 5c07f34a74..e6d45103f9 100644
--- a/BaseTools/Source/Python/UPT/Library/CommentParsing.py
+++ b/BaseTools/Source/Python/UPT/Library/CommentParsing.py
@@ -1,7 +1,7 @@
 ## @file

 # This file is used to define comment parsing interface

 #

-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>

+# Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>

 #

 # This program and the accompanying materials are licensed and made available 

 # under the terms and conditions of the BSD License which accompanies this 

@@ -32,6 +32,17 @@ from Library.DataType import HEADER_COMMENT_DESCRIPTION
 from Library.DataType import TAB_SPACE_SPLIT

 from Library.DataType import TAB_COMMA_SPLIT

 from Library.DataType import SUP_MODULE_LIST

+from Library.DataType import TAB_VALUE_SPLIT

+from Library.DataType import TAB_PCD_VALIDRANGE

+from Library.DataType import TAB_PCD_VALIDLIST

+from Library.DataType import TAB_PCD_EXPRESSION

+from Library.DataType import TAB_PCD_PROMPT

+from Library.DataType import TAB_CAPHEX_START

+from Library.DataType import TAB_HEX_START

+from Library.DataType import PCD_ERR_CODE_MAX_SIZE

+from Library.ExpressionValidate import IsValidRangeExpr

+from Library.ExpressionValidate import IsValidListExpr

+from Library.ExpressionValidate import IsValidLogicalExpr

 from Object.POM.CommonObject import TextObject

 from Object.POM.CommonObject import PcdErrorObject

 import Logger.Log as Logger

@@ -47,13 +58,16 @@ from Logger import StringTable as ST
 # @param CommentList:   List of (Comment, LineNumber)

 # @param FileName:      FileName of the comment

 #

-def ParseHeaderCommentSection(CommentList, FileName = None):

+def ParseHeaderCommentSection(CommentList, FileName = None, IsBinaryHeader = False):

     Abstract = ''

     Description = ''

     Copyright = ''

     License = ''

     EndOfLine = "\n"

-    STR_HEADER_COMMENT_START = "@file"

+    if IsBinaryHeader:

+        STR_HEADER_COMMENT_START = "@BinaryHeader"

+    else:

+        STR_HEADER_COMMENT_START = "@file"

     HeaderCommentStage = HEADER_COMMENT_NOT_STARTED

     

     #

@@ -94,7 +108,6 @@ def ParseHeaderCommentSection(CommentList, FileName = None):
                 # in case there is no abstract and description

                 #

                 if not Comment:

-                    Abstract = ''

                     HeaderCommentStage = HEADER_COMMENT_DESCRIPTION

                 elif _IsCopyrightLine(Comment):

                     Result, ErrMsg = _ValidateCopyright(Comment)

@@ -134,14 +147,7 @@ def ParseHeaderCommentSection(CommentList, FileName = None):
                 if not Comment and not License:

                     continue

                 License += Comment + EndOfLine

-    

-    if not Copyright:

-        Logger.Error("\nUPT", FORMAT_INVALID, ST.ERR_COPYRIGHT_MISSING, \

-                     FileName)

-

-    if not License:

-        Logger.Error("\nUPT", FORMAT_INVALID, ST.ERR_LICENSE_MISSING, FileName)

-                     

+                  

     return Abstract.strip(), Description.strip(), Copyright.strip(), License.strip()

 

 ## _IsCopyrightLine

@@ -158,7 +164,7 @@ def _IsCopyrightLine (LineContent):
     ReIsCopyrightRe = re.compile(r"""(^|\s)COPYRIGHT *\(""", re.DOTALL)

     if ReIsCopyrightRe.search(LineContent):

         Result = True

-        

+

     return Result

 

 ## ParseGenericComment

@@ -188,6 +194,37 @@ def ParseGenericComment (GenericComment, ContainerFile=None, SkipTag=None):
 

     return HelpTxt

 

+## ParsePcdErrorCode

+#

+# @param Value: original ErrorCode value 

+# @param ContainerFile: Input value for filename of Dec file

+# @param LineNum: Line Num 

+# 

+def ParsePcdErrorCode (Value = None, ContainerFile = None, LineNum = None):      

+    try: 

+        if Value.strip().startswith((TAB_HEX_START, TAB_CAPHEX_START)):

+            Base = 16

+        else:

+            Base = 10

+        ErrorCode = long(Value, Base)

+        if ErrorCode > PCD_ERR_CODE_MAX_SIZE or ErrorCode < 0:

+            Logger.Error('Parser', 

+                        FORMAT_NOT_SUPPORTED,

+                        "The format %s of ErrorCode is not valid, should be UNIT32 type or long type" % Value,

+                        File = ContainerFile, 

+                        Line = LineNum)

+        #

+        # To delete the tailing 'L'

+        #

+        return hex(ErrorCode)[:-1]

+    except ValueError, XStr:

+        if XStr:

+            pass

+        Logger.Error('Parser', 

+                    FORMAT_NOT_SUPPORTED,

+                    "The format %s of ErrorCode is not valid, should be UNIT32 type or long type" % Value,

+                    File = ContainerFile, 

+                    Line = LineNum)

     

 ## ParseDecPcdGenericComment

 #

@@ -195,46 +232,135 @@ def ParseGenericComment (GenericComment, ContainerFile=None, SkipTag=None):
 #                         LineNum)

 # @param ContainerFile:  Input value for filename of Dec file

 # 

-def ParseDecPcdGenericComment (GenericComment, ContainerFile):       

+def ParseDecPcdGenericComment (GenericComment, ContainerFile, TokenSpaceGuidCName, CName, MacroReplaceDict):       

     HelpStr = '' 

+    PromptStr = ''

     PcdErr = None

+    PcdErrList = []

+    ValidValueNum = 0

+    ValidRangeNum = 0

+    ExpressionNum = 0

         

     for (CommentLine, LineNum) in GenericComment:

         Comment = CleanString2(CommentLine)[1]

-        if Comment.startswith("@ValidRange"):

-            if PcdErr:

+        #

+        # To replace Macro

+        #

+        MACRO_PATTERN = '[\t\s]*\$\([A-Z][_A-Z0-9]*\)'

+        MatchedStrs =  re.findall(MACRO_PATTERN, Comment)

+        for MatchedStr in MatchedStrs:

+            if MatchedStr:

+                Macro = MatchedStr.strip().lstrip('$(').rstrip(')').strip()

+                if Macro in MacroReplaceDict:

+                    Comment = Comment.replace(MatchedStr, MacroReplaceDict[Macro])    

+        if Comment.startswith(TAB_PCD_VALIDRANGE):

+            if ValidValueNum > 0 or ExpressionNum > 0:

                 Logger.Error('Parser', 

                              FORMAT_NOT_SUPPORTED,

                              ST.WRN_MULTI_PCD_RANGES,

                              File = ContainerFile, 

                              Line = LineNum)

-            ValidRange = Comment.replace("@ValidRange", "", 1)

-            if _CheckRangeExpression(ValidRange):

+            else:

                 PcdErr = PcdErrorObject()

-                PcdErr.SetValidValueRange(ValidRange)

-        elif Comment.startswith("@ValidList"):

-            if PcdErr:

+                PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)

+                PcdErr.SetCName(CName)

+                PcdErr.SetFileLine(Comment)

+                PcdErr.SetLineNum(LineNum)

+                ValidRangeNum += 1

+            ValidRange = Comment.replace(TAB_PCD_VALIDRANGE, "", 1).strip()

+            Valid, Cause = _CheckRangeExpression(ValidRange)

+            if Valid:

+                ValueList = ValidRange.split(TAB_VALUE_SPLIT)

+                if len(ValueList) > 1:

+                    PcdErr.SetValidValueRange((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())

+                    PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))

+                else:

+                    PcdErr.SetValidValueRange(ValidRange)

+                PcdErrList.append(PcdErr)

+            else:

+                Logger.Error("Parser",

+                         FORMAT_NOT_SUPPORTED,

+                         Cause, 

+                         ContainerFile, 

+                         LineNum)

+        elif Comment.startswith(TAB_PCD_VALIDLIST):

+            if ValidRangeNum > 0 or ExpressionNum > 0:

                 Logger.Error('Parser', 

                              FORMAT_NOT_SUPPORTED,

                              ST.WRN_MULTI_PCD_RANGES,

                              File = ContainerFile, 

                              Line = LineNum)

-            ValidValue = Comment.replace("@ValidList", "", 1).replace(TAB_COMMA_SPLIT, TAB_SPACE_SPLIT)

-            PcdErr = PcdErrorObject()

-            PcdErr.SetValidValue(ValidValue)

-        elif Comment.startswith("@Expression"):

-            if PcdErr:

+            elif ValidValueNum > 0:

+                Logger.Error('Parser', 

+                             FORMAT_NOT_SUPPORTED,

+                             ST.WRN_MULTI_PCD_VALIDVALUE,

+                             File = ContainerFile, 

+                             Line = LineNum)

+            else:

+                PcdErr = PcdErrorObject()

+                PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)

+                PcdErr.SetCName(CName)

+                PcdErr.SetFileLine(Comment)

+                PcdErr.SetLineNum(LineNum)

+                ValidValueNum += 1

+                ValidValueExpr = Comment.replace(TAB_PCD_VALIDLIST, "", 1).strip()

+            Valid, Cause = _CheckListExpression(ValidValueExpr)

+            if Valid:

+                ValidValue = Comment.replace(TAB_PCD_VALIDLIST, "", 1).replace(TAB_COMMA_SPLIT, TAB_SPACE_SPLIT)

+                ValueList = ValidValue.split(TAB_VALUE_SPLIT)

+                if len(ValueList) > 1:

+                    PcdErr.SetValidValue((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())

+                    PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))

+                else:

+                    PcdErr.SetValidValue(ValidValue)

+                PcdErrList.append(PcdErr)

+            else:

+                Logger.Error("Parser",

+                         FORMAT_NOT_SUPPORTED,

+                         Cause, 

+                         ContainerFile, 

+                         LineNum)

+        elif Comment.startswith(TAB_PCD_EXPRESSION):

+            if ValidRangeNum > 0 or ValidValueNum > 0:

                 Logger.Error('Parser', 

                              FORMAT_NOT_SUPPORTED,

                              ST.WRN_MULTI_PCD_RANGES,

                              File = ContainerFile, 

                              Line = LineNum)

-            Expression = Comment.replace("@Expression", "", 1)

-            if _CheckRangeExpression(Expression):

+            else:

                 PcdErr = PcdErrorObject()

-                PcdErr.SetExpression(Expression)

+                PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)

+                PcdErr.SetCName(CName)

+                PcdErr.SetFileLine(Comment)

+                PcdErr.SetLineNum(LineNum)

+                ExpressionNum += 1

+            Expression = Comment.replace(TAB_PCD_EXPRESSION, "", 1).strip()

+            Valid, Cause = _CheckExpression(Expression)

+            if Valid:

+                ValueList = Expression.split(TAB_VALUE_SPLIT)

+                if len(ValueList) > 1:

+                    PcdErr.SetExpression((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())

+                    PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))

+                else:

+                    PcdErr.SetExpression(Expression)

+                PcdErrList.append(PcdErr)

+            else:        

+                Logger.Error("Parser",

+                         FORMAT_NOT_SUPPORTED,

+                         Cause, 

+                         ContainerFile, 

+                         LineNum)                

+        elif Comment.startswith(TAB_PCD_PROMPT):

+            if PromptStr:

+                Logger.Error('Parser', 

+                             FORMAT_NOT_SUPPORTED,

+                             ST.WRN_MULTI_PCD_PROMPT,

+                             File = ContainerFile, 

+                             Line = LineNum)

+            PromptStr = Comment.replace(TAB_PCD_PROMPT, "", 1).strip()

         else:

-            HelpStr += Comment + '\n'

+            if Comment:

+                HelpStr += Comment + '\n'

     

     #

     # remove the last EOL if the comment is of format 'FOO\n'

@@ -243,7 +369,7 @@ def ParseDecPcdGenericComment (GenericComment, ContainerFile):
         if HelpStr != '\n' and not HelpStr.endswith('\n\n'):

             HelpStr = HelpStr[:-1]

 

-    return HelpStr, PcdErr

+    return HelpStr, PcdErrList, PromptStr

 

 ## ParseDecPcdTailComment

 #

@@ -289,18 +415,43 @@ def ParseDecPcdTailComment (TailCommentList, ContainerFile):
 

     return SupModuleList, HelpStr

 

+## _CheckListExpression

+#

+# @param Expression: Pcd value list expression 

+#

+def _CheckListExpression(Expression):

+    ListExpr = ''

+    if TAB_VALUE_SPLIT in Expression:

+        ListExpr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:] 

+    else:

+        ListExpr = Expression

+        

+    return IsValidListExpr(ListExpr)

+

+## _CheckExpreesion

+#

+# @param Expression: Pcd value expression

+#

+def _CheckExpression(Expression):

+    Expr = ''

+    if TAB_VALUE_SPLIT in Expression:

+        Expr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:]

+    else:

+        Expr = Expression

+    return IsValidLogicalExpr(Expr, True)

 

 ## _CheckRangeExpression

 #

 # @param Expression:    Pcd range expression

 #          

 def _CheckRangeExpression(Expression):

-    #

-    # check grammar for Pcd range expression is not required yet

-    #

-    if Expression:

-        pass

-    return True

+    RangeExpr = ''

+    if TAB_VALUE_SPLIT in Expression:

+        RangeExpr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:]

+    else:

+        RangeExpr = Expression

+        

+    return IsValidRangeExpr(RangeExpr)

 

 ## ValidateCopyright

 #

@@ -349,7 +500,6 @@ def ParseComment (Comment, UsageTokens, TypeTokens, RemoveTokens, ParseVariable)
     Usage = None

     Type = None

     String = None

-    HelpText = None

     

     Comment = Comment[0]