← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox-lts-xenial/trusty-proposed

« back to all changes in this revision

Viewing changes to src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/Common/EfiUtilityMsgs.c

  • Committer: Package Import Robot
  • Author(s): Gianfranco Costamagna
  • Date: 2016-02-23 14:28:26 UTC
  • Revision ID: package-import@ubuntu.com-20160223142826-bdu69el2z6wa2a44
Tags: upstream-4.3.36-dfsg
Import upstream version 4.3.36-dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/Common/EfiUtilityMsgs.c
 
1
/** @file
 
2
 
 
3
Copyright (c) 2004 - 2008, Intel Corporation. All rights reserved.<BR>
 
4
This program and the accompanying materials
 
5
are licensed and made available under the terms and conditions of the BSD License
 
6
which accompanies this distribution.  The full text of the license may be found at
 
7
http://opensource.org/licenses/bsd-license.php
 
8
 
 
9
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
 
10
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 
11
 
 
12
Module Name:
 
13
 
 
14
  EfiUtilityMsgs.c
 
15
 
 
16
Abstract:
 
17
 
 
18
  EFI tools utility functions to display warning, error, and informational
 
19
  messages.
 
20
 
 
21
--*/
 
22
 
 
23
#include <stdio.h>
 
24
#include <string.h>
 
25
#include <ctype.h>
 
26
#include <stdarg.h>
 
27
#include <time.h>
 
28
 
 
29
#include "EfiUtilityMsgs.h"
 
30
 
 
31
//
 
32
// Declare module globals for keeping track of the the utility's
 
33
// name and other settings.
 
34
//
 
35
STATIC STATUS mStatus                 = STATUS_SUCCESS;
 
36
STATIC CHAR8  mUtilityName[50]        = { 0 };
 
37
STATIC UINT64 mPrintLogLevel          = INFO_LOG_LEVEL;
 
38
STATIC CHAR8  *mSourceFileName        = NULL;
 
39
STATIC UINT32 mSourceFileLineNum      = 0;
 
40
STATIC UINT32 mErrorCount             = 0;
 
41
STATIC UINT32 mWarningCount           = 0;
 
42
STATIC UINT32 mMaxErrors              = 0;
 
43
STATIC UINT32 mMaxWarnings            = 0;
 
44
STATIC UINT32 mMaxWarningsPlusErrors  = 0;
 
45
STATIC INT8   mPrintLimitsSet         = 0;
 
46
 
 
47
STATIC
 
48
VOID
 
49
PrintLimitExceeded (
 
50
  VOID
 
51
  );
 
52
 
 
53
VOID
 
54
Error (
 
55
  CHAR8   *FileName,
 
56
  UINT32  LineNumber,
 
57
  UINT32  MessageCode,
 
58
  CHAR8   *Text,
 
59
  CHAR8   *MsgFmt,
 
60
  ...
 
61
  )
 
62
/*++
 
63
 
 
64
Routine Description:
 
65
  Prints an error message.
 
66
 
 
67
Arguments:
 
68
  All arguments are optional, though the printed message may be useless if
 
69
  at least something valid is not specified.
 
70
 
 
71
  FileName - name of the file or application. If not specified, then the
 
72
             utilty name (as set by the utility calling SetUtilityName()
 
73
             earlier) is used. Otherwise "Unknown utility" is used.
 
74
 
 
75
  LineNumber - the line number of error, typically used by parsers. If the
 
76
               utility is not a parser, then 0 should be specified. Otherwise
 
77
               the FileName and LineNumber info can be used to cause
 
78
               MS Visual Studio to jump to the error.
 
79
 
 
80
  MessageCode - an application-specific error code that can be referenced in
 
81
              other documentation.
 
82
 
 
83
  Text        - the text in question, typically used by parsers.
 
84
 
 
85
  MsgFmt - the format string for the error message. Can contain formatting
 
86
           controls for use with the varargs.
 
87
 
 
88
Returns:
 
89
  None.
 
90
 
 
91
Notes:
 
92
  We print the following (similar to the Warn() and Debug()
 
93
  W
 
94
  Typical error/warning message format:
 
95
 
 
96
  bin\VfrCompile.cpp(330) : error C2660: 'AddVfrDataStructField' : function does not take 2 parameters
 
97
 
 
98
  BUGBUG -- these three utility functions are almost identical, and
 
99
  should be modified to share code.
 
100
 
 
101
  Visual Studio does not find error messages with:
 
102
 
 
103
     " error :"
 
104
     " error 1:"
 
105
     " error c1:"
 
106
     " error 1000:"
 
107
     " error c100:"
 
108
 
 
109
  It does find:
 
110
     " error c1000:"
 
111
--*/
 
112
{
 
113
  va_list List;
 
114
  //
 
115
  // If limits have been set, then check that we have not exceeded them
 
116
  //
 
117
  if (mPrintLimitsSet) {
 
118
    //
 
119
    // See if we've exceeded our total count
 
120
    //
 
121
    if (mMaxWarningsPlusErrors != 0) {
 
122
      if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
 
123
        PrintLimitExceeded ();
 
124
        return ;
 
125
      }
 
126
    }
 
127
    //
 
128
    // See if we've exceeded our error count
 
129
    //
 
130
    if (mMaxErrors != 0) {
 
131
      if (mErrorCount > mMaxErrors) {
 
132
        PrintLimitExceeded ();
 
133
        return ;
 
134
      }
 
135
    }
 
136
  }
 
137
 
 
138
  mErrorCount++;
 
139
  va_start (List, MsgFmt);
 
140
  PrintMessage ("ERROR", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
 
141
  va_end (List);
 
142
}
 
143
 
 
144
VOID
 
145
ParserError (
 
146
  UINT32  MessageCode,
 
147
  CHAR8   *Text,
 
148
  CHAR8   *MsgFmt,
 
149
  ...
 
150
  )
 
151
/*++
 
152
 
 
153
Routine Description:
 
154
  Print a parser error, using the source file name and line number
 
155
  set by a previous call to SetParserPosition().
 
156
 
 
157
Arguments:
 
158
  MessageCode   - application-specific error code
 
159
  Text          - text to print in the error message
 
160
  MsgFmt        - format string to print at the end of the error message
 
161
 
 
162
Returns:
 
163
  NA
 
164
 
 
165
--*/
 
166
{
 
167
  va_list List;
 
168
  //
 
169
  // If limits have been set, then check them
 
170
  //
 
171
  if (mPrintLimitsSet) {
 
172
    //
 
173
    // See if we've exceeded our total count
 
174
    //
 
175
    if (mMaxWarningsPlusErrors != 0) {
 
176
      if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
 
177
        PrintLimitExceeded ();
 
178
        return ;
 
179
      }
 
180
    }
 
181
    //
 
182
    // See if we've exceeded our error count
 
183
    //
 
184
    if (mMaxErrors != 0) {
 
185
      if (mErrorCount > mMaxErrors) {
 
186
        PrintLimitExceeded ();
 
187
        return ;
 
188
      }
 
189
    }
 
190
  }
 
191
 
 
192
  mErrorCount++;
 
193
  va_start (List, MsgFmt);
 
194
  PrintMessage ("ERROR", mSourceFileName, mSourceFileLineNum, MessageCode, Text, MsgFmt, List);
 
195
  va_end (List);
 
196
}
 
197
 
 
198
VOID
 
199
ParserWarning (
 
200
  UINT32  ErrorCode,
 
201
  CHAR8   *OffendingText,
 
202
  CHAR8   *MsgFmt,
 
203
  ...
 
204
  )
 
205
/*++
 
206
 
 
207
Routine Description:
 
208
  Print a parser warning, using the source file name and line number
 
209
  set by a previous call to SetParserPosition().
 
210
 
 
211
Arguments:
 
212
  ErrorCode     - application-specific error code
 
213
  OffendingText - text to print in the warning message
 
214
  MsgFmt        - format string to print at the end of the warning message
 
215
 
 
216
Returns:
 
217
  NA
 
218
 
 
219
--*/
 
220
{
 
221
  va_list List;
 
222
  //
 
223
  // If limits have been set, then check them
 
224
  //
 
225
  if (mPrintLimitsSet) {
 
226
    //
 
227
    // See if we've exceeded our total count
 
228
    //
 
229
    if (mMaxWarningsPlusErrors != 0) {
 
230
      if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
 
231
        PrintLimitExceeded ();
 
232
        return ;
 
233
      }
 
234
    }
 
235
    //
 
236
    // See if we've exceeded our warning count
 
237
    //
 
238
    if (mMaxWarnings != 0) {
 
239
      if (mWarningCount > mMaxWarnings) {
 
240
        PrintLimitExceeded ();
 
241
        return ;
 
242
      }
 
243
    }
 
244
  }
 
245
 
 
246
  mWarningCount++;
 
247
  va_start (List, MsgFmt);
 
248
  PrintMessage ("WARNING", mSourceFileName, mSourceFileLineNum, ErrorCode, OffendingText, MsgFmt, List);
 
249
  va_end (List);
 
250
  //
 
251
  // Don't set warning status accordingly
 
252
  //
 
253
  //  if (mStatus < STATUS_WARNING) {
 
254
  //    mStatus = STATUS_WARNING;
 
255
  //  }
 
256
}
 
257
 
 
258
VOID
 
259
Warning (
 
260
  CHAR8   *FileName,
 
261
  UINT32  LineNumber,
 
262
  UINT32  MessageCode,
 
263
  CHAR8   *Text,
 
264
  CHAR8   *MsgFmt,
 
265
  ...
 
266
  )
 
267
/*++
 
268
 
 
269
Routine Description:
 
270
  Print a warning message.
 
271
 
 
272
Arguments:
 
273
  FileName    - name of the file where the warning was detected, or the name
 
274
                of the application that detected the warning
 
275
 
 
276
  LineNumber  - the line number where the warning was detected (parsers).
 
277
                0 should be specified if the utility is not a parser.
 
278
 
 
279
  MessageCode - an application-specific warning code that can be referenced in
 
280
                other documentation.
 
281
 
 
282
  Text        - the text in question (parsers)
 
283
 
 
284
  MsgFmt      - the format string for the warning message. Can contain formatting
 
285
                controls for use with varargs.
 
286
 
 
287
Returns:
 
288
  None.
 
289
 
 
290
--*/
 
291
{
 
292
  va_list List;
 
293
 
 
294
  //
 
295
  // Current Print Level not output warning information.
 
296
  //
 
297
  if (WARNING_LOG_LEVEL < mPrintLogLevel) {
 
298
    return;
 
299
  }
 
300
  //
 
301
  // If limits have been set, then check them
 
302
  //
 
303
  if (mPrintLimitsSet) {
 
304
    //
 
305
    // See if we've exceeded our total count
 
306
    //
 
307
    if (mMaxWarningsPlusErrors != 0) {
 
308
      if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
 
309
        PrintLimitExceeded ();
 
310
        return ;
 
311
      }
 
312
    }
 
313
    //
 
314
    // See if we've exceeded our warning count
 
315
    //
 
316
    if (mMaxWarnings != 0) {
 
317
      if (mWarningCount > mMaxWarnings) {
 
318
        PrintLimitExceeded ();
 
319
        return ;
 
320
      }
 
321
    }
 
322
  }
 
323
 
 
324
  mWarningCount++;
 
325
  va_start (List, MsgFmt);
 
326
  PrintMessage ("WARNING", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
 
327
  va_end (List);
 
328
}
 
329
 
 
330
VOID
 
331
DebugMsg (
 
332
  CHAR8   *FileName,
 
333
  UINT32  LineNumber,
 
334
  UINT64  MsgLevel,
 
335
  CHAR8   *Text,
 
336
  CHAR8   *MsgFmt,
 
337
  ...
 
338
  )
 
339
/*++
 
340
 
 
341
Routine Description:
 
342
  Print a Debug message.
 
343
 
 
344
Arguments:
 
345
  FileName    - typically the name of the utility printing the debug message, but
 
346
                can be the name of a file being parsed.
 
347
 
 
348
  LineNumber  - the line number in FileName (parsers)
 
349
 
 
350
  MsgLevel    - Debug message print level (0~9)
 
351
 
 
352
  Text        - the text in question (parsers)
 
353
 
 
354
  MsgFmt      - the format string for the debug message. Can contain formatting
 
355
                controls for use with varargs.
 
356
 
 
357
Returns:
 
358
  None.
 
359
 
 
360
--*/
 
361
{
 
362
  va_list List;
 
363
  //
 
364
  // If the debug level is less than current print level, then do nothing.
 
365
  //
 
366
  if (MsgLevel < mPrintLogLevel) {
 
367
    return ;
 
368
  }
 
369
 
 
370
  va_start (List, MsgFmt);
 
371
  PrintMessage ("DEBUG", FileName, LineNumber, 0, Text, MsgFmt, List);
 
372
  va_end (List);
 
373
}
 
374
 
 
375
VOID
 
376
PrintMessage (
 
377
  CHAR8   *Type,
 
378
  CHAR8   *FileName,
 
379
  UINT32  LineNumber,
 
380
  UINT32  MessageCode,
 
381
  CHAR8   *Text,
 
382
  CHAR8   *MsgFmt,
 
383
  va_list List
 
384
  )
 
385
/*++
 
386
 
 
387
Routine Description:
 
388
  Worker routine for all the utility printing services. Prints the message in
 
389
  a format that Visual Studio will find when scanning build outputs for
 
390
  errors or warnings.
 
391
 
 
392
Arguments:
 
393
  Type        - "warning" or "error" string to insert into the message to be
 
394
                printed. The first character of this string (converted to uppercase)
 
395
                is used to preceed the MessageCode value in the output string.
 
396
 
 
397
  FileName    - name of the file where the warning was detected, or the name
 
398
                of the application that detected the warning
 
399
 
 
400
  LineNumber  - the line number where the warning was detected (parsers).
 
401
                0 should be specified if the utility is not a parser.
 
402
 
 
403
  MessageCode - an application-specific warning code that can be referenced in
 
404
                other documentation.
 
405
 
 
406
  Text        - part of the message to print
 
407
 
 
408
  MsgFmt      - the format string for the message. Can contain formatting
 
409
                controls for use with varargs.
 
410
  List        - the variable list.
 
411
 
 
412
Returns:
 
413
  None.
 
414
 
 
415
Notes:
 
416
  If FileName == NULL then this utility will use the string passed into SetUtilityName().
 
417
 
 
418
  LineNumber is only used if the caller is a parser, in which case FileName refers to the
 
419
  file being parsed.
 
420
 
 
421
  Text and MsgFmt are both optional, though it would be of little use calling this function with
 
422
  them both NULL.
 
423
 
 
424
  Output will typically be of the form:
 
425
    <FileName>(<LineNumber>) : <Type> <Type[0]><MessageCode>: <Text> : <MsgFmt>
 
426
 
 
427
    Parser (LineNumber != 0)
 
428
      VfrCompile.cpp(330) : error E2660: AddVfrDataStructField : function does not take 2 parameters
 
429
    Generic utility (LineNumber == 0)
 
430
      UtilityName : error E1234 : Text string : MsgFmt string and args
 
431
 
 
432
--*/
 
433
{
 
434
  CHAR8       Line[MAX_LINE_LEN];
 
435
  CHAR8       Line2[MAX_LINE_LEN];
 
436
  CHAR8       *Cptr;
 
437
  struct tm   *NewTime;
 
438
  time_t      CurrentTime;
 
439
 
 
440
  //
 
441
  // init local variable
 
442
  //
 
443
  Line[0] = '\0';
 
444
  Line2[0] = '\0';
 
445
 
 
446
  //
 
447
  // If given a filename, then add it (and the line number) to the string.
 
448
  // If there's no filename, then use the program name if provided.
 
449
  //
 
450
  if (FileName != NULL) {
 
451
    Cptr = FileName;
 
452
  } else {
 
453
    Cptr = NULL;
 
454
  }
 
455
 
 
456
  if (strcmp (Type, "DEBUG") == 0) {
 
457
    //
 
458
    // Debug Message requires current time.
 
459
    //
 
460
    time (&CurrentTime);
 
461
    NewTime = localtime (&CurrentTime);
 
462
    fprintf (stdout, "%04d-%02d-%02d %02d:%02d:%02d",
 
463
                     NewTime->tm_year + 1900,
 
464
                     NewTime->tm_mon + 1,
 
465
                     NewTime->tm_mday,
 
466
                     NewTime->tm_hour,
 
467
                     NewTime->tm_min,
 
468
                     NewTime->tm_sec
 
469
                     );
 
470
    if (Cptr != NULL) {
 
471
      sprintf (Line, ": %s", Cptr);
 
472
      if (LineNumber != 0) {
 
473
        sprintf (Line2, "(%u)", (unsigned) LineNumber);
 
474
        strcat (Line, Line2);
 
475
      }
 
476
    }
 
477
  } else {
 
478
    //
 
479
    // Error and Warning Information.
 
480
    //
 
481
    if (Cptr != NULL) {
 
482
      if (mUtilityName[0] != '\0') {
 
483
        fprintf (stdout, "%s...\n", mUtilityName);
 
484
      }
 
485
      sprintf (Line, "%s", Cptr);
 
486
      if (LineNumber != 0) {
 
487
        sprintf (Line2, "(%u)", (unsigned) LineNumber);
 
488
        strcat (Line, Line2);
 
489
      }
 
490
    } else {
 
491
      if (mUtilityName[0] != '\0') {
 
492
        sprintf (Line, "%s", mUtilityName);
 
493
      }
 
494
    }
 
495
 
 
496
    if (strcmp (Type, "ERROR") == 0) {
 
497
      //
 
498
      // Set status accordingly for ERROR information.
 
499
      //
 
500
      if (mStatus < STATUS_ERROR) {
 
501
        mStatus = STATUS_ERROR;
 
502
      }
 
503
    }
 
504
  }
 
505
 
 
506
  //
 
507
  // Have to print an error code or Visual Studio won't find the
 
508
  // message for you. It has to be decimal digits too.
 
509
  //
 
510
  if (MessageCode != 0) {
 
511
    sprintf (Line2, ": %s %04u", Type, (unsigned) MessageCode);
 
512
  } else {
 
513
    sprintf (Line2, ": %s", Type);
 
514
  }
 
515
  strcat (Line, Line2);
 
516
  fprintf (stdout, "%s", Line);
 
517
  //
 
518
  // If offending text was provided, then print it
 
519
  //
 
520
  if (Text != NULL) {
 
521
    fprintf (stdout, ": %s", Text);
 
522
  }
 
523
  fprintf (stdout, "\n");
 
524
 
 
525
  //
 
526
  // Print formatted message if provided
 
527
  //
 
528
  if (MsgFmt != NULL) {
 
529
    vsprintf (Line2, MsgFmt, List);
 
530
    fprintf (stdout, "  %s\n", Line2);
 
531
  }
 
532
 
 
533
}
 
534
 
 
535
STATIC
 
536
VOID
 
537
PrintSimpleMessage (
 
538
  CHAR8   *MsgFmt,
 
539
  va_list List
 
540
  )
 
541
/*++
 
542
Routine Description:
 
543
  Print message into stdout.
 
544
 
 
545
Arguments:
 
546
  MsgFmt      - the format string for the message. Can contain formatting
 
547
                controls for use with varargs.
 
548
  List        - the variable list.
 
549
 
 
550
Returns:
 
551
  None.
 
552
--*/
 
553
{
 
554
  CHAR8       Line[MAX_LINE_LEN];
 
555
  //
 
556
  // Print formatted message if provided
 
557
  //
 
558
  if (MsgFmt != NULL) {
 
559
    vsprintf (Line, MsgFmt, List);
 
560
    fprintf (stdout, "%s\n", Line);
 
561
  }
 
562
}
 
563
 
 
564
VOID
 
565
ParserSetPosition (
 
566
  CHAR8   *SourceFileName,
 
567
  UINT32  LineNum
 
568
  )
 
569
/*++
 
570
 
 
571
Routine Description:
 
572
  Set the position in a file being parsed. This can be used to
 
573
  print error messages deeper down in a parser.
 
574
 
 
575
Arguments:
 
576
  SourceFileName - name of the source file being parsed
 
577
  LineNum        - line number of the source file being parsed
 
578
 
 
579
Returns:
 
580
  NA
 
581
 
 
582
--*/
 
583
{
 
584
  mSourceFileName     = SourceFileName;
 
585
  mSourceFileLineNum  = LineNum;
 
586
}
 
587
 
 
588
VOID
 
589
SetUtilityName (
 
590
  CHAR8   *UtilityName
 
591
  )
 
592
/*++
 
593
 
 
594
Routine Description:
 
595
  All printed error/warning/debug messages follow the same format, and
 
596
  typically will print a filename or utility name followed by the error
 
597
  text. However if a filename is not passed to the print routines, then
 
598
  they'll print the utility name if you call this function early in your
 
599
  app to set the utility name.
 
600
 
 
601
Arguments:
 
602
  UtilityName  -  name of the utility, which will be printed with all
 
603
                  error/warning/debug messags.
 
604
 
 
605
Returns:
 
606
  NA
 
607
 
 
608
--*/
 
609
{
 
610
  //
 
611
  // Save the name of the utility in our local variable. Make sure its
 
612
  // length does not exceed our buffer.
 
613
  //
 
614
  if (UtilityName != NULL) {
 
615
    if (strlen (UtilityName) >= sizeof (mUtilityName)) {
 
616
      Error (UtilityName, 0, 0, "application error", "utility name length exceeds internal buffer size");
 
617
      strncpy (mUtilityName, UtilityName, sizeof (mUtilityName) - 1);
 
618
      mUtilityName[sizeof (mUtilityName) - 1] = 0;
 
619
      return ;
 
620
    } else {
 
621
      strcpy (mUtilityName, UtilityName);
 
622
    }
 
623
  } else {
 
624
    Error (NULL, 0, 0, "application error", "SetUtilityName() called with NULL utility name");
 
625
  }
 
626
}
 
627
 
 
628
STATUS
 
629
GetUtilityStatus (
 
630
  VOID
 
631
  )
 
632
/*++
 
633
 
 
634
Routine Description:
 
635
  When you call Error() or Warning(), this module keeps track of it and
 
636
  sets a local mStatus to STATUS_ERROR or STATUS_WARNING. When the utility
 
637
  exits, it can call this function to get the status and use it as a return
 
638
  value.
 
639
 
 
640
Arguments:
 
641
  None.
 
642
 
 
643
Returns:
 
644
  Worst-case status reported, as defined by which print function was called.
 
645
 
 
646
--*/
 
647
{
 
648
  return mStatus;
 
649
}
 
650
 
 
651
VOID
 
652
SetPrintLevel (
 
653
  UINT64  LogLevel
 
654
  )
 
655
/*++
 
656
 
 
657
Routine Description:
 
658
  Set the printing message Level. This is used by the PrintMsg() function
 
659
  to determine when/if a message should be printed.
 
660
 
 
661
Arguments:
 
662
  LogLevel  - 0~50 to specify the different level message.
 
663
 
 
664
Returns:
 
665
  NA
 
666
 
 
667
--*/
 
668
{
 
669
  mPrintLogLevel = LogLevel;
 
670
}
 
671
 
 
672
VOID
 
673
VerboseMsg (
 
674
  CHAR8   *MsgFmt,
 
675
  ...
 
676
  )
 
677
/*++
 
678
 
 
679
Routine Description:
 
680
  Print a verbose level message.
 
681
 
 
682
Arguments:
 
683
  MsgFmt      - the format string for the message. Can contain formatting
 
684
                controls for use with varargs.
 
685
  List        - the variable list.
 
686
 
 
687
Returns:
 
688
  NA
 
689
 
 
690
--*/
 
691
{
 
692
  va_list List;
 
693
  //
 
694
  // If the debug level is less than current print level, then do nothing.
 
695
  //
 
696
  if (VERBOSE_LOG_LEVEL < mPrintLogLevel) {
 
697
    return ;
 
698
  }
 
699
 
 
700
  va_start (List, MsgFmt);
 
701
  PrintSimpleMessage (MsgFmt, List);
 
702
  va_end (List);
 
703
}
 
704
 
 
705
VOID
 
706
NormalMsg (
 
707
  CHAR8   *MsgFmt,
 
708
  ...
 
709
  )
 
710
/*++
 
711
 
 
712
Routine Description:
 
713
  Print a default level message.
 
714
 
 
715
Arguments:
 
716
  MsgFmt      - the format string for the message. Can contain formatting
 
717
                controls for use with varargs.
 
718
  List        - the variable list.
 
719
 
 
720
Returns:
 
721
  NA
 
722
 
 
723
--*/
 
724
{
 
725
  va_list List;
 
726
  //
 
727
  // If the debug level is less than current print level, then do nothing.
 
728
  //
 
729
  if (INFO_LOG_LEVEL < mPrintLogLevel) {
 
730
    return ;
 
731
  }
 
732
 
 
733
  va_start (List, MsgFmt);
 
734
  PrintSimpleMessage (MsgFmt, List);
 
735
  va_end (List);
 
736
}
 
737
 
 
738
VOID
 
739
KeyMsg (
 
740
  CHAR8   *MsgFmt,
 
741
  ...
 
742
  )
 
743
/*++
 
744
 
 
745
Routine Description:
 
746
  Print a key level message.
 
747
 
 
748
Arguments:
 
749
  MsgFmt      - the format string for the message. Can contain formatting
 
750
                controls for use with varargs.
 
751
  List        - the variable list.
 
752
 
 
753
Returns:
 
754
  NA
 
755
 
 
756
--*/
 
757
{
 
758
  va_list List;
 
759
  //
 
760
  // If the debug level is less than current print level, then do nothing.
 
761
  //
 
762
  if (KEY_LOG_LEVEL < mPrintLogLevel) {
 
763
    return ;
 
764
  }
 
765
 
 
766
  va_start (List, MsgFmt);
 
767
  PrintSimpleMessage (MsgFmt, List);
 
768
  va_end (List);
 
769
}
 
770
 
 
771
VOID
 
772
SetPrintLimits (
 
773
  UINT32  MaxErrors,
 
774
  UINT32  MaxWarnings,
 
775
  UINT32  MaxWarningsPlusErrors
 
776
  )
 
777
/*++
 
778
 
 
779
Routine Description:
 
780
  Set the limits of how many errors, warnings, and errors+warnings
 
781
  we will print.
 
782
 
 
783
Arguments:
 
784
  MaxErrors       - maximum number of error messages to print
 
785
  MaxWarnings     - maximum number of warning messages to print
 
786
  MaxWarningsPlusErrors
 
787
                  - maximum number of errors+warnings to print
 
788
 
 
789
Returns:
 
790
  NA
 
791
 
 
792
--*/
 
793
{
 
794
  mMaxErrors              = MaxErrors;
 
795
  mMaxWarnings            = MaxWarnings;
 
796
  mMaxWarningsPlusErrors  = MaxWarningsPlusErrors;
 
797
  mPrintLimitsSet         = 1;
 
798
}
 
799
 
 
800
STATIC
 
801
VOID
 
802
PrintLimitExceeded (
 
803
  VOID
 
804
  )
 
805
{
 
806
  STATIC INT8 mPrintLimitExceeded = 0;
 
807
  //
 
808
  // If we've already printed the message, do nothing. Otherwise
 
809
  // temporarily increase our print limits so we can pass one
 
810
  // more message through.
 
811
  //
 
812
  if (mPrintLimitExceeded == 0) {
 
813
    mPrintLimitExceeded++;
 
814
    mMaxErrors++;
 
815
    mMaxWarnings++;
 
816
    mMaxWarningsPlusErrors++;
 
817
    Error (NULL, 0, 0, "error/warning print limit exceeded", NULL);
 
818
    mMaxErrors--;
 
819
    mMaxWarnings--;
 
820
    mMaxWarningsPlusErrors--;
 
821
  }
 
822
}
 
823
 
 
824
#if 0
 
825
VOID
 
826
TestUtilityMessages (
 
827
  VOID
 
828
  )
 
829
{
 
830
  CHAR8 *ArgStr = "ArgString";
 
831
  int   ArgInt;
 
832
 
 
833
  ArgInt  = 0x12345678;
 
834
  //
 
835
  // Test without setting utility name
 
836
  //
 
837
  fprintf (stdout, "* Testing without setting utility name\n");
 
838
  fprintf (stdout, "** Test debug message not printed\n");
 
839
  DebugMsg (NULL, 0, 0x00000001, NULL, NULL);
 
840
  fprintf (stdout, "** Test warning with two strings and two args\n");
 
841
  Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
842
  fprintf (stdout, "** Test error with two strings and two args\n");
 
843
  Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
844
  fprintf (stdout, "** Test parser warning with nothing\n");
 
845
  ParserWarning (0, NULL, NULL);
 
846
  fprintf (stdout, "** Test parser error with nothing\n");
 
847
  ParserError (0, NULL, NULL);
 
848
  //
 
849
  // Test with utility name set now
 
850
  //
 
851
  fprintf (stdout, "** Testingin with utility name set\n");
 
852
  SetUtilityName ("MyUtilityName");
 
853
  //
 
854
  // Test debug prints
 
855
  //
 
856
  SetDebugMsgMask (2);
 
857
  fprintf (stdout, "** Test debug message with one string\n");
 
858
  DebugMsg (NULL, 0, 0x00000002, "Text1", NULL);
 
859
  fprintf (stdout, "** Test debug message with one string\n");
 
860
  DebugMsg (NULL, 0, 0x00000002, NULL, "Text2");
 
861
  fprintf (stdout, "** Test debug message with two strings\n");
 
862
  DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2");
 
863
  fprintf (stdout, "** Test debug message with two strings and two args\n");
 
864
  DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
865
  //
 
866
  // Test warning prints
 
867
  //
 
868
  fprintf (stdout, "** Test warning with no strings\n");
 
869
  Warning (NULL, 0, 1234, NULL, NULL);
 
870
  fprintf (stdout, "** Test warning with one string\n");
 
871
  Warning (NULL, 0, 1234, "Text1", NULL);
 
872
  fprintf (stdout, "** Test warning with one string\n");
 
873
  Warning (NULL, 0, 1234, NULL, "Text2");
 
874
  fprintf (stdout, "** Test warning with two strings and two args\n");
 
875
  Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
876
  //
 
877
  // Test error prints
 
878
  //
 
879
  fprintf (stdout, "** Test error with no strings\n");
 
880
  Error (NULL, 0, 1234, NULL, NULL);
 
881
  fprintf (stdout, "** Test error with one string\n");
 
882
  Error (NULL, 0, 1234, "Text1", NULL);
 
883
  fprintf (stdout, "** Test error with one string\n");
 
884
  Error (NULL, 0, 1234, NULL, "Text2");
 
885
  fprintf (stdout, "** Test error with two strings and two args\n");
 
886
  Error (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
887
  //
 
888
  // Test parser prints
 
889
  //
 
890
  fprintf (stdout, "** Test parser errors\n");
 
891
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
892
  ParserError (1234, NULL, NULL);
 
893
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
894
  ParserError (1234, "Text1", NULL);
 
895
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
896
  ParserError (1234, NULL, "Text2");
 
897
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
898
  ParserError (1234, "Text1", "Text2");
 
899
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
900
  ParserError (1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
901
 
 
902
  fprintf (stdout, "** Test parser warnings\n");
 
903
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
904
  ParserWarning (4321, NULL, NULL);
 
905
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
906
  ParserWarning (4321, "Text1", NULL);
 
907
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
908
  ParserWarning (4321, NULL, "Text2");
 
909
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
910
  ParserWarning (4321, "Text1", "Text2");
 
911
  ParserSetPosition (__FILE__, __LINE__ + 1);
 
912
  ParserWarning (4321, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
 
913
}
 
914
#endif