Home | History | Annotate | Download | only in VfrCompile 
      1 /** @file
      2 
      3   VfrCompiler main class and main function.
      4 
      5 Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR>
      6 This program and the accompanying materials
      7 are licensed and made available under the terms and conditions of the BSD License
      8 which accompanies this distribution.  The full text of the license may be found at
      9 http://opensource.org/licenses/bsd-license.php
     10 
     11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
     12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
     13 
     14 **/
     15 
     16 #include "stdio.h"
     17 #include "stdlib.h"
     18 #include "string.h"
     19 #include "VfrCompiler.h"
     20 #include "CommonLib.h"
     21 #include "EfiUtilityMsgs.h"
     22 
     23 PACKAGE_DATA  gCBuffer;
     24 PACKAGE_DATA  gRBuffer;
     25 CVfrStringDB  gCVfrStringDB;
     26 
     27 VOID
     28 CVfrCompiler::DebugError (
     29   IN CHAR8         *FileName,
     30   IN UINT32        LineNumber,
     31   IN UINT32        MessageCode,
     32   IN CONST CHAR8   *Text,
     33   IN CONST CHAR8   *MsgFmt,
     34   ...
     35   )
     36 {
     37   va_list List;
     38   va_start (List, MsgFmt);
     39   PrintMessage ((CHAR8 *) "ERROR", FileName, LineNumber, MessageCode, (CHAR8 *) Text, (CHAR8 *) MsgFmt, List);
     40   va_end (List);
     41 }
     42 
     43 VOID
     44 CVfrCompiler::SET_RUN_STATUS (
     45   IN COMPILER_RUN_STATUS Status
     46   )
     47 {
     48   mRunStatus = Status;
     49 }
     50 
     51 BOOLEAN
     52 CVfrCompiler::IS_RUN_STATUS (
     53   IN COMPILER_RUN_STATUS Status
     54   )
     55 {
     56   return mRunStatus == Status;
     57 }
     58 
     59 VOID
     60 CVfrCompiler::OptionInitialization (
     61   IN INT32      Argc,
     62   IN CHAR8      **Argv
     63   )
     64 {
     65   INT32         Index;
     66   EFI_STATUS    Status;
     67 
     68   Status = EFI_SUCCESS;
     69   SetUtilityName ((CHAR8*) PROGRAM_NAME);
     70 
     71   mOptions.VfrFileName                   = NULL;
     72   mOptions.RecordListFile                = NULL;
     73   mOptions.CreateRecordListFile          = FALSE;
     74   mOptions.CreateIfrPkgFile              = FALSE;
     75   mOptions.PkgOutputFileName             = NULL;
     76   mOptions.COutputFileName               = NULL;
     77   mOptions.OutputDirectory               = NULL;
     78   mOptions.PreprocessorOutputFileName    = NULL;
     79   mOptions.VfrBaseFileName               = NULL;
     80   mOptions.IncludePaths                  = NULL;
     81   mOptions.SkipCPreprocessor             = TRUE;
     82   mOptions.CPreprocessorOptions          = NULL;
     83   mOptions.CompatibleMode                = FALSE;
     84   mOptions.HasOverrideClassGuid          = FALSE;
     85   mOptions.WarningAsError                = FALSE;
     86   mOptions.AutoDefault                   = FALSE;
     87   mOptions.CheckDefault                  = FALSE;
     88   memset (&mOptions.OverrideClassGuid, 0, sizeof (EFI_GUID));
     89 
     90   if (Argc == 1) {
     91     Usage ();
     92     SET_RUN_STATUS (STATUS_DEAD);
     93     return;
     94   }
     95 
     96   for (Index = 1; (Index < Argc) && (Argv[Index][0] == '-'); Index++) {
     97     if ((stricmp(Argv[Index], "-h") == 0) || (stricmp(Argv[Index], "--help") == 0)) {
     98       Usage ();
     99       SET_RUN_STATUS (STATUS_DEAD);
    100       return;
    101     } else if (stricmp(Argv[Index], "--version") == 0) {
    102       Version ();
    103       SET_RUN_STATUS (STATUS_DEAD);
    104       return;
    105     } else if (stricmp(Argv[Index], "-l") == 0) {
    106       mOptions.CreateRecordListFile = TRUE;
    107       gCIfrRecordInfoDB.TurnOn ();
    108     } else if (stricmp(Argv[Index], "-i") == 0) {
    109       Index++;
    110       if ((Index >= Argc) || (Argv[Index][0] == '-')) {
    111         DebugError (NULL, 0, 1001, "Missing option", "-i missing path argument");
    112         goto Fail;
    113       }
    114 
    115       AppendIncludePath(Argv[Index]);
    116     } else if (stricmp(Argv[Index], "-o") == 0 || stricmp(Argv[Index], "--output-directory") == 0 || stricmp(Argv[Index], "-od") == 0) {
    117       Index++;
    118       if ((Index >= Argc) || (Argv[Index][0] == '-')) {
    119         DebugError (NULL, 0, 1001, "Missing option", "-o missing output directory name");
    120         goto Fail;
    121       }
    122       if (strlen (Argv[Index]) > MAX_PATH - 1) {
    123         DebugError (NULL, 0, 1003, "Invalid option value", "Output directory name %s is too long", Argv[Index]);
    124         goto Fail;
    125       }
    126 
    127       mOptions.OutputDirectory = (CHAR8 *) malloc (strlen (Argv[Index]) + strlen ("\\") + 1);
    128       if (mOptions.OutputDirectory == NULL) {
    129         DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    130         goto Fail;
    131       }
    132       strcpy (mOptions.OutputDirectory, Argv[Index]);
    133 
    134       CHAR8 lastChar = mOptions.OutputDirectory[strlen(mOptions.OutputDirectory) - 1];
    135       if ((lastChar != '/') && (lastChar != '\\')) {
    136         if (strchr(mOptions.OutputDirectory, '/') != NULL) {
    137           strcat (mOptions.OutputDirectory, "/");
    138         } else {
    139           strcat (mOptions.OutputDirectory, "\\");
    140         }
    141       }
    142       DebugMsg (NULL, 0, 9, (CHAR8 *) "Output Directory", (CHAR8 *) "%s", mOptions.OutputDirectory);
    143     } else if (stricmp(Argv[Index], "-b") == 0 || stricmp(Argv[Index], "--create-ifr-package") == 0 || stricmp(Argv[Index], "-ibin") == 0) {
    144       mOptions.CreateIfrPkgFile = TRUE;
    145     } else if (stricmp(Argv[Index], "-n") == 0 || stricmp(Argv[Index], "--no-pre-processing") == 0 || stricmp(Argv[Index], "-nopp") == 0) {
    146       mOptions.SkipCPreprocessor = TRUE;
    147     } else if (stricmp(Argv[Index], "-f") == 0 || stricmp(Argv[Index], "--pre-processing-flag") == 0 || stricmp(Argv[Index], "-ppflag") == 0) {
    148       Index++;
    149       if ((Index >= Argc) || (Argv[Index][0] == '-')) {
    150         DebugError (NULL, 0, 1001, "Missing option", "-od - missing C-preprocessor argument");
    151         goto Fail;
    152       }
    153 
    154       AppendCPreprocessorOptions (Argv[Index]);
    155     } else if (stricmp(Argv[Index], "-c") == 0 || stricmp(Argv[Index], "--compatible-framework") == 0) {
    156       mOptions.CompatibleMode = TRUE;
    157     } else if (stricmp(Argv[Index], "-s") == 0|| stricmp(Argv[Index], "--string-db") == 0) {
    158       Index++;
    159       if ((Index >= Argc) || (Argv[Index][0] == '-')) {
    160         DebugError (NULL, 0, 1001, "Missing option", "-s missing input string file name");
    161         goto Fail;
    162       }
    163       gCVfrStringDB.SetStringFileName(Argv[Index]);
    164       DebugMsg (NULL, 0, 9, (CHAR8 *) "Input string file path", (CHAR8 *) "%s", Argv[Index]);
    165     } else if ((stricmp (Argv[Index], "-g") == 0) || (stricmp (Argv[Index], "--guid") == 0)) {
    166       Index++;
    167       Status = StringToGuid (Argv[Index], &mOptions.OverrideClassGuid);
    168       if (EFI_ERROR (Status)) {
    169         DebugError (NULL, 0, 1000, "Invalid format:", "%s", Argv[Index]);
    170         goto Fail;
    171       }
    172       mOptions.HasOverrideClassGuid = TRUE;
    173     } else if (stricmp(Argv[Index], "-w") == 0 || stricmp(Argv[Index], "--warning-as-error") == 0) {
    174       mOptions.WarningAsError = TRUE;
    175     } else if (stricmp(Argv[Index], "-a") == 0 ||stricmp(Argv[Index], "--autodefault") == 0) {
    176       mOptions.AutoDefault = TRUE;
    177     } else if (stricmp(Argv[Index], "-d") == 0 ||stricmp(Argv[Index], "--checkdefault") == 0) {
    178       mOptions.CheckDefault = TRUE;
    179     } else {
    180       DebugError (NULL, 0, 1000, "Unknown option", "unrecognized option %s", Argv[Index]);
    181       goto Fail;
    182     }
    183   }
    184 
    185   if (Index != Argc - 1) {
    186     DebugError (NULL, 0, 1001, "Missing option", "VFR file name is not specified.");
    187     goto Fail;
    188   } else {
    189     if (strlen (Argv[Index]) > MAX_PATH) {
    190       DebugError (NULL, 0, 1003, "Invalid option value", "VFR file name %s is too long.", Argv[Index]);
    191       goto Fail;
    192     }
    193     mOptions.VfrFileName = (CHAR8 *) malloc (strlen (Argv[Index]) + 1);
    194     if (mOptions.VfrFileName == NULL) {
    195       DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    196       goto Fail;
    197     }
    198     strcpy (mOptions.VfrFileName, Argv[Index]);
    199 
    200     if (mOptions.OutputDirectory == NULL) {
    201       mOptions.OutputDirectory = (CHAR8 *) malloc (1);
    202       if (mOptions.OutputDirectory == NULL) {
    203         DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    204         goto Fail;
    205       }
    206       mOptions.OutputDirectory[0] = '\0';
    207     }
    208   }
    209 
    210   if (SetBaseFileName() != 0) {
    211     goto Fail;
    212   }
    213   if (SetPkgOutputFileName () != 0) {
    214     goto Fail;
    215   }
    216   if (SetCOutputFileName() != 0) {
    217     goto Fail;
    218   }
    219   if (SetPreprocessorOutputFileName () != 0) {
    220     goto Fail;
    221   }
    222   if (SetRecordListFileName () != 0) {
    223     goto Fail;
    224   }
    225   return;
    226 
    227 Fail:
    228   SET_RUN_STATUS (STATUS_DEAD);
    229 
    230   mOptions.CreateRecordListFile          = FALSE;
    231   mOptions.CreateIfrPkgFile              = FALSE;
    232 
    233   if (mOptions.VfrFileName != NULL) {
    234     free (mOptions.VfrFileName);
    235     mOptions.VfrFileName                 = NULL;
    236   }
    237   if (mOptions.VfrBaseFileName != NULL) {
    238     free (mOptions.VfrBaseFileName);
    239     mOptions.VfrBaseFileName             = NULL;
    240   }
    241   if (mOptions.OutputDirectory != NULL) {
    242     free (mOptions.OutputDirectory);
    243     mOptions.OutputDirectory             = NULL;
    244   }
    245   if (mOptions.PkgOutputFileName != NULL) {
    246     free (mOptions.PkgOutputFileName);
    247     mOptions.PkgOutputFileName           = NULL;
    248   }
    249   if (mOptions.COutputFileName != NULL) {
    250     free (mOptions.COutputFileName);
    251     mOptions.COutputFileName             = NULL;
    252   }
    253   if (mOptions.PreprocessorOutputFileName != NULL) {
    254     free (mOptions.PreprocessorOutputFileName);
    255     mOptions.PreprocessorOutputFileName  = NULL;
    256   }
    257   if (mOptions.RecordListFile != NULL) {
    258     free (mOptions.RecordListFile);
    259     mOptions.RecordListFile              = NULL;
    260   }
    261   if (mOptions.IncludePaths != NULL) {
    262     delete mOptions.IncludePaths;
    263     mOptions.IncludePaths                = NULL;
    264   }
    265   if (mOptions.CPreprocessorOptions != NULL) {
    266     delete mOptions.CPreprocessorOptions;
    267     mOptions.CPreprocessorOptions        = NULL;
    268   }
    269 }
    270 
    271 VOID
    272 CVfrCompiler::AppendIncludePath (
    273   IN CHAR8      *PathStr
    274   )
    275 {
    276   UINT32  Len           = 0;
    277   CHAR8   *IncludePaths = NULL;
    278 
    279   Len = strlen (" -I ") + strlen (PathStr) + 1;
    280   if (mOptions.IncludePaths != NULL) {
    281     Len += strlen (mOptions.IncludePaths);
    282   }
    283   IncludePaths = new CHAR8[Len];
    284   if (IncludePaths == NULL) {
    285     DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    286     return;
    287   }
    288   IncludePaths[0] = '\0';
    289   if (mOptions.IncludePaths != NULL) {
    290     strcat (IncludePaths, mOptions.IncludePaths);
    291   }
    292   strcat (IncludePaths, " -I ");
    293   strcat (IncludePaths, PathStr);
    294   if (mOptions.IncludePaths != NULL) {
    295     delete mOptions.IncludePaths;
    296   }
    297   mOptions.IncludePaths = IncludePaths;
    298 }
    299 
    300 VOID
    301 CVfrCompiler::AppendCPreprocessorOptions (
    302   IN CHAR8      *Options
    303   )
    304 {
    305   UINT32  Len           = 0;
    306   CHAR8   *Opt          = NULL;
    307 
    308   Len = strlen (Options) + strlen (" ") + 1;
    309   if (mOptions.CPreprocessorOptions != NULL) {
    310     Len += strlen (mOptions.CPreprocessorOptions);
    311   }
    312   Opt = new CHAR8[Len];
    313   if (Opt == NULL) {
    314     DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    315     return;
    316   }
    317   Opt[0] = 0;
    318   if (mOptions.CPreprocessorOptions != NULL) {
    319     strcat (Opt, mOptions.CPreprocessorOptions);
    320   }
    321   strcat (Opt, " ");
    322   strcat (Opt, Options);
    323   if (mOptions.CPreprocessorOptions != NULL) {
    324     delete mOptions.CPreprocessorOptions;
    325   }
    326   mOptions.CPreprocessorOptions = Opt;
    327 }
    328 
    329 INT8
    330 CVfrCompiler::SetBaseFileName (
    331   VOID
    332   )
    333 {
    334   CHAR8         *pFileName, *pPath, *pExt;
    335 
    336   if (mOptions.VfrFileName == NULL) {
    337     return -1;
    338   }
    339 
    340   pFileName = mOptions.VfrFileName;
    341   while (
    342     ((pPath = strchr (pFileName, '\\')) != NULL) ||
    343     ((pPath = strchr (pFileName, '/')) != NULL)
    344     )
    345   {
    346     pFileName = pPath + 1;
    347   }
    348 
    349   if (pFileName == NULL) {
    350     return -1;
    351   }
    352 
    353   if ((pExt = strchr (pFileName, '.')) == NULL) {
    354     return -1;
    355   }
    356 
    357   *pExt = '\0';
    358   if (strlen (pFileName) > MAX_PATH - 1) {
    359     *pExt = '.';
    360     return -1;
    361   }
    362 
    363   mOptions.VfrBaseFileName = (CHAR8 *) malloc (strlen (pFileName) + 1);
    364   if (mOptions.VfrBaseFileName == NULL) {
    365     *pExt = '.';
    366     return -1;
    367   }
    368 
    369   strcpy (mOptions.VfrBaseFileName, pFileName);
    370   *pExt = '.';
    371 
    372   return 0;
    373 }
    374 
    375 INT8
    376 CVfrCompiler::SetPkgOutputFileName (
    377   VOID
    378   )
    379 {
    380   INTN Length;
    381 
    382   if (mOptions.VfrBaseFileName == NULL) {
    383     return -1;
    384   }
    385 
    386   Length = strlen (mOptions.OutputDirectory) +
    387            strlen (mOptions.VfrBaseFileName) +
    388            strlen (VFR_PACKAGE_FILENAME_EXTENSION) +
    389            1;
    390   if (Length > MAX_PATH) {
    391     return -1;
    392   }
    393 
    394   mOptions.PkgOutputFileName = (CHAR8 *) malloc (Length);
    395   if (mOptions.PkgOutputFileName == NULL) {
    396     return -1;
    397   }
    398 
    399   strcpy (mOptions.PkgOutputFileName, mOptions.OutputDirectory);
    400   strcat (mOptions.PkgOutputFileName, mOptions.VfrBaseFileName);
    401   strcat (mOptions.PkgOutputFileName, VFR_PACKAGE_FILENAME_EXTENSION);
    402 
    403   return 0;
    404 }
    405 
    406 INT8
    407 CVfrCompiler::SetCOutputFileName (
    408   VOID
    409   )
    410 {
    411   INTN Length;
    412 
    413   if (mOptions.VfrBaseFileName == NULL) {
    414     return -1;
    415   }
    416 
    417   Length = strlen (mOptions.OutputDirectory) +
    418            strlen (mOptions.VfrBaseFileName) +
    419            strlen (".c") +
    420            1;
    421   if (Length > MAX_PATH) {
    422     return -1;
    423   }
    424 
    425   mOptions.COutputFileName = (CHAR8 *) malloc (Length);
    426   if (mOptions.COutputFileName == NULL) {
    427     return -1;
    428   }
    429 
    430   strcpy (mOptions.COutputFileName, mOptions.OutputDirectory);
    431   strcat (mOptions.COutputFileName, mOptions.VfrBaseFileName);
    432   strcat (mOptions.COutputFileName, ".c");
    433 
    434   return 0;
    435 }
    436 
    437 INT8
    438 CVfrCompiler::SetPreprocessorOutputFileName (
    439   VOID
    440   )
    441 {
    442   INTN Length;
    443 
    444   if (mOptions.VfrBaseFileName == NULL) {
    445     return -1;
    446   }
    447 
    448   Length = strlen (mOptions.OutputDirectory) +
    449            strlen (mOptions.VfrBaseFileName) +
    450            strlen (VFR_PREPROCESS_FILENAME_EXTENSION) +
    451            1;
    452   if (Length > MAX_PATH) {
    453     return -1;
    454   }
    455 
    456   mOptions.PreprocessorOutputFileName = (CHAR8 *) malloc (Length);
    457   if (mOptions.PreprocessorOutputFileName == NULL) {
    458     return -1;
    459   }
    460 
    461   strcpy (mOptions.PreprocessorOutputFileName, mOptions.OutputDirectory);
    462   strcat (mOptions.PreprocessorOutputFileName, mOptions.VfrBaseFileName);
    463   strcat (mOptions.PreprocessorOutputFileName, VFR_PREPROCESS_FILENAME_EXTENSION);
    464 
    465   return 0;
    466 }
    467 
    468 INT8
    469 CVfrCompiler::SetRecordListFileName (
    470   VOID
    471   )
    472 {
    473   INTN Length;
    474 
    475   if (mOptions.VfrBaseFileName == NULL) {
    476     return -1;
    477   }
    478 
    479   Length = strlen (mOptions.OutputDirectory) +
    480            strlen (mOptions.VfrBaseFileName) +
    481            strlen (VFR_RECORDLIST_FILENAME_EXTENSION) +
    482            1;
    483   if (Length > MAX_PATH) {
    484     return -1;
    485   }
    486 
    487   mOptions.RecordListFile = (CHAR8 *) malloc (Length);
    488   if (mOptions.RecordListFile == NULL) {
    489     return -1;
    490   }
    491 
    492   strcpy (mOptions.RecordListFile, mOptions.OutputDirectory);
    493   strcat (mOptions.RecordListFile, mOptions.VfrBaseFileName);
    494   strcat (mOptions.RecordListFile, VFR_RECORDLIST_FILENAME_EXTENSION);
    495 
    496   return 0;
    497 }
    498 
    499 CVfrCompiler::CVfrCompiler (
    500   IN INT32      Argc,
    501   IN CHAR8      **Argv
    502   )
    503 {
    504   mPreProcessCmd = (CHAR8 *) PREPROCESSOR_COMMAND;
    505   mPreProcessOpt = (CHAR8 *) PREPROCESSOR_OPTIONS;
    506 
    507   SET_RUN_STATUS (STATUS_STARTED);
    508 
    509   OptionInitialization(Argc, Argv);
    510 
    511   if ((IS_RUN_STATUS(STATUS_FAILED)) || (IS_RUN_STATUS(STATUS_DEAD))) {
    512     return;
    513   }
    514 
    515   SET_RUN_STATUS(STATUS_INITIALIZED);
    516 }
    517 
    518 CVfrCompiler::~CVfrCompiler (
    519   VOID
    520   )
    521 {
    522   if (mOptions.VfrFileName != NULL) {
    523     free (mOptions.VfrFileName);
    524     mOptions.VfrFileName = NULL;
    525   }
    526 
    527   if (mOptions.VfrBaseFileName != NULL) {
    528     free (mOptions.VfrBaseFileName);
    529     mOptions.VfrBaseFileName = NULL;
    530   }
    531 
    532   if (mOptions.OutputDirectory != NULL) {
    533     free (mOptions.OutputDirectory);
    534     mOptions.OutputDirectory = NULL;
    535   }
    536 
    537   if (mOptions.PkgOutputFileName != NULL) {
    538     free (mOptions.PkgOutputFileName);
    539     mOptions.PkgOutputFileName = NULL;
    540   }
    541 
    542   if (mOptions.COutputFileName != NULL) {
    543     free (mOptions.COutputFileName);
    544     mOptions.COutputFileName = NULL;
    545   }
    546 
    547   if (mOptions.PreprocessorOutputFileName != NULL) {
    548     free (mOptions.PreprocessorOutputFileName);
    549     mOptions.PreprocessorOutputFileName = NULL;
    550   }
    551 
    552   if (mOptions.RecordListFile != NULL) {
    553     free (mOptions.RecordListFile);
    554     mOptions.RecordListFile = NULL;
    555   }
    556 
    557   if (mOptions.IncludePaths != NULL) {
    558     delete mOptions.IncludePaths;
    559     mOptions.IncludePaths = NULL;
    560   }
    561 
    562   if (mOptions.CPreprocessorOptions != NULL) {
    563     delete mOptions.CPreprocessorOptions;
    564     mOptions.CPreprocessorOptions = NULL;
    565   }
    566 
    567   SET_RUN_STATUS(STATUS_DEAD);
    568 }
    569 
    570 VOID
    571 CVfrCompiler::Usage (
    572   VOID
    573   )
    574 {
    575   UINT32 Index;
    576   CONST  CHAR8 *Help[] = {
    577     " ",
    578     "VfrCompile version " VFR_COMPILER_VERSION "Build " __BUILD_VERSION,
    579     "Copyright (c) 2004-2016 Intel Corporation. All rights reserved.",
    580     " ",
    581     "Usage: VfrCompile [options] VfrFile",
    582     " ",
    583     "Options:",
    584     "  -h, --help     prints this help",
    585     "  --version      prints version info",
    586     "  -l             create an output IFR listing file",
    587     "  -o DIR, --output-directory DIR",
    588     "                 deposit all output files to directory OutputDir",
    589     "                 default is current directory",
    590     "  -b, --create-ifr-package",
    591     "                 create an IFR HII pack file",
    592     "  -n, --no-pre-processing",
    593     "                 do not preprocessing input file",
    594     "  -c, --compatible-framework",
    595     "                 compatible framework vfr file",
    596     "  -s, --string-db",
    597     "                 input uni string package file",
    598     "  -g, --guid",
    599     "                 override class guid input",
    600     "                 format is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx",
    601     "  -w  --warning-as-error",
    602     "                 treat warning as an error",
    603     "  -a  --autodefaut    generate default value for question opcode if some default is missing",
    604     "  -d  --checkdefault  check the default information in a question opcode",
    605     NULL
    606     };
    607   for (Index = 0; Help[Index] != NULL; Index++) {
    608     fprintf (stdout, "%s\n", Help[Index]);
    609   }
    610 }
    611 
    612 VOID
    613 CVfrCompiler::Version (
    614   VOID
    615   )
    616 {
    617   UINT32 Index;
    618   CONST  CHAR8 *Help[] = {
    619     "VfrCompile version " VFR_COMPILER_VERSION "Build " __BUILD_VERSION,
    620     NULL
    621     };
    622   for (Index = 0; Help[Index] != NULL; Index++) {
    623     fprintf (stdout, "%s\n", Help[Index]);
    624   }
    625 }
    626 
    627 VOID
    628 CVfrCompiler::PreProcess (
    629   VOID
    630   )
    631 {
    632   FILE    *pVfrFile      = NULL;
    633   UINT32  CmdLen         = 0;
    634   CHAR8   *PreProcessCmd = NULL;
    635 
    636   if (!IS_RUN_STATUS(STATUS_INITIALIZED)) {
    637     goto Fail;
    638   }
    639 
    640   if (mOptions.SkipCPreprocessor == TRUE) {
    641     goto Out;
    642   }
    643 
    644   if ((pVfrFile = fopen (LongFilePath (mOptions.VfrFileName), "r")) == NULL) {
    645     DebugError (NULL, 0, 0001, "Error opening the input VFR file", mOptions.VfrFileName);
    646     goto Fail;
    647   }
    648   fclose (pVfrFile);
    649 
    650   CmdLen = strlen (mPreProcessCmd) + strlen (mPreProcessOpt) +
    651   	       strlen (mOptions.VfrFileName) + strlen (mOptions.PreprocessorOutputFileName);
    652   if (mOptions.CPreprocessorOptions != NULL) {
    653     CmdLen += strlen (mOptions.CPreprocessorOptions);
    654   }
    655   if (mOptions.IncludePaths != NULL) {
    656     CmdLen += strlen (mOptions.IncludePaths);
    657   }
    658 
    659   PreProcessCmd = new CHAR8[CmdLen + 10];
    660   if (PreProcessCmd == NULL) {
    661     DebugError (NULL, 0, 4001, "Resource: memory can't be allocated", NULL);
    662     goto Fail;
    663   }
    664   strcpy (PreProcessCmd, mPreProcessCmd), strcat (PreProcessCmd, " ");
    665   strcat (PreProcessCmd, mPreProcessOpt), strcat (PreProcessCmd, " ");
    666   if (mOptions.IncludePaths != NULL) {
    667     strcat (PreProcessCmd, mOptions.IncludePaths), strcat (PreProcessCmd, " ");
    668   }
    669   if (mOptions.CPreprocessorOptions != NULL) {
    670     strcat (PreProcessCmd, mOptions.CPreprocessorOptions), strcat (PreProcessCmd, " ");
    671   }
    672   strcat (PreProcessCmd, mOptions.VfrFileName), strcat (PreProcessCmd, " > ");
    673   strcat (PreProcessCmd, mOptions.PreprocessorOutputFileName);
    674 
    675   if (system (PreProcessCmd) != 0) {
    676     DebugError (NULL, 0, 0003, "Error parsing file", "failed to spawn C preprocessor on VFR file %s\n", PreProcessCmd);
    677     goto Fail;
    678   }
    679 
    680   delete[] PreProcessCmd;
    681 
    682 Out:
    683   SET_RUN_STATUS (STATUS_PREPROCESSED);
    684   return;
    685 
    686 Fail:
    687   if (!IS_RUN_STATUS(STATUS_DEAD)) {
    688     SET_RUN_STATUS (STATUS_FAILED);
    689   }
    690   delete[] PreProcessCmd;
    691 }
    692 
    693 extern UINT8 VfrParserStart (IN FILE *, IN INPUT_INFO_TO_SYNTAX *);
    694 
    695 VOID
    696 CVfrCompiler::Compile (
    697   VOID
    698   )
    699 {
    700   FILE  *pInFile    = NULL;
    701   CHAR8 *InFileName = NULL;
    702   INPUT_INFO_TO_SYNTAX InputInfo;
    703 
    704   if (!IS_RUN_STATUS(STATUS_PREPROCESSED)) {
    705     goto Fail;
    706   }
    707 
    708   InFileName = (mOptions.SkipCPreprocessor == TRUE) ? mOptions.VfrFileName : mOptions.PreprocessorOutputFileName;
    709 
    710   gCVfrErrorHandle.SetInputFile (InFileName);
    711   gCVfrErrorHandle.SetWarningAsError(mOptions.WarningAsError);
    712 
    713   if ((pInFile = fopen (LongFilePath (InFileName), "r")) == NULL) {
    714     DebugError (NULL, 0, 0001, "Error opening the input file", InFileName);
    715     goto Fail;
    716   }
    717 
    718   InputInfo.CompatibleMode = mOptions.CompatibleMode;
    719   if (mOptions.HasOverrideClassGuid) {
    720     InputInfo.OverrideClassGuid = &mOptions.OverrideClassGuid;
    721   } else {
    722     InputInfo.OverrideClassGuid = NULL;
    723   }
    724 
    725   if (VfrParserStart (pInFile, &InputInfo) != 0) {
    726     goto Fail;
    727   }
    728 
    729   fclose (pInFile);
    730 
    731   if (gCFormPkg.HavePendingUnassigned () == TRUE) {
    732     gCFormPkg.PendingAssignPrintAll ();
    733     goto Fail;
    734   }
    735 
    736   SET_RUN_STATUS (STATUS_COMPILEED);
    737   return;
    738 
    739 Fail:
    740   if (!IS_RUN_STATUS(STATUS_DEAD)) {
    741     DebugError (NULL, 0, 0003, "Error parsing", "compile error in file %s", InFileName);
    742     SET_RUN_STATUS (STATUS_FAILED);
    743   }
    744   if (pInFile != NULL) {
    745     fclose (pInFile);
    746   }
    747 }
    748 
    749 VOID
    750 CVfrCompiler::AdjustBin (
    751   VOID
    752   )
    753 {
    754   EFI_VFR_RETURN_CODE Status;
    755 
    756   if (!IS_RUN_STATUS(STATUS_COMPILEED)) {
    757     return;
    758   }
    759 
    760   if (gNeedAdjustOpcode) {
    761     //
    762     // When parsing the Vfr, has created some opcodes, now need to update the record info.
    763     //
    764     gCIfrRecordInfoDB.IfrUpdateRecordInfoForDynamicOpcode (FALSE);
    765   }
    766 
    767   //
    768   // Check whether need to check default info for question or auto add default for question.
    769   //
    770   if (mOptions.AutoDefault || mOptions.CheckDefault) {
    771     gCIfrRecordInfoDB.IfrCheckAddDefaultRecord (mOptions.AutoDefault, mOptions.CheckDefault);
    772   }
    773 
    774   //
    775   // Check Binary Code consistent between Form and IfrRecord
    776   //
    777 
    778   //
    779   // Get Package Data and IfrRecord Data
    780   //
    781   gCFormPkg.BuildPkg (gCBuffer);
    782   gCIfrRecordInfoDB.IfrRecordOutput (gRBuffer);
    783 
    784   //
    785   // Compare Form and Record data
    786   //
    787   if (gCBuffer.Buffer != NULL && gRBuffer.Buffer != NULL) {
    788     UINT32 Index;
    789     if (gCBuffer.Size != gRBuffer.Size) {
    790       DebugError (NULL, 0, 0001, "Error parsing vfr file", " %s. FormBinary Size 0x%X is not same to RecordBuffer Size 0x%X", mOptions.VfrFileName, gCBuffer.Size, gRBuffer.Size);
    791     }
    792     for (Index = 0; Index < gCBuffer.Size; Index ++) {
    793       if (gCBuffer.Buffer[Index] != gRBuffer.Buffer[Index]) {
    794         break;
    795       }
    796     }
    797     if (Index != gCBuffer.Size) {
    798       DebugError (NULL, 0, 0001, "Error parsing vfr file", " %s. the 0x%X byte is different between Form and Record", mOptions.VfrFileName, Index);
    799     }
    800     DebugMsg (NULL, 0, 9, (CHAR8 *) "IFR Buffer", (CHAR8 *) "Form Buffer same to Record Buffer and Size is 0x%X", Index);
    801   } else if (gCBuffer.Buffer == NULL && gRBuffer.Buffer == NULL) {
    802     //ok
    803   } else {
    804     DebugError (NULL, 0, 0001, "Error parsing vfr file", " %s.Buffer not allocated.", mOptions.VfrFileName);
    805   }
    806 
    807   //
    808   // For UEFI mode, not do OpCode Adjust
    809   //
    810   if (mOptions.CompatibleMode) {
    811     //
    812     // Adjust Opcode to be compatible with framework vfr
    813     //
    814     Status = gCIfrRecordInfoDB.IfrRecordAdjust ();
    815     if (Status != VFR_RETURN_SUCCESS) {
    816       //
    817       // Record List Adjust Failed
    818       //
    819       SET_RUN_STATUS (STATUS_FAILED);
    820       return;
    821     }
    822     //
    823     // Re get the IfrRecord Buffer.
    824     //
    825     gCIfrRecordInfoDB.IfrRecordOutput (gRBuffer);
    826   }
    827 
    828   return;
    829 }
    830 
    831 VOID
    832 CVfrCompiler::GenBinary (
    833   VOID
    834   )
    835 {
    836   FILE                    *pFile = NULL;
    837 
    838   if (!IS_RUN_STATUS(STATUS_COMPILEED)) {
    839     goto Fail;
    840   }
    841 
    842   if (mOptions.CreateIfrPkgFile == TRUE) {
    843     if ((pFile = fopen (LongFilePath (mOptions.PkgOutputFileName), "wb")) == NULL) {
    844       DebugError (NULL, 0, 0001, "Error opening file", mOptions.PkgOutputFileName);
    845       goto Fail;
    846     }
    847     if (gCFormPkg.BuildPkg (pFile, &gRBuffer) != VFR_RETURN_SUCCESS) {
    848       fclose (pFile);
    849       goto Fail;
    850     }
    851     fclose (pFile);
    852   }
    853 
    854   SET_RUN_STATUS (STATUS_GENBINARY);
    855 
    856   return;
    857 
    858 Fail:
    859   if (!IS_RUN_STATUS(STATUS_DEAD)) {
    860     SET_RUN_STATUS (STATUS_FAILED);
    861   }
    862 }
    863 
    864 static const char *gSourceFileHeader[] = {
    865   "//",
    866   "//  DO NOT EDIT -- auto-generated file",
    867   "//",
    868   "//  This file is generated by the vfrcompiler utility",
    869   "//",
    870   NULL
    871 };
    872 
    873 VOID
    874 CVfrCompiler::GenCFile (
    875   VOID
    876   )
    877 {
    878   FILE                    *pFile;
    879   UINT32                  Index;
    880 
    881   if (!IS_RUN_STATUS(STATUS_GENBINARY)) {
    882     goto Fail;
    883   }
    884 
    885   if (!mOptions.CreateIfrPkgFile || mOptions.CompatibleMode) {
    886     if ((pFile = fopen (LongFilePath (mOptions.COutputFileName), "w")) == NULL) {
    887       DebugError (NULL, 0, 0001, "Error opening output C file", mOptions.COutputFileName);
    888       goto Fail;
    889     }
    890 
    891     for (Index = 0; gSourceFileHeader[Index] != NULL; Index++) {
    892       fprintf (pFile, "%s\n", gSourceFileHeader[Index]);
    893     }
    894 
    895     if (mOptions.CompatibleMode) {
    896       gCVfrBufferConfig.OutputCFile (pFile, mOptions.VfrBaseFileName);
    897     }
    898 
    899     if (gCFormPkg.GenCFile (mOptions.VfrBaseFileName, pFile, &gRBuffer) != VFR_RETURN_SUCCESS) {
    900       fclose (pFile);
    901       goto Fail;
    902     }
    903     fclose (pFile);
    904   }
    905 
    906   SET_RUN_STATUS (STATUS_FINISHED);
    907   return;
    908 
    909 Fail:
    910   if (!IS_RUN_STATUS(STATUS_DEAD)) {
    911     SET_RUN_STATUS (STATUS_FAILED);
    912   }
    913 }
    914 
    915 VOID
    916 CVfrCompiler::GenRecordListFile (
    917   VOID
    918   )
    919 {
    920   CHAR8  *InFileName = NULL;
    921   FILE   *pInFile    = NULL;
    922   FILE   *pOutFile   = NULL;
    923   CHAR8  LineBuf[MAX_VFR_LINE_LEN];
    924   UINT32 LineNo;
    925 
    926   InFileName = (mOptions.SkipCPreprocessor == TRUE) ? mOptions.VfrFileName : mOptions.PreprocessorOutputFileName;
    927 
    928   if (mOptions.CreateRecordListFile == TRUE) {
    929     if ((InFileName[0] == '\0') || (mOptions.RecordListFile[0] == '\0')) {
    930       return;
    931     }
    932 
    933     if ((pInFile = fopen (LongFilePath (InFileName), "r")) == NULL) {
    934       DebugError (NULL, 0, 0001, "Error opening the input VFR preprocessor output file", InFileName);
    935       return;
    936     }
    937 
    938     if ((pOutFile = fopen (LongFilePath (mOptions.RecordListFile), "w")) == NULL) {
    939       DebugError (NULL, 0, 0001, "Error opening the record list file", mOptions.RecordListFile);
    940       goto Err1;
    941     }
    942 
    943     fprintf (pOutFile, "//\n//  VFR compiler version " VFR_COMPILER_VERSION __BUILD_VERSION "\n//\n");
    944     LineNo = 0;
    945     while (!feof (pInFile)) {
    946       if (fgets (LineBuf, MAX_VFR_LINE_LEN, pInFile) != NULL) {
    947         fprintf (pOutFile, "%s", LineBuf);
    948         LineNo++;
    949         gCIfrRecordInfoDB.IfrRecordOutput (pOutFile, LineNo);
    950       }
    951     }
    952 
    953     fprintf (pOutFile, "\n//\n// All Opcode Record List \n//\n");
    954     gCIfrRecordInfoDB.IfrRecordOutput (pOutFile, 0);
    955     gCVfrVarDataTypeDB.Dump(pOutFile);
    956 
    957     fclose (pOutFile);
    958     fclose (pInFile);
    959   }
    960 
    961   return;
    962 
    963 Err1:
    964   fclose (pInFile);
    965 }
    966 
    967 int
    968 main (
    969   IN int             Argc,
    970   IN char            **Argv
    971   )
    972 {
    973   COMPILER_RUN_STATUS  Status;
    974 
    975   SetPrintLevel(WARNING_LOG_LEVEL);
    976   CVfrCompiler         Compiler(Argc, Argv);
    977 
    978   Compiler.PreProcess();
    979   Compiler.Compile();
    980   Compiler.AdjustBin();
    981   Compiler.GenBinary();
    982   Compiler.GenCFile();
    983   Compiler.GenRecordListFile ();
    984 
    985   Status = Compiler.RunStatus ();
    986   if ((Status == STATUS_DEAD) || (Status == STATUS_FAILED)) {
    987     return 2;
    988   }
    989 
    990   if (gCBuffer.Buffer != NULL) {
    991     delete gCBuffer.Buffer;
    992   }
    993 
    994   if (gRBuffer.Buffer != NULL) {
    995     delete gRBuffer.Buffer;
    996   }
    997 
    998   return GetUtilityStatus ();
    999 }
   1000 
   1001 
   1002