604371b98d
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1676 6f19259b-4bc3-4df7-8a09-765794883524
491 lines
12 KiB
C
491 lines
12 KiB
C
/*++
|
|
|
|
Copyright (c) 2004, Intel Corporation
|
|
All rights reserved. This program and the accompanying materials
|
|
are licensed and made available under the terms and conditions of the BSD License
|
|
which accompanies this distribution. The full text of the license may be found at
|
|
http://opensource.org/licenses/bsd-license.php
|
|
|
|
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
|
|
|
Module Name:
|
|
|
|
UtilsMsgs.c
|
|
|
|
Abstract:
|
|
|
|
EFI tools utility functions to display warning, error, and informational
|
|
messages.
|
|
|
|
--*/
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <stdarg.h>
|
|
|
|
#include <Common/UefiBaseTypes.h>
|
|
|
|
#include "EfiUtilityMsgs.h"
|
|
|
|
#define MAX_LINE_LEN 200
|
|
|
|
//
|
|
// Declare module globals for keeping track of the the utility's
|
|
// name and other settings.
|
|
//
|
|
static STATUS mStatus = STATUS_SUCCESS;
|
|
static INT8 mUtilityName[50] = { 0 };
|
|
static INT8 *mSourceFileName = NULL;
|
|
static UINT32 mSourceFileLineNum = 0;
|
|
static UINT32 mErrorCount = 0;
|
|
static UINT32 mWarningCount = 0;
|
|
static UINT32 mDebugMsgMask = 0;
|
|
|
|
static
|
|
void
|
|
PrintMessage (
|
|
INT8 *Type,
|
|
INT8 *FileName,
|
|
UINT32 LineNumber,
|
|
UINT32 MessageCode,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
va_list List
|
|
);
|
|
|
|
void
|
|
Error (
|
|
INT8 *FileName,
|
|
UINT32 LineNumber,
|
|
UINT32 MessageCode,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Prints an error message.
|
|
|
|
Arguments:
|
|
All arguments are optional, though the printed message may be useless if
|
|
at least something valid is not specified.
|
|
|
|
FileName - name of the file or application. If not specified, then the
|
|
utilty name (as set by the utility calling SetUtilityName()
|
|
earlier) is used. Otherwise "Unknown utility" is used.
|
|
|
|
LineNumber - the line number of error, typically used by parsers. If the
|
|
utility is not a parser, then 0 should be specified. Otherwise
|
|
the FileName and LineNumber info can be used to cause
|
|
MS Visual Studio to jump to the error.
|
|
|
|
MessageCode - an application-specific error code that can be referenced in
|
|
other documentation.
|
|
|
|
Text - the text in question, typically used by parsers.
|
|
|
|
MsgFmt - the format string for the error message. Can contain formatting
|
|
controls for use with the varargs.
|
|
|
|
Returns:
|
|
None.
|
|
|
|
Notes:
|
|
We print the following (similar to the Warn() and Debug()
|
|
W
|
|
Typical error/warning message format:
|
|
|
|
bin\VfrCompile.cpp(330) : error C2660: 'AddVfrDataStructField' : function does not take 2 parameters
|
|
|
|
BUGBUG -- these three utility functions are almost identical, and
|
|
should be modified to share code.
|
|
|
|
Visual Studio does not find error messages with:
|
|
|
|
" error :"
|
|
" error 1:"
|
|
" error c1:"
|
|
" error 1000:"
|
|
" error c100:"
|
|
|
|
It does find:
|
|
" error c1000:"
|
|
--*/
|
|
{
|
|
va_list List;
|
|
mErrorCount++;
|
|
va_start (List, MsgFmt);
|
|
PrintMessage ("error", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
|
va_end (List);
|
|
//
|
|
// Set status accordingly
|
|
//
|
|
if (mStatus < STATUS_ERROR) {
|
|
mStatus = STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
void
|
|
ParserError (
|
|
UINT32 MessageCode,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Print a parser error, using the source file name and line number
|
|
set by a previous call to SetParserPosition().
|
|
|
|
Arguments:
|
|
MessageCode - application-specific error code
|
|
Text - text to print in the error message
|
|
MsgFmt - format string to print at the end of the error message
|
|
...
|
|
|
|
Returns:
|
|
NA
|
|
|
|
--*/
|
|
{
|
|
va_list List;
|
|
mErrorCount++;
|
|
va_start (List, MsgFmt);
|
|
PrintMessage ("error", mSourceFileName, mSourceFileLineNum, MessageCode, Text, MsgFmt, List);
|
|
va_end (List);
|
|
//
|
|
// Set status accordingly
|
|
//
|
|
if (mStatus < STATUS_ERROR) {
|
|
mStatus = STATUS_ERROR;
|
|
}
|
|
}
|
|
|
|
void
|
|
ParserWarning (
|
|
UINT32 ErrorCode,
|
|
INT8 *OffendingText,
|
|
INT8 *MsgFmt,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Print a parser warning, using the source file name and line number
|
|
set by a previous call to SetParserPosition().
|
|
|
|
Arguments:
|
|
ErrorCode - application-specific error code
|
|
OffendingText - text to print in the warning message
|
|
MsgFmt - format string to print at the end of the warning message
|
|
...
|
|
|
|
Returns:
|
|
NA
|
|
|
|
--*/
|
|
{
|
|
va_list List;
|
|
mWarningCount++;
|
|
va_start (List, MsgFmt);
|
|
PrintMessage ("warning", mSourceFileName, mSourceFileLineNum, ErrorCode, OffendingText, MsgFmt, List);
|
|
va_end (List);
|
|
//
|
|
// Set status accordingly
|
|
//
|
|
if (mStatus < STATUS_WARNING) {
|
|
mStatus = STATUS_WARNING;
|
|
}
|
|
}
|
|
|
|
void
|
|
Warning (
|
|
INT8 *FileName,
|
|
UINT32 LineNumber,
|
|
UINT32 MessageCode,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Print a warning message.
|
|
|
|
Arguments:
|
|
FileName - name of the file where the warning was detected, or the name
|
|
of the application that detected the warning
|
|
|
|
LineNumber - the line number where the warning was detected (parsers).
|
|
0 should be specified if the utility is not a parser.
|
|
|
|
MessageCode - an application-specific warning code that can be referenced in
|
|
other documentation.
|
|
|
|
Text - the text in question (parsers)
|
|
|
|
MsgFmt - the format string for the warning message. Can contain formatting
|
|
controls for use with varargs.
|
|
|
|
...
|
|
|
|
Returns:
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
va_list List;
|
|
mWarningCount++;
|
|
va_start (List, MsgFmt);
|
|
PrintMessage ("warning", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
|
va_end (List);
|
|
//
|
|
// Set status accordingly
|
|
//
|
|
if (mStatus < STATUS_WARNING) {
|
|
mStatus = STATUS_WARNING;
|
|
}
|
|
}
|
|
|
|
void
|
|
DebugMsg (
|
|
INT8 *FileName,
|
|
UINT32 LineNumber,
|
|
UINT32 MsgMask,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Print a warning message.
|
|
|
|
Arguments:
|
|
FileName - typically the name of the utility printing the debug message, but
|
|
can be the name of a file being parsed.
|
|
|
|
LineNumber - the line number in FileName (parsers)
|
|
|
|
MsgMask - an application-specific bitmask that, in combination with mDebugMsgMask,
|
|
determines if the debug message gets printed.
|
|
|
|
Text - the text in question (parsers)
|
|
|
|
MsgFmt - the format string for the debug message. Can contain formatting
|
|
controls for use with varargs.
|
|
|
|
...
|
|
Returns:
|
|
None.
|
|
|
|
--*/
|
|
{
|
|
va_list List;
|
|
//
|
|
// If the debug mask is not applicable, then do nothing.
|
|
//
|
|
if ((MsgMask != 0) && ((mDebugMsgMask & MsgMask) == 0)) {
|
|
return ;
|
|
}
|
|
|
|
va_start (List, MsgFmt);
|
|
PrintMessage ("debug", FileName, LineNumber, 0, Text, MsgFmt, List);
|
|
va_end (List);
|
|
}
|
|
|
|
static
|
|
void
|
|
PrintMessage (
|
|
INT8 *Type,
|
|
INT8 *FileName,
|
|
UINT32 LineNumber,
|
|
UINT32 MessageCode,
|
|
INT8 *Text,
|
|
INT8 *MsgFmt,
|
|
va_list List
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Worker routine for all the utility printing services. Prints the message in
|
|
a format that Visual Studio will find when scanning build outputs for
|
|
errors or warnings.
|
|
|
|
Arguments:
|
|
Type - "warning" or "error" string to insert into the message to be
|
|
printed. The first character of this string (converted to uppercase)
|
|
is used to preceed the MessageCode value in the output string.
|
|
|
|
FileName - name of the file where the warning was detected, or the name
|
|
of the application that detected the warning
|
|
|
|
LineNumber - the line number where the warning was detected (parsers).
|
|
0 should be specified if the utility is not a parser.
|
|
|
|
MessageCode - an application-specific warning code that can be referenced in
|
|
other documentation.
|
|
|
|
Text - part of the message to print
|
|
|
|
MsgFmt - the format string for the message. Can contain formatting
|
|
controls for use with varargs.
|
|
|
|
List - Variable function parameter list.
|
|
Returns:
|
|
None.
|
|
|
|
Notes:
|
|
If FileName == NULL then this utility will use the string passed into SetUtilityName().
|
|
|
|
LineNumber is only used if the caller is a parser, in which case FileName refers to the
|
|
file being parsed.
|
|
|
|
Text and MsgFmt are both optional, though it would be of little use calling this function with
|
|
them both NULL.
|
|
|
|
Output will typically be of the form:
|
|
<FileName>(<LineNumber>) : <Type> <Type[0]><MessageCode>: <Text> : <MsgFmt>
|
|
|
|
Parser (LineNumber != 0)
|
|
VfrCompile.cpp(330) : error E2660: AddVfrDataStructField : function does not take 2 parameters
|
|
Generic utility (LineNumber == 0)
|
|
UtilityName : error E1234 : Text string : MsgFmt string and args
|
|
|
|
--*/
|
|
{
|
|
INT8 Line[MAX_LINE_LEN];
|
|
INT8 Line2[MAX_LINE_LEN];
|
|
INT8 *Cptr;
|
|
//
|
|
// If given a filename, then add it (and the line number) to the string.
|
|
// If there's no filename, then use the program name if provided.
|
|
//
|
|
if (FileName != NULL) {
|
|
Cptr = FileName;
|
|
} else if (mUtilityName[0] != 0) {
|
|
Cptr = mUtilityName;
|
|
} else {
|
|
Cptr = "Unknown utility";
|
|
}
|
|
|
|
strcpy (Line, Cptr);
|
|
if (LineNumber != 0) {
|
|
sprintf (Line2, "(%d)", LineNumber);
|
|
strcat (Line, Line2);
|
|
}
|
|
//
|
|
// Have to print an error code or Visual Studio won't find the
|
|
// message for you. It has to be decimal digits too.
|
|
//
|
|
sprintf (Line2, " : %s %c%04d", Type, toupper (Type[0]), MessageCode);
|
|
strcat (Line, Line2);
|
|
fprintf (stdout, "%s", Line);
|
|
//
|
|
// If offending text was provided, then print it
|
|
//
|
|
if (Text != NULL) {
|
|
fprintf (stdout, ": %s ", Text);
|
|
}
|
|
//
|
|
// Print formatted message if provided
|
|
//
|
|
if (MsgFmt != NULL) {
|
|
vsprintf (Line2, MsgFmt, List);
|
|
fprintf (stdout, ": %s", Line2);
|
|
}
|
|
|
|
fprintf (stdout, "\n");
|
|
}
|
|
|
|
void
|
|
ParserSetPosition (
|
|
INT8 *SourceFileName,
|
|
UINT32 LineNum
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Set the position in a file being parsed. This can be used to
|
|
print error messages deeper down in a parser.
|
|
|
|
Arguments:
|
|
SourceFileName - name of the source file being parsed
|
|
LineNum - line number of the source file being parsed
|
|
|
|
Returns:
|
|
NA
|
|
|
|
--*/
|
|
{
|
|
mSourceFileName = SourceFileName;
|
|
mSourceFileLineNum = LineNum;
|
|
}
|
|
|
|
void
|
|
SetUtilityName (
|
|
INT8 *UtilityName
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
All printed error/warning/debug messages follow the same format, and
|
|
typically will print a filename or utility name followed by the error
|
|
text. However if a filename is not passed to the print routines, then
|
|
they'll print the utility name if you call this function early in your
|
|
app to set the utility name.
|
|
|
|
Arguments:
|
|
UtilityName - name of the utility, which will be printed with all
|
|
error/warning/debug messags.
|
|
|
|
Returns:
|
|
NA
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// Save the name of the utility in our local variable. Make sure its
|
|
// length does not exceed our buffer.
|
|
//
|
|
if (UtilityName != NULL) {
|
|
if (strlen (UtilityName) >= sizeof (mUtilityName)) {
|
|
Error (UtilityName, 0, 0, "application error", "utility name length exceeds internal buffer size");
|
|
strncpy (mUtilityName, UtilityName, sizeof (mUtilityName) - 1);
|
|
mUtilityName[sizeof (mUtilityName) - 1] = 0;
|
|
return ;
|
|
} else {
|
|
strcpy (mUtilityName, UtilityName);
|
|
}
|
|
} else {
|
|
Error (NULL, 0, 0, "application error", "SetUtilityName() called with NULL utility name");
|
|
}
|
|
}
|
|
|
|
STATUS
|
|
GetUtilityStatus (
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
When you call Error() or Warning(), this module keeps track of it and
|
|
sets a local mStatus to STATUS_ERROR or STATUS_WARNING. When the utility
|
|
exits, it can call this function to get the status and use it as a return
|
|
value.
|
|
|
|
Arguments:
|
|
None.
|
|
|
|
Returns:
|
|
Worst-case status reported, as defined by which print function was called.
|
|
|
|
--*/
|
|
{
|
|
return mStatus;
|
|
}
|