1) Sync EdkCompatibilityPkg with EDK 1.04. The changes includes:
1.1) Bug fixes. (For details, please check Documents & files: Snapshot/Release Notes at https://edk.tianocore.org/servlets/ProjectDocumentList?folderID=43&expandFolder=43&folderID=6) 1.2) Add new UEFI protocol definitions for AbsolutePointer, FormBrowser2, HiiConfigAccess, HiiConfigRouting, HiiDatabase, HiiFont, HiiImage, HiiString, SimpleTextInputEx, DPC protocol. 1.3) Add Smbios 2.5, 2.6 supports. Incompatible changes hilighted: 1) EFI_MANAGED_NETWORK_PROTOCOL_GUID changed. 2) EFI_IP4_IPCONFIG_DATA changed. 2) Add in EdkCompatibilityPkg/EdkCompatibilityPkg.dsc to build all libraries in this package. git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@4624 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qwang12
@@ -0,0 +1,53 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004 - 2007, 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:
|
||||
|
||||
EfiVfr.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Defines and prototypes for the UEFI VFR compiler internal use.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFIVFR_H_
|
||||
#define _EFIVFR_H_
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "TianoHii.h"
|
||||
|
||||
#define MAX_PATH 255
|
||||
#define MAX_LINE_LEN 4096
|
||||
|
||||
#define EFI_IFR_MAX_LENGTH 0xFF
|
||||
|
||||
#define EFI_VARSTORE_ID_INVALID 0
|
||||
#define EFI_VAROFFSET_INVALID 0xFFFF
|
||||
#define EFI_VARSTORE_ID_START 0x20
|
||||
#define EFI_STRING_ID_INVALID 0x0
|
||||
#define EFI_IMAGE_ID_INVALID 0xFFFF
|
||||
|
||||
typedef enum {
|
||||
QUESTION_NORMAL,
|
||||
QUESTION_DATE,
|
||||
QUESTION_TIME,
|
||||
} EFI_QUESION_TYPE;
|
||||
|
||||
typedef enum {
|
||||
EQUAL,
|
||||
LESS_EQUAL,
|
||||
LESS_THAN,
|
||||
GREATER_THAN,
|
||||
GREATER_EQUAL
|
||||
} EFI_COMPARE_TYPE;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,594 @@
|
||||
#include "stdio.h"
|
||||
#include "string.h"
|
||||
#include "process.h"
|
||||
#include "VfrCompiler.h"
|
||||
|
||||
|
||||
VOID
|
||||
CVfrCompiler::SET_RUN_STATUS (
|
||||
IN COMPILER_RUN_STATUS Status
|
||||
)
|
||||
{
|
||||
mRunStatus = Status;
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
CVfrCompiler::IS_RUN_STATUS (
|
||||
IN COMPILER_RUN_STATUS Status
|
||||
)
|
||||
{
|
||||
return mRunStatus == Status;
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::OptionInitialization (
|
||||
IN INT32 Argc,
|
||||
IN INT8 **Argv
|
||||
)
|
||||
{
|
||||
INT32 Index;
|
||||
|
||||
mOptions.VfrFileName[0] = '\0';
|
||||
mOptions.RecordListFile[0] = '\0';
|
||||
mOptions.CreateRecordListFile = FALSE;
|
||||
mOptions.CreateIfrPkgFile = FALSE;
|
||||
mOptions.PkgOutputFileName[0] = '\0';
|
||||
mOptions.COutputFileName[0] = '\0';
|
||||
mOptions.OutputDirectory[0] = '\0';
|
||||
mOptions.PreprocessorOutputFileName[0] = '\0';
|
||||
mOptions.VfrBaseFileName[0] = '\0';
|
||||
mOptions.IncludePaths = NULL;
|
||||
mOptions.CPreprocessorOptions = NULL;
|
||||
|
||||
for (Index = 1; (Index < Argc) && (Argv[Index][0] == '-'); Index++) {
|
||||
if ((_stricmp(Argv[Index], "-?") == 0) || (_stricmp(Argv[Index], "-h") == 0)) {
|
||||
Usage ();
|
||||
SET_RUN_STATUS (STATUS_DEAD);
|
||||
return;
|
||||
} else if (_stricmp(Argv[Index], "-l") == 0) {
|
||||
mOptions.CreateRecordListFile = TRUE;
|
||||
gCIfrRecordInfoDB.TurnOn ();
|
||||
} else if (_stricmp(Argv[Index], "-i") == 0) {
|
||||
Index++;
|
||||
if ((Index >= Argc) || (Argv[Index][0] == '-')) {
|
||||
printf ("%s -i - missing path argument\n", PROGRAM_NAME);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
AppendIncludePath(Argv[Index]);
|
||||
} else if (_stricmp(Argv[Index], "-od") == 0) {
|
||||
Index++;
|
||||
if ((Index >= Argc) || (Argv[Index][0] == '-')) {
|
||||
printf ("%s -od - missing output directory name\n", PROGRAM_NAME);
|
||||
goto Fail;
|
||||
}
|
||||
strcpy (mOptions.OutputDirectory, Argv[Index]);
|
||||
} else if (_stricmp(Argv[Index], "-ibin") == 0) {
|
||||
mOptions.CreateIfrPkgFile = TRUE;
|
||||
} else if (_stricmp(Argv[Index], "-nostrings") == 0) {
|
||||
} else if (_stricmp(Argv[Index], "-ppflag") == 0) {
|
||||
Index++;
|
||||
if ((Index >= Argc) || (Argv[Index][0] == '-')) {
|
||||
printf ("%s -od - missing C-preprocessor argument\n", PROGRAM_NAME);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
AppendCPreprocessorOptions (Argv[Index]);
|
||||
} else {
|
||||
printf ("%s unrecognized option %s\n", PROGRAM_NAME, Argv[Index]);
|
||||
Usage ();
|
||||
goto Fail;
|
||||
}
|
||||
}
|
||||
|
||||
if (Index != Argc - 1) {
|
||||
printf ("%s must specify VFR file name", PROGRAM_NAME);
|
||||
Usage ();
|
||||
goto Fail;
|
||||
} else {
|
||||
strcpy (mOptions.VfrFileName, Argv[Index]);
|
||||
}
|
||||
|
||||
if (SetBaseFileName() != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
if (SetPkgOutputFileName () != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
if (SetCOutputFileName() != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
if (SetPreprocessorOutputFileName () != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
if (SetRecordListFileName () != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
return;
|
||||
|
||||
Fail:
|
||||
SET_RUN_STATUS (STATUS_FAILED);
|
||||
|
||||
mOptions.VfrFileName[0] = '\0';
|
||||
mOptions.RecordListFile[0] = '\0';
|
||||
mOptions.CreateRecordListFile = FALSE;
|
||||
mOptions.CreateIfrPkgFile = FALSE;
|
||||
mOptions.PkgOutputFileName[0] = '\0';
|
||||
mOptions.COutputFileName[0] = '\0';
|
||||
mOptions.OutputDirectory[0] = '\0';
|
||||
mOptions.PreprocessorOutputFileName[0] = '\0';
|
||||
mOptions.VfrBaseFileName[0] = '\0';
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
delete mOptions.IncludePaths;
|
||||
mOptions.IncludePaths = NULL;
|
||||
}
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
delete mOptions.CPreprocessorOptions;
|
||||
mOptions.CPreprocessorOptions = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::AppendIncludePath (
|
||||
IN INT8 *PathStr
|
||||
)
|
||||
{
|
||||
UINT32 Len = 0;
|
||||
INT8 *IncludePaths = NULL;
|
||||
|
||||
Len = strlen (" -I ") + strlen (PathStr) + 1;
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
Len += strlen (mOptions.IncludePaths);
|
||||
}
|
||||
IncludePaths = new INT8[Len];
|
||||
if (IncludePaths == NULL) {
|
||||
printf ("%s memory allocation failure\n", PROGRAM_NAME);
|
||||
return;
|
||||
}
|
||||
IncludePaths[0] = '\0';
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
strcat (IncludePaths, mOptions.IncludePaths);
|
||||
}
|
||||
strcat (IncludePaths, " -I ");
|
||||
strcat (IncludePaths, PathStr);
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
delete mOptions.IncludePaths;
|
||||
}
|
||||
mOptions.IncludePaths = IncludePaths;
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::AppendCPreprocessorOptions (
|
||||
IN INT8 *Options
|
||||
)
|
||||
{
|
||||
UINT32 Len = 0;
|
||||
INT8 *Opt = NULL;
|
||||
|
||||
Len = strlen (Options) + strlen (" ") + 1;
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
Len += strlen (mOptions.CPreprocessorOptions);
|
||||
}
|
||||
Opt = new INT8[Len];
|
||||
if (Opt == NULL) {
|
||||
printf ("%s memory allocation failure\n", PROGRAM_NAME);
|
||||
return;
|
||||
}
|
||||
Opt[0] = 0;
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
strcat (Opt, mOptions.CPreprocessorOptions);
|
||||
}
|
||||
strcat (Opt, " ");
|
||||
strcat (Opt, Options);
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
delete mOptions.CPreprocessorOptions;
|
||||
}
|
||||
mOptions.CPreprocessorOptions = Opt;
|
||||
}
|
||||
|
||||
INT8
|
||||
CVfrCompiler::SetBaseFileName (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
INT8 *pFileName, *pPath, *pExt;
|
||||
|
||||
if (mOptions.VfrFileName[0] == '\0') {
|
||||
return -1;
|
||||
}
|
||||
|
||||
pFileName = mOptions.VfrFileName;
|
||||
while ((pPath = strchr (pFileName, '\\')) != NULL) {
|
||||
pFileName = pPath + 1;
|
||||
}
|
||||
|
||||
if (pFileName == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((pExt = strchr (pFileName, '.')) == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
strncpy (mOptions.VfrBaseFileName, pFileName, pExt - pFileName);
|
||||
mOptions.VfrBaseFileName[pExt - pFileName] = '\0';
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT8
|
||||
CVfrCompiler::SetPkgOutputFileName (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mOptions.VfrBaseFileName[0] == '\0') {
|
||||
return -1;
|
||||
}
|
||||
|
||||
strcpy (mOptions.PkgOutputFileName, mOptions.OutputDirectory);
|
||||
strcat (mOptions.PkgOutputFileName, mOptions.VfrBaseFileName);
|
||||
strcat (mOptions.PkgOutputFileName, VFR_PACKAGE_FILENAME_EXTENSION);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT8
|
||||
CVfrCompiler::SetCOutputFileName (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mOptions.VfrBaseFileName[0] == '\0') {
|
||||
return -1;
|
||||
}
|
||||
|
||||
strcpy (mOptions.COutputFileName, mOptions.OutputDirectory);
|
||||
strcat (mOptions.COutputFileName, mOptions.VfrBaseFileName);
|
||||
strcat (mOptions.COutputFileName, ".c");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT8
|
||||
CVfrCompiler::SetPreprocessorOutputFileName (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mOptions.VfrBaseFileName[0] == '\0') {
|
||||
return -1;
|
||||
}
|
||||
|
||||
strcpy (mOptions.PreprocessorOutputFileName, mOptions.OutputDirectory);
|
||||
strcat (mOptions.PreprocessorOutputFileName, mOptions.VfrBaseFileName);
|
||||
strcat (mOptions.PreprocessorOutputFileName, VFR_PREPROCESS_FILENAME_EXTENSION);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
INT8
|
||||
CVfrCompiler::SetRecordListFileName (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mOptions.VfrBaseFileName[0] == '\0') {
|
||||
return -1;
|
||||
}
|
||||
|
||||
strcpy (mOptions.RecordListFile, mOptions.OutputDirectory);
|
||||
strcat (mOptions.RecordListFile, mOptions.VfrBaseFileName);
|
||||
strcat (mOptions.RecordListFile, VFR_RECORDLIST_FILENAME_EXTENSION);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
CVfrCompiler::CVfrCompiler (
|
||||
IN INT32 Argc,
|
||||
IN INT8 **Argv
|
||||
)
|
||||
{
|
||||
mPreProcessCmd = PREPROCESSOR_COMMAND;
|
||||
mPreProcessOpt = PREPROCESSOR_OPTIONS;
|
||||
|
||||
OptionInitialization(Argc, Argv);
|
||||
|
||||
if ((IS_RUN_STATUS(STATUS_FAILED)) || (IS_RUN_STATUS(STATUS_DEAD))) {
|
||||
return;
|
||||
}
|
||||
|
||||
SET_RUN_STATUS(STATUS_INITIALIZED);
|
||||
}
|
||||
|
||||
CVfrCompiler::~CVfrCompiler (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
delete mOptions.IncludePaths;
|
||||
mOptions.IncludePaths = NULL;
|
||||
}
|
||||
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
delete mOptions.CPreprocessorOptions;
|
||||
mOptions.CPreprocessorOptions = NULL;
|
||||
}
|
||||
|
||||
SET_RUN_STATUS(STATUS_DEAD);
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::Usage (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
CONST INT8 *Help[] = {
|
||||
" ",
|
||||
"VfrCompile version " VFR_COMPILER_VERSION,
|
||||
" ",
|
||||
" Usage: VfrCompile {options} [VfrFile]",
|
||||
" ",
|
||||
" where options include:",
|
||||
" -? or -h prints this help",
|
||||
" -l create an output IFR listing file",
|
||||
" -i IncPath add IncPath to the search path for VFR included files",
|
||||
" -od OutputDir deposit all output files to directory OutputDir (default=cwd)",
|
||||
" -ibin create an IFR HII pack file"
|
||||
" -ppflag C-preprocessor argument",
|
||||
" where parameters include:",
|
||||
" VfrFile name of the input VFR script file",
|
||||
" ",
|
||||
NULL
|
||||
};
|
||||
for (Index = 0; Help[Index] != NULL; Index++) {
|
||||
fprintf (stdout, "%s\n", Help[Index]);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::PreProcess (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
FILE *pVfrFile = NULL;
|
||||
UINT32 CmdLen = 0;
|
||||
INT8 *PreProcessCmd = NULL;
|
||||
|
||||
if (!IS_RUN_STATUS(STATUS_INITIALIZED)) {
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if ((pVfrFile = fopen (mOptions.VfrFileName, "r")) == NULL) {
|
||||
printf ("%s could not open input VFR file - %s\n", PROGRAM_NAME, mOptions.VfrFileName);
|
||||
goto Fail;
|
||||
}
|
||||
fclose (pVfrFile);
|
||||
|
||||
CmdLen = strlen (mPreProcessCmd) + strlen (mPreProcessOpt) +
|
||||
strlen (mOptions.VfrFileName) + strlen (mOptions.PreprocessorOutputFileName);
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
CmdLen += strlen (mOptions.CPreprocessorOptions);
|
||||
}
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
CmdLen += strlen (mOptions.IncludePaths);
|
||||
}
|
||||
|
||||
PreProcessCmd = new INT8[CmdLen + 10];
|
||||
if (PreProcessCmd == NULL) {
|
||||
printf ("%s could not allocate memory\n", PROGRAM_NAME);
|
||||
goto Fail;
|
||||
}
|
||||
strcpy (PreProcessCmd, mPreProcessCmd), strcat (PreProcessCmd, " ");
|
||||
strcat (PreProcessCmd, mPreProcessOpt), strcat (PreProcessCmd, " ");
|
||||
if (mOptions.IncludePaths != NULL) {
|
||||
strcat (PreProcessCmd, mOptions.IncludePaths), strcat (PreProcessCmd, " ");
|
||||
}
|
||||
if (mOptions.CPreprocessorOptions != NULL) {
|
||||
strcat (PreProcessCmd, mOptions.CPreprocessorOptions), strcat (PreProcessCmd, " ");
|
||||
}
|
||||
strcat (PreProcessCmd, mOptions.VfrFileName), strcat (PreProcessCmd, " > ");
|
||||
strcat (PreProcessCmd, mOptions.PreprocessorOutputFileName);
|
||||
|
||||
if (system (PreProcessCmd) != 0) {
|
||||
printf ("%s failed to spawn C preprocessor on VFR file \n\t - %s\n", PROGRAM_NAME, PreProcessCmd);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
delete PreProcessCmd;
|
||||
SET_RUN_STATUS (STATUS_PREPROCESSED);
|
||||
return;
|
||||
|
||||
Fail:
|
||||
if (!IS_RUN_STATUS(STATUS_DEAD)) {
|
||||
SET_RUN_STATUS (STATUS_FAILED);
|
||||
}
|
||||
delete PreProcessCmd;
|
||||
}
|
||||
|
||||
extern UINT8 VfrParserStart (IN FILE *);
|
||||
|
||||
VOID
|
||||
CVfrCompiler::Compile (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
FILE *VfrFile = NULL;
|
||||
|
||||
if (!IS_RUN_STATUS(STATUS_PREPROCESSED)) {
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if ((VfrFile = fopen (mOptions.PreprocessorOutputFileName, "r")) == NULL) {
|
||||
printf ("%s failed to open input VFR preprocessor output file - %s\n", PROGRAM_NAME, mOptions.PreprocessorOutputFileName);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if (VfrParserStart (VfrFile) != 0) {
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
fclose (VfrFile);
|
||||
|
||||
if (gCFormPkg.HavePendingUnassigned () == TRUE) {
|
||||
gCFormPkg.PendingAssignPrintAll ();
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
SET_RUN_STATUS (STATUS_COMPILEED);
|
||||
return;
|
||||
|
||||
Fail:
|
||||
if (!IS_RUN_STATUS(STATUS_DEAD)) {
|
||||
printf ("%s compile error!\n", PROGRAM_NAME);
|
||||
SET_RUN_STATUS (STATUS_FAILED);
|
||||
}
|
||||
if (VfrFile != NULL) {
|
||||
fclose (VfrFile);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::GenBinary (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
FILE *pFile = NULL;
|
||||
|
||||
if (!IS_RUN_STATUS(STATUS_COMPILEED)) {
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if (mOptions.CreateIfrPkgFile == TRUE) {
|
||||
if ((pFile = fopen (mOptions.PkgOutputFileName, "wb")) == NULL) {
|
||||
printf ("can not open PkgFileName\n", mOptions.PkgOutputFileName);
|
||||
goto Fail;
|
||||
}
|
||||
if (gCFormPkg.BuildPkg (pFile) != VFR_RETURN_SUCCESS) {
|
||||
fclose (pFile);
|
||||
goto Fail;
|
||||
}
|
||||
fclose (pFile);
|
||||
}
|
||||
|
||||
SET_RUN_STATUS (STATUS_GENBINARY);
|
||||
return;
|
||||
|
||||
Fail:
|
||||
if (!IS_RUN_STATUS(STATUS_DEAD)) {
|
||||
SET_RUN_STATUS (STATUS_FAILED);
|
||||
}
|
||||
}
|
||||
|
||||
static const char *gSourceFileHeader[] = {
|
||||
"//",
|
||||
"// DO NOT EDIT -- auto-generated file",
|
||||
"//",
|
||||
"// This file is generated by the vfrcompiler utility",
|
||||
"//",
|
||||
NULL
|
||||
};
|
||||
|
||||
VOID
|
||||
CVfrCompiler::GenCFile (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
FILE *pFile;
|
||||
UINT32 Index;
|
||||
|
||||
if (!IS_RUN_STATUS(STATUS_GENBINARY)) {
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
if ((pFile = fopen (mOptions.COutputFileName, "w")) == NULL) {
|
||||
printf ("failed to open output C file - %s\n", mOptions.COutputFileName);
|
||||
goto Fail;
|
||||
}
|
||||
|
||||
for (Index = 0; gSourceFileHeader[Index] != NULL; Index++) {
|
||||
fprintf (pFile, "%s\n", gSourceFileHeader[Index]);
|
||||
}
|
||||
|
||||
gCVfrBufferConfig.OutputCFile (pFile, mOptions.VfrBaseFileName);
|
||||
|
||||
if (gCFormPkg.GenCFile (mOptions.VfrBaseFileName, pFile) != VFR_RETURN_SUCCESS) {
|
||||
fclose (pFile);
|
||||
goto Fail;
|
||||
}
|
||||
fclose (pFile);
|
||||
|
||||
SET_RUN_STATUS (STATUS_FINISHED);
|
||||
return;
|
||||
|
||||
Fail:
|
||||
if (!IS_RUN_STATUS(STATUS_DEAD)) {
|
||||
SET_RUN_STATUS (STATUS_FAILED);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrCompiler::GenRecordListFile (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
FILE *pInFile = NULL;
|
||||
FILE *pOutFile = NULL;
|
||||
INT8 LineBuf[MAX_LINE_LEN];
|
||||
UINT32 LineNo;
|
||||
|
||||
if (mOptions.CreateRecordListFile == TRUE) {
|
||||
if ((mOptions.PreprocessorOutputFileName[0] == '\0') || (mOptions.RecordListFile[0] == '\0')) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((pInFile = fopen (mOptions.PreprocessorOutputFileName, "r")) == NULL) {
|
||||
printf ("%s failed to open input VFR preprocessor output file - %s\n", PROGRAM_NAME, mOptions.PreprocessorOutputFileName);
|
||||
return;
|
||||
}
|
||||
|
||||
if ((pOutFile = fopen (mOptions.RecordListFile, "w")) == NULL) {
|
||||
printf ("%s failed to open record list file for writing - %s\n", PROGRAM_NAME, mOptions.RecordListFile);
|
||||
goto Err1;
|
||||
}
|
||||
|
||||
fprintf (pOutFile, "//\n// VFR compiler version " VFR_COMPILER_VERSION "\n//\n");
|
||||
LineNo = 0;
|
||||
while (!feof (pInFile)) {
|
||||
if (fgets (LineBuf, MAX_LINE_LEN, pInFile) != NULL) {
|
||||
fprintf (pOutFile, "%s", LineBuf);
|
||||
LineNo++;
|
||||
gCIfrRecordInfoDB.IfrRecordOutput (pOutFile, LineNo);
|
||||
}
|
||||
}
|
||||
|
||||
fclose (pOutFile);
|
||||
fclose (pInFile);
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
Err1:
|
||||
fclose (pInFile);
|
||||
}
|
||||
|
||||
INT32
|
||||
main (
|
||||
IN INT32 Argc,
|
||||
IN INT8 **Argv
|
||||
)
|
||||
{
|
||||
COMPILER_RUN_STATUS Status;
|
||||
CVfrCompiler Compiler(Argc, Argv);
|
||||
|
||||
Compiler.PreProcess();
|
||||
Compiler.Compile();
|
||||
Compiler.GenBinary();
|
||||
Compiler.GenCFile();
|
||||
Compiler.GenRecordListFile ();
|
||||
|
||||
Status = Compiler.RunStatus ();
|
||||
if ((Status == STATUS_DEAD) || (Status == STATUS_FAILED)) {
|
||||
return 2;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
#ifndef _VFRCOMPILER_H_
|
||||
#define _VFRCOMPILER_H_
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "EfiTypes.h"
|
||||
#include "EfiVfr.h"
|
||||
#include "VfrFormPkg.h"
|
||||
#include "VfrUtilityLib.h"
|
||||
|
||||
#define PROGRAM_NAME "VfrCompile"
|
||||
#define VFR_COMPILER_VERSION "UEFI 2.1"
|
||||
|
||||
//
|
||||
// This is how we invoke the C preprocessor on the VFR source file
|
||||
// to resolve #defines, #includes, etc. To make C source files
|
||||
// shareable between VFR and drivers, define VFRCOMPILE so that
|
||||
// #ifdefs can be used in shared .h files.
|
||||
//
|
||||
#define PREPROCESSOR_COMMAND "cl "
|
||||
#define PREPROCESSOR_OPTIONS "/nologo /E /TC /DVFRCOMPILE "
|
||||
|
||||
//
|
||||
// Specify the filename extensions for the files we generate.
|
||||
//
|
||||
#define VFR_PREPROCESS_FILENAME_EXTENSION ".i"
|
||||
#define VFR_PACKAGE_FILENAME_EXTENSION ".hpk"
|
||||
#define VFR_RECORDLIST_FILENAME_EXTENSION ".lst"
|
||||
|
||||
typedef struct {
|
||||
INT8 VfrFileName[MAX_PATH];
|
||||
INT8 RecordListFile[MAX_PATH];
|
||||
INT8 PkgOutputFileName[MAX_PATH];
|
||||
INT8 COutputFileName[MAX_PATH];
|
||||
bool CreateRecordListFile;
|
||||
bool CreateIfrPkgFile;
|
||||
INT8 OutputDirectory[MAX_PATH];
|
||||
INT8 PreprocessorOutputFileName[MAX_PATH];
|
||||
INT8 VfrBaseFileName[MAX_PATH]; // name of input VFR file with no path or extension
|
||||
INT8 *IncludePaths;
|
||||
INT8 *CPreprocessorOptions;
|
||||
} OPTIONS;
|
||||
|
||||
typedef enum {
|
||||
STATUS_INITIALIZED = 1,
|
||||
STATUS_PREPROCESSED,
|
||||
STATUS_COMPILEED,
|
||||
STATUS_GENBINARY,
|
||||
STATUS_FINISHED,
|
||||
STATUS_FAILED,
|
||||
STATUS_DEAD,
|
||||
} COMPILER_RUN_STATUS;
|
||||
|
||||
class CVfrCompiler {
|
||||
private:
|
||||
COMPILER_RUN_STATUS mRunStatus;
|
||||
OPTIONS mOptions;
|
||||
INT8 *mPreProcessCmd;
|
||||
INT8 *mPreProcessOpt;
|
||||
|
||||
VOID OptionInitialization (IN INT32 , IN INT8 **);
|
||||
VOID AppendIncludePath (IN INT8 *);
|
||||
VOID AppendCPreprocessorOptions (IN INT8 *);
|
||||
INT8 SetBaseFileName (VOID);
|
||||
INT8 SetPkgOutputFileName (VOID);
|
||||
INT8 SetCOutputFileName(VOID);
|
||||
INT8 SetPreprocessorOutputFileName (VOID);
|
||||
INT8 SetRecordListFileName (VOID);
|
||||
|
||||
VOID SET_RUN_STATUS (IN COMPILER_RUN_STATUS);
|
||||
BOOLEAN IS_RUN_STATUS (IN COMPILER_RUN_STATUS);
|
||||
|
||||
public:
|
||||
COMPILER_RUN_STATUS RunStatus (VOID) {
|
||||
return mRunStatus;
|
||||
}
|
||||
|
||||
public:
|
||||
CVfrCompiler (IN INT32 , IN INT8 **);
|
||||
~CVfrCompiler ();
|
||||
|
||||
VOID Usage (VOID);
|
||||
|
||||
VOID PreProcess (VOID);
|
||||
VOID Compile (VOID);
|
||||
VOID GenBinary (VOID);
|
||||
VOID GenCFile (VOID);
|
||||
VOID GenRecordListFile (VOID);
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,197 @@
|
||||
#include "stdio.h"
|
||||
#include "string.h"
|
||||
#include "stdlib.h"
|
||||
#include "VfrError.h"
|
||||
|
||||
static SVFR_ERROR_HANDLE VFR_ERROR_HANDLE_TABLE [] = {
|
||||
{ VFR_RETURN_SUCCESS, NULL },
|
||||
{ VFR_RETURN_ERROR_SKIPED, NULL },
|
||||
{ VFR_RETURN_FATAL_ERROR, "fatal error!!" },
|
||||
|
||||
{ VFR_RETURN_MISMATCHED, "unexpected token" },
|
||||
{ VFR_RETURN_INVALID_PARAMETER, "Invalid parameter" },
|
||||
{ VFR_RETURN_OUT_FOR_RESOURCES, "system out of memory" },
|
||||
{ VFR_RETURN_UNSUPPORTED, "unsupported" },
|
||||
{ VFR_RETURN_REDEFINED, "already defined" },
|
||||
{ VFR_RETURN_FORMID_REDEFINED, "form id already defined" },
|
||||
{ VFR_RETURN_QUESTIONID_REDEFINED, "question id already defined" },
|
||||
{ VFR_RETURN_VARSTOREID_REDEFINED, "varstore id already defined" },
|
||||
{ VFR_RETURN_UNDEFINED, "undefined" },
|
||||
{ VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION, "some variable has not defined by a question"},
|
||||
{ VFR_RETURN_GET_EFIVARSTORE_ERROR, "get efi varstore error"},
|
||||
{ VFR_RETURN_EFIVARSTORE_USE_ERROR, "can not use the efi varstore like this" },
|
||||
{ VFR_RETURN_EFIVARSTORE_SIZE_ERROR, "unsupport efi varstore size should be <= 8 bytes" },
|
||||
{ VFR_RETURN_GET_NVVARSTORE_ERROR, "get name value varstore error" },
|
||||
{ VFR_RETURN_QVAR_REUSE, "variable reused by more than one question" },
|
||||
{ VFR_RETURN_FLAGS_UNSUPPORTED, "flags unsupported" },
|
||||
{ VFR_RETURN_ERROR_ARRARY_NUM, "array number error" },
|
||||
{ VFR_RETURN_DATA_STRING_ERROR, "data field string error or not support"},
|
||||
{ VFR_RETURN_CODEUNDEFINED, "Undefined Error Code" }
|
||||
};
|
||||
|
||||
CVfrErrorHandle::CVfrErrorHandle (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
mScopeRecordListHead = NULL;
|
||||
mScopeRecordListTail = NULL;
|
||||
mVfrErrorHandleTable = VFR_ERROR_HANDLE_TABLE;
|
||||
}
|
||||
|
||||
CVfrErrorHandle::~CVfrErrorHandle (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
SVfrFileScopeRecord *pNode = NULL;
|
||||
|
||||
while (mScopeRecordListHead != NULL) {
|
||||
pNode = mScopeRecordListHead;
|
||||
mScopeRecordListHead = mScopeRecordListHead->mNext;
|
||||
delete pNode;
|
||||
}
|
||||
|
||||
mScopeRecordListHead = NULL;
|
||||
mScopeRecordListTail = NULL;
|
||||
mVfrErrorHandleTable = NULL;
|
||||
}
|
||||
|
||||
SVfrFileScopeRecord::SVfrFileScopeRecord (
|
||||
IN INT8 *Record,
|
||||
IN UINT32 LineNum
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
INT8 *FileName = NULL;
|
||||
INT8 *Str = NULL;
|
||||
|
||||
mWholeScopeLine = LineNum;
|
||||
mNext = NULL;
|
||||
|
||||
Str = strchr (Record, ' ');
|
||||
mScopeLineStart = atoi (++Str);
|
||||
|
||||
Str = strchr (Str, '\"');
|
||||
FileName = ++Str;
|
||||
|
||||
while((Str = strstr (FileName, "\\\\")) != NULL) {
|
||||
FileName = Str + 2;
|
||||
}
|
||||
if ((mFileName = new INT8[strlen(FileName)]) != NULL) {
|
||||
for (Index = 0; FileName[Index] != '\"'; Index++) {
|
||||
mFileName[Index] = FileName[Index];
|
||||
}
|
||||
mFileName[Index] = '\0';
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
SVfrFileScopeRecord::~SVfrFileScopeRecord (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mFileName != NULL) {
|
||||
delete mFileName;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrErrorHandle::ParseFileScopeRecord (
|
||||
IN INT8 *Record,
|
||||
IN UINT32 WholeScopeLine
|
||||
)
|
||||
{
|
||||
INT8 *FullPathName = NULL;
|
||||
SVfrFileScopeRecord *pNode = NULL;
|
||||
|
||||
if (Record == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if ((pNode = new SVfrFileScopeRecord(Record, WholeScopeLine)) == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (mScopeRecordListHead == NULL) {
|
||||
mScopeRecordListTail = mScopeRecordListHead = pNode;
|
||||
} else {
|
||||
mScopeRecordListTail->mNext = pNode;
|
||||
mScopeRecordListTail = pNode;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrErrorHandle::GetFileNameLineNum (
|
||||
IN UINT32 LineNum,
|
||||
OUT INT8 **FileName,
|
||||
OUT UINT32 *FileLine
|
||||
)
|
||||
{
|
||||
SVfrFileScopeRecord *pNode = NULL;
|
||||
|
||||
if ((FileName == NULL) || (FileLine == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
*FileName = NULL;
|
||||
*FileLine = 0xFFFFFFFF;
|
||||
|
||||
for (pNode = mScopeRecordListHead; pNode->mNext != NULL; pNode = pNode->mNext) {
|
||||
if ((LineNum > pNode->mWholeScopeLine) && (pNode->mNext->mWholeScopeLine > LineNum)) {
|
||||
*FileName = pNode->mFileName;
|
||||
*FileLine = LineNum - pNode->mWholeScopeLine + pNode->mScopeLineStart - 1;
|
||||
return ;
|
||||
}
|
||||
}
|
||||
|
||||
*FileName = pNode->mFileName;
|
||||
*FileLine = LineNum - pNode->mWholeScopeLine + pNode->mScopeLineStart - 1;
|
||||
}
|
||||
|
||||
VOID
|
||||
CVfrErrorHandle::PrintError (
|
||||
IN UINT32 LineNum,
|
||||
IN INT8 *TokName,
|
||||
IN INT8 *ErrorMsg
|
||||
)
|
||||
{
|
||||
INT8 *FileName = NULL;
|
||||
UINT32 FileLine;
|
||||
|
||||
GetFileNameLineNum (LineNum, &FileName, &FileLine);
|
||||
printf ("%s line %d: error %s %s\n", FileName, FileLine, TokName, ErrorMsg);
|
||||
}
|
||||
|
||||
UINT8
|
||||
CVfrErrorHandle::HandleError (
|
||||
IN EFI_VFR_RETURN_CODE ErrorCode,
|
||||
IN UINT32 LineNum,
|
||||
IN INT8 *TokName
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
INT8 *FileName = NULL;
|
||||
UINT32 FileLine;
|
||||
INT8 *ErrorMsg = NULL;
|
||||
|
||||
if (mVfrErrorHandleTable == NULL) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
for (Index = 0; mVfrErrorHandleTable[Index].mErrorCode != VFR_RETURN_CODEUNDEFINED; Index++) {
|
||||
if (ErrorCode == mVfrErrorHandleTable[Index].mErrorCode) {
|
||||
ErrorMsg = mVfrErrorHandleTable[Index].mErrorMsg;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (ErrorMsg != NULL) {
|
||||
GetFileNameLineNum (LineNum, &FileName, &FileLine);
|
||||
printf ("%s line %d: error %s %s\n", FileName, FileLine, TokName, ErrorMsg);
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
CVfrErrorHandle gCVfrErrorHandle;
|
||||
@@ -0,0 +1,67 @@
|
||||
#ifndef _VFRERROR_H_
|
||||
#define _VFRERROR_H_
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "EfiTypes.h"
|
||||
|
||||
typedef enum {
|
||||
VFR_RETURN_SUCCESS = 0,
|
||||
VFR_RETURN_ERROR_SKIPED,
|
||||
VFR_RETURN_FATAL_ERROR,
|
||||
VFR_RETURN_MISMATCHED,
|
||||
VFR_RETURN_INVALID_PARAMETER,
|
||||
VFR_RETURN_OUT_FOR_RESOURCES,
|
||||
VFR_RETURN_UNSUPPORTED,
|
||||
VFR_RETURN_REDEFINED,
|
||||
VFR_RETURN_FORMID_REDEFINED,
|
||||
VFR_RETURN_QUESTIONID_REDEFINED,
|
||||
VFR_RETURN_VARSTOREID_REDEFINED,
|
||||
VFR_RETURN_UNDEFINED,
|
||||
VFR_RETURN_VAR_NOTDEFINED_BY_QUESTION,
|
||||
VFR_RETURN_GET_EFIVARSTORE_ERROR,
|
||||
VFR_RETURN_EFIVARSTORE_USE_ERROR,
|
||||
VFR_RETURN_EFIVARSTORE_SIZE_ERROR,
|
||||
VFR_RETURN_GET_NVVARSTORE_ERROR,
|
||||
VFR_RETURN_QVAR_REUSE,
|
||||
VFR_RETURN_FLAGS_UNSUPPORTED,
|
||||
VFR_RETURN_ERROR_ARRARY_NUM,
|
||||
VFR_RETURN_DATA_STRING_ERROR,
|
||||
VFR_RETURN_CODEUNDEFINED
|
||||
} EFI_VFR_RETURN_CODE;
|
||||
|
||||
typedef struct _SVFR_ERROR_HANDLE {
|
||||
EFI_VFR_RETURN_CODE mErrorCode;
|
||||
INT8 *mErrorMsg;
|
||||
} SVFR_ERROR_HANDLE;
|
||||
|
||||
struct SVfrFileScopeRecord {
|
||||
INT8 *mFileName;
|
||||
UINT32 mWholeScopeLine;
|
||||
UINT32 mScopeLineStart;
|
||||
SVfrFileScopeRecord *mNext;
|
||||
|
||||
SVfrFileScopeRecord (IN INT8 *, IN UINT32);
|
||||
~SVfrFileScopeRecord();
|
||||
};
|
||||
|
||||
class CVfrErrorHandle {
|
||||
private:
|
||||
SVFR_ERROR_HANDLE *mVfrErrorHandleTable;
|
||||
SVfrFileScopeRecord *mScopeRecordListHead;
|
||||
SVfrFileScopeRecord *mScopeRecordListTail;
|
||||
|
||||
public:
|
||||
CVfrErrorHandle (VOID);
|
||||
~CVfrErrorHandle (VOID);
|
||||
|
||||
VOID ParseFileScopeRecord (IN INT8 *, IN UINT32);
|
||||
VOID GetFileNameLineNum (IN UINT32, OUT INT8 **, OUT UINT32 *);
|
||||
UINT8 HandleError (IN EFI_VFR_RETURN_CODE, IN UINT32 LineNum = 0, IN INT8 *TokName = "\0");
|
||||
VOID PrintError (IN UINT32 LineNum = 0, IN INT8 *TokName = "\0", IN INT8 *ErrorMsg = "\0");
|
||||
};
|
||||
|
||||
#define CHECK_ERROR_RETURN(f, v) do { EFI_VFR_RETURN_CODE r; if ((r = (f)) != (v)) { return r; } } while (0)
|
||||
|
||||
extern CVfrErrorHandle gCVfrErrorHandle;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,830 @@
|
||||
#include "stdio.h"
|
||||
#include "VfrFormPkg.h"
|
||||
|
||||
/*
|
||||
* The definition of CFormPkg's member function
|
||||
*/
|
||||
|
||||
SPendingAssign::SPendingAssign (
|
||||
IN INT8 *Key,
|
||||
IN VOID *Addr,
|
||||
IN UINT32 Len,
|
||||
IN UINT32 LineNo
|
||||
)
|
||||
{
|
||||
if (Key != NULL) {
|
||||
mKey = new INT8[strlen (Key) + 1];
|
||||
if (mKey != NULL) {
|
||||
strcpy (mKey, Key);
|
||||
}
|
||||
} else {
|
||||
mKey = NULL;
|
||||
}
|
||||
mAddr = Addr;
|
||||
mLen = Len;
|
||||
mFlag = PENDING;
|
||||
mLineNo = LineNo;
|
||||
mNext = NULL;
|
||||
}
|
||||
|
||||
SPendingAssign::~SPendingAssign (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mKey != NULL) {
|
||||
delete mKey;
|
||||
}
|
||||
mAddr = NULL;
|
||||
mLen = 0;
|
||||
mLineNo = 0;
|
||||
mNext = NULL;
|
||||
}
|
||||
|
||||
VOID
|
||||
SPendingAssign::SetAddrAndLen (
|
||||
IN VOID *Addr,
|
||||
IN UINT32 LineNo
|
||||
)
|
||||
{
|
||||
mAddr = Addr;
|
||||
mLineNo = LineNo;
|
||||
}
|
||||
|
||||
VOID
|
||||
SPendingAssign::AssignValue (
|
||||
IN VOID *Addr,
|
||||
IN UINT32 Len
|
||||
)
|
||||
{
|
||||
memcpy (mAddr, Addr, (mLen < Len ? mLen : Len));
|
||||
mFlag = ASSIGNED;
|
||||
}
|
||||
|
||||
INT8 *
|
||||
SPendingAssign::GetKey (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
return mKey;
|
||||
}
|
||||
|
||||
CFormPkg::CFormPkg (
|
||||
IN UINT32 BufferSize = 4096
|
||||
)
|
||||
{
|
||||
CHAR8 *BufferStart;
|
||||
CHAR8 *BufferEnd;
|
||||
SBufferNode *Node;
|
||||
|
||||
mPkgLength = 0;
|
||||
mBufferNodeQueueHead = NULL;
|
||||
mCurrBufferNode = NULL;
|
||||
|
||||
Node = new SBufferNode;
|
||||
if (Node == NULL) {
|
||||
return ;
|
||||
}
|
||||
BufferStart = new CHAR8[BufferSize];
|
||||
if (BufferStart == NULL) {
|
||||
return;
|
||||
}
|
||||
BufferEnd = BufferStart + BufferSize;
|
||||
|
||||
memset (BufferStart, 0, BufferSize);
|
||||
Node->mBufferStart = BufferStart;
|
||||
Node->mBufferEnd = BufferEnd;
|
||||
Node->mBufferFree = BufferStart;
|
||||
Node->mNext = NULL;
|
||||
|
||||
mBufferSize = BufferSize;
|
||||
mBufferNodeQueueHead = Node;
|
||||
mBufferNodeQueueTail = Node;
|
||||
mCurrBufferNode = Node;
|
||||
}
|
||||
|
||||
CFormPkg::~CFormPkg ()
|
||||
{
|
||||
SBufferNode *pBNode;
|
||||
SPendingAssign *pPNode;
|
||||
|
||||
while (mBufferNodeQueueHead != NULL) {
|
||||
pBNode = mBufferNodeQueueHead;
|
||||
mBufferNodeQueueHead = mBufferNodeQueueHead->mNext;
|
||||
if (pBNode->mBufferStart != NULL) {
|
||||
delete pBNode->mBufferStart;
|
||||
delete pBNode;
|
||||
}
|
||||
}
|
||||
mBufferNodeQueueTail = NULL;
|
||||
mCurrBufferNode = NULL;
|
||||
|
||||
while (PendingAssignList != NULL) {
|
||||
pPNode = PendingAssignList;
|
||||
PendingAssignList = PendingAssignList->mNext;
|
||||
delete pPNode;
|
||||
}
|
||||
PendingAssignList = NULL;
|
||||
}
|
||||
|
||||
CHAR8 *
|
||||
CFormPkg::IfrBinBufferGet (
|
||||
IN UINT32 Len
|
||||
)
|
||||
{
|
||||
CHAR8 *BinBuffer = NULL;
|
||||
|
||||
if ((Len == 0) || (Len > mBufferSize)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((mCurrBufferNode->mBufferFree + Len) <= mCurrBufferNode->mBufferEnd) {
|
||||
BinBuffer = mCurrBufferNode->mBufferFree;
|
||||
mCurrBufferNode->mBufferFree += Len;
|
||||
} else {
|
||||
SBufferNode *Node;
|
||||
|
||||
Node = new SBufferNode;
|
||||
if (Node == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
Node->mBufferStart = new CHAR8[mBufferSize];
|
||||
if (Node->mBufferStart == NULL) {
|
||||
delete Node;
|
||||
return NULL;
|
||||
} else {
|
||||
memset (Node->mBufferStart, 0, mBufferSize);
|
||||
Node->mBufferEnd = Node->mBufferStart + mBufferSize;
|
||||
Node->mBufferFree = Node->mBufferStart;
|
||||
Node->mNext = NULL;
|
||||
}
|
||||
|
||||
if (mBufferNodeQueueTail == NULL) {
|
||||
mBufferNodeQueueHead = mBufferNodeQueueTail = Node;
|
||||
} else {
|
||||
mBufferNodeQueueTail->mNext = Node;
|
||||
mBufferNodeQueueTail = Node;
|
||||
}
|
||||
mCurrBufferNode = Node;
|
||||
|
||||
//
|
||||
// Now try again.
|
||||
//
|
||||
BinBuffer = mCurrBufferNode->mBufferFree;
|
||||
mCurrBufferNode->mBufferFree += Len;
|
||||
}
|
||||
|
||||
mPkgLength += Len;
|
||||
|
||||
return BinBuffer;
|
||||
}
|
||||
|
||||
inline
|
||||
UINT32
|
||||
CFormPkg::GetPkgLength (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
return mPkgLength;
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::Open (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
mReadBufferNode = mBufferNodeQueueHead;
|
||||
mReadBufferOffset = 0;
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::Close (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
mReadBufferNode = NULL;
|
||||
mReadBufferOffset = 0;
|
||||
}
|
||||
|
||||
UINT32
|
||||
CFormPkg::Read (
|
||||
IN CHAR8 *Buffer,
|
||||
IN UINT32 Size
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
|
||||
if ((Size == 0) || (Buffer == NULL)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (mReadBufferNode == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < Size; Index++) {
|
||||
if ((mReadBufferNode->mBufferStart + mReadBufferOffset) < mReadBufferNode->mBufferFree) {
|
||||
Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++];
|
||||
} else {
|
||||
if ((mReadBufferNode = mReadBufferNode->mNext) == NULL) {
|
||||
return Index;
|
||||
} else {
|
||||
mReadBufferOffset = 0;
|
||||
Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return Size;
|
||||
}
|
||||
|
||||
EFI_VFR_RETURN_CODE
|
||||
CFormPkg::BuildPkgHdr (
|
||||
OUT EFI_HII_PACKAGE_HEADER **PkgHdr
|
||||
)
|
||||
{
|
||||
if (PkgHdr == NULL) {
|
||||
return VFR_RETURN_FATAL_ERROR;
|
||||
}
|
||||
|
||||
if (((*PkgHdr) = new EFI_HII_PACKAGE_HEADER) == NULL) {
|
||||
return VFR_RETURN_OUT_FOR_RESOURCES;
|
||||
}
|
||||
|
||||
(*PkgHdr)->Type = EFI_HII_PACKAGE_FORM;
|
||||
(*PkgHdr)->Length = mPkgLength + sizeof (EFI_HII_PACKAGE_HEADER);
|
||||
return VFR_RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_VFR_RETURN_CODE
|
||||
CFormPkg::BuildPkg (
|
||||
IN FILE *Output
|
||||
)
|
||||
{
|
||||
EFI_VFR_RETURN_CODE Ret;
|
||||
CHAR8 Buffer[1024];
|
||||
UINT32 Size;
|
||||
EFI_HII_PACKAGE_HEADER *PkgHdr;
|
||||
|
||||
if (Output == NULL) {
|
||||
return VFR_RETURN_FATAL_ERROR;
|
||||
}
|
||||
|
||||
if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
|
||||
return Ret;
|
||||
}
|
||||
fwrite (PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER), 1, Output);
|
||||
delete PkgHdr;
|
||||
|
||||
Open ();
|
||||
while ((Size = Read (Buffer, 1024)) != 0) {
|
||||
fwrite (Buffer, Size, 1, Output);
|
||||
}
|
||||
Close ();
|
||||
|
||||
return VFR_RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::_WRITE_PKG_LINE (
|
||||
IN FILE *pFile,
|
||||
IN UINT32 LineBytes,
|
||||
IN INT8 *LineHeader,
|
||||
IN INT8 *BlkBuf,
|
||||
IN UINT32 BlkSize
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
|
||||
if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < BlkSize; Index++) {
|
||||
if ((Index % LineBytes) == 0) {
|
||||
fprintf (pFile, "\n%s", LineHeader);
|
||||
}
|
||||
fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::_WRITE_PKG_END (
|
||||
IN FILE *pFile,
|
||||
IN UINT32 LineBytes,
|
||||
IN INT8 *LineHeader,
|
||||
IN INT8 *BlkBuf,
|
||||
IN UINT32 BlkSize
|
||||
)
|
||||
{
|
||||
UINT32 Index;
|
||||
|
||||
if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < BlkSize - 1; Index++) {
|
||||
if ((Index % LineBytes) == 0) {
|
||||
fprintf (pFile, "\n%s", LineHeader);
|
||||
}
|
||||
fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
|
||||
}
|
||||
|
||||
if ((Index % LineBytes) == 0) {
|
||||
fprintf (pFile, "\n%s", LineHeader);
|
||||
}
|
||||
fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]);
|
||||
}
|
||||
|
||||
#define BYTES_PRE_LINE 0x10
|
||||
|
||||
EFI_VFR_RETURN_CODE
|
||||
CFormPkg::GenCFile (
|
||||
IN INT8 *BaseName,
|
||||
IN FILE *pFile
|
||||
)
|
||||
{
|
||||
EFI_VFR_RETURN_CODE Ret;
|
||||
INT8 Buffer[BYTES_PRE_LINE * 8];
|
||||
EFI_HII_PACKAGE_HEADER *PkgHdr;
|
||||
UINT32 PkgLength = 0;
|
||||
UINT32 ReadSize = 0;
|
||||
|
||||
if ((BaseName == NULL) || (pFile == NULL)) {
|
||||
return VFR_RETURN_FATAL_ERROR;
|
||||
}
|
||||
|
||||
fprintf (pFile, "\nunsigned char %sBin[] = {\n", BaseName);
|
||||
|
||||
if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
|
||||
return Ret;
|
||||
}
|
||||
|
||||
fprintf (pFile, " // ARRAY LENGTH\n");
|
||||
PkgLength = PkgHdr->Length + sizeof (UINT32);
|
||||
_WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (INT8 *)&PkgLength, sizeof (UINT32));
|
||||
|
||||
fprintf (pFile, "\n\n // PACKAGE HEADER\n");
|
||||
_WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (INT8 *)PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER));
|
||||
PkgLength = sizeof (EFI_HII_PACKAGE_HEADER);
|
||||
|
||||
fprintf (pFile, "\n\n // PACKAGE DATA\n");
|
||||
Open ();
|
||||
while ((ReadSize = Read ((CHAR8 *)Buffer, BYTES_PRE_LINE * 8)) != 0) {
|
||||
PkgLength += ReadSize;
|
||||
if (PkgLength < PkgHdr->Length) {
|
||||
_WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize);
|
||||
} else {
|
||||
_WRITE_PKG_END (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize);
|
||||
}
|
||||
}
|
||||
Close ();
|
||||
|
||||
delete PkgHdr;
|
||||
fprintf (pFile, "\n};\n");
|
||||
|
||||
return VFR_RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_VFR_RETURN_CODE
|
||||
CFormPkg::AssignPending (
|
||||
IN INT8 *Key,
|
||||
IN VOID *ValAddr,
|
||||
IN UINT32 ValLen,
|
||||
IN UINT32 LineNo
|
||||
)
|
||||
{
|
||||
SPendingAssign *pNew;
|
||||
|
||||
pNew = new SPendingAssign (Key, ValAddr, ValLen, LineNo);
|
||||
if (pNew == NULL) {
|
||||
return VFR_RETURN_OUT_FOR_RESOURCES;
|
||||
}
|
||||
|
||||
pNew->mNext = PendingAssignList;
|
||||
PendingAssignList = pNew;
|
||||
return VFR_RETURN_SUCCESS;
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::DoPendingAssign (
|
||||
IN INT8 *Key,
|
||||
IN VOID *ValAddr,
|
||||
IN UINT32 ValLen
|
||||
)
|
||||
{
|
||||
SPendingAssign *pNode;
|
||||
|
||||
if ((Key == NULL) || (ValAddr == NULL)) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
|
||||
if (strcmp (pNode->mKey, Key) == 0) {
|
||||
pNode->AssignValue (ValAddr, ValLen);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
CFormPkg::HavePendingUnassigned (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
SPendingAssign *pNode;
|
||||
|
||||
for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
|
||||
if (pNode->mFlag == PENDING) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
VOID
|
||||
CFormPkg::PendingAssignPrintAll (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
SPendingAssign *pNode;
|
||||
|
||||
for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
|
||||
if (pNode->mFlag == PENDING) {
|
||||
gCVfrErrorHandle.PrintError (pNode->mLineNo, pNode->mKey, "can not assign value because not defined");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CFormPkg gCFormPkg;
|
||||
|
||||
SIfrRecord::SIfrRecord (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
mIfrBinBuf = NULL;
|
||||
mBinBufLen = 0;
|
||||
mLineNo = 0xFFFFFFFF;
|
||||
mOffset = 0xFFFFFFFF;
|
||||
mNext = NULL;
|
||||
}
|
||||
|
||||
SIfrRecord::~SIfrRecord (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if (mIfrBinBuf != NULL) {
|
||||
delete mIfrBinBuf;
|
||||
mIfrBinBuf = NULL;
|
||||
}
|
||||
mLineNo = 0xFFFFFFFF;
|
||||
mOffset = 0xFFFFFFFF;
|
||||
mBinBufLen = 0;
|
||||
mNext = NULL;
|
||||
}
|
||||
|
||||
CIfrRecordInfoDB::CIfrRecordInfoDB (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
mSwitch = FALSE;
|
||||
mRecordCount = EFI_IFR_RECORDINFO_IDX_START;
|
||||
mIfrRecordListHead = NULL;
|
||||
mIfrRecordListTail = NULL;
|
||||
}
|
||||
|
||||
CIfrRecordInfoDB::~CIfrRecordInfoDB (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
SIfrRecord *pNode;
|
||||
|
||||
while (mIfrRecordListHead != NULL) {
|
||||
pNode = mIfrRecordListHead;
|
||||
mIfrRecordListHead = mIfrRecordListHead->mNext;
|
||||
delete pNode;
|
||||
}
|
||||
}
|
||||
|
||||
SIfrRecord *
|
||||
CIfrRecordInfoDB::GetRecordInfoFromIdx (
|
||||
IN UINT32 RecordIdx
|
||||
)
|
||||
{
|
||||
UINT32 Idx;
|
||||
SIfrRecord *pNode = NULL;
|
||||
|
||||
if (RecordIdx == EFI_IFR_RECORDINFO_IDX_INVALUD) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
for (Idx = (EFI_IFR_RECORDINFO_IDX_START + 1), pNode = mIfrRecordListHead;
|
||||
(Idx != RecordIdx) && (pNode != NULL);
|
||||
Idx++, pNode = pNode->mNext)
|
||||
;
|
||||
|
||||
return pNode;
|
||||
}
|
||||
|
||||
UINT32
|
||||
CIfrRecordInfoDB::IfrRecordRegister (
|
||||
IN UINT32 LineNo,
|
||||
IN CHAR8 *IfrBinBuf,
|
||||
IN UINT8 BinBufLen,
|
||||
IN UINT32 Offset
|
||||
)
|
||||
{
|
||||
SIfrRecord *pNew;
|
||||
|
||||
if (mSwitch == FALSE) {
|
||||
return EFI_IFR_RECORDINFO_IDX_INVALUD;
|
||||
}
|
||||
|
||||
if ((pNew = new SIfrRecord) == NULL) {
|
||||
return EFI_IFR_RECORDINFO_IDX_INVALUD;
|
||||
}
|
||||
|
||||
if (mIfrRecordListHead == NULL) {
|
||||
mIfrRecordListHead = pNew;
|
||||
mIfrRecordListTail = pNew;
|
||||
} else {
|
||||
mIfrRecordListTail->mNext = pNew;
|
||||
mIfrRecordListTail = pNew;
|
||||
}
|
||||
mRecordCount++;
|
||||
|
||||
return mRecordCount;
|
||||
}
|
||||
|
||||
VOID
|
||||
CIfrRecordInfoDB::IfrRecordInfoUpdate (
|
||||
IN UINT32 RecordIdx,
|
||||
IN UINT32 LineNo,
|
||||
IN CHAR8 *BinBuf,
|
||||
IN UINT8 BinBufLen,
|
||||
IN UINT32 Offset
|
||||
)
|
||||
{
|
||||
SIfrRecord *pNode;
|
||||
|
||||
if ((pNode = GetRecordInfoFromIdx (RecordIdx)) == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
pNode->mLineNo = LineNo;
|
||||
pNode->mOffset = Offset;
|
||||
pNode->mBinBufLen = BinBufLen;
|
||||
if (BinBuf != NULL) {
|
||||
if (pNode->mIfrBinBuf != NULL) {
|
||||
delete pNode->mIfrBinBuf;
|
||||
}
|
||||
pNode->mIfrBinBuf = new CHAR8[BinBufLen];
|
||||
if (pNode->mIfrBinBuf != NULL) {
|
||||
memcpy (pNode->mIfrBinBuf, BinBuf, BinBufLen);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CIfrRecordInfoDB::IfrRecordOutput (
|
||||
IN FILE *File,
|
||||
IN UINT32 LineNo
|
||||
)
|
||||
{
|
||||
SIfrRecord *pNode;
|
||||
UINT8 Index;
|
||||
|
||||
if (mSwitch == FALSE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (File == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
|
||||
if (pNode->mLineNo == LineNo) {
|
||||
fprintf (File, ">%08X: ", pNode->mOffset);
|
||||
if (pNode->mIfrBinBuf != NULL) {
|
||||
for (Index = 0; Index < pNode->mBinBufLen; Index++) {
|
||||
fprintf (File, "%02X ", pNode->mIfrBinBuf[Index]);
|
||||
}
|
||||
}
|
||||
fprintf (File, "\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CIfrRecordInfoDB gCIfrRecordInfoDB;
|
||||
|
||||
VOID
|
||||
CIfrObj::_EMIT_PENDING_OBJ (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
CHAR8 *ObjBinBuf = NULL;
|
||||
|
||||
ObjBinBuf = gCFormPkg.IfrBinBufferGet (mObjBinLen);
|
||||
if (ObjBinBuf != NULL) {
|
||||
memcpy (ObjBinBuf, mObjBinBuf, mObjBinLen);
|
||||
}
|
||||
|
||||
if (mObjBinBuf != NULL) {
|
||||
delete mObjBinBuf;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* The definition of CIfrObj's member function
|
||||
*/
|
||||
static struct {
|
||||
UINT8 mSize;
|
||||
UINT8 mScope;
|
||||
} gOpcodeSizesScopeTable[] = {
|
||||
{ 0, 0 }, // EFI_IFR_INVALID - 0x00
|
||||
{ sizeof (EFI_IFR_FORM), 1 }, // EFI_IFR_FORM_OP
|
||||
{ sizeof (EFI_IFR_SUBTITLE), 1 }, // EFI_IFR_SUBTITLE_OP
|
||||
{ sizeof (EFI_IFR_TEXT), 0 }, // EFI_IFR_TEXT_OP
|
||||
{ sizeof (EFI_IFR_IMAGE), 0 }, // EFI_IFR_IMAGE_OP
|
||||
{ sizeof (EFI_IFR_ONE_OF), 1 }, // EFI_IFR_ONE_OF_OP - 0x05
|
||||
{ sizeof (EFI_IFR_CHECKBOX), 1}, // EFI_IFR_CHECKBOX_OP
|
||||
{ sizeof (EFI_IFR_NUMERIC), 1 }, // EFI_IFR_NUMERIC_OP
|
||||
{ sizeof (EFI_IFR_PASSWORD), 1 }, // EFI_IFR_PASSWORD_OP
|
||||
{ sizeof (EFI_IFR_ONE_OF_OPTION), 0 }, // EFI_IFR_ONE_OF_OPTION_OP
|
||||
{ sizeof (EFI_IFR_SUPPRESS_IF), 1 }, // EFI_IFR_SUPPRESS_IF - 0x0A
|
||||
{ sizeof (EFI_IFR_LOCKED), 0 }, // EFI_IFR_LOCKED_OP
|
||||
{ sizeof (EFI_IFR_ACTION), 1 }, // EFI_IFR_ACTION_OP
|
||||
{ sizeof (EFI_IFR_RESET_BUTTON), 1 }, // EFI_IFR_RESET_BUTTON_OP
|
||||
{ sizeof (EFI_IFR_FORM_SET), 1 }, // EFI_IFR_FORM_SET_OP -0xE
|
||||
{ sizeof (EFI_IFR_REF), 0 }, // EFI_IFR_REF_OP
|
||||
{ sizeof (EFI_IFR_NO_SUBMIT_IF), 1}, // EFI_IFR_NO_SUBMIT_IF_OP -0x10
|
||||
{ sizeof (EFI_IFR_INCONSISTENT_IF), 1 }, // EFI_IFR_INCONSISTENT_IF_OP
|
||||
{ sizeof (EFI_IFR_EQ_ID_VAL), 0 }, // EFI_IFR_EQ_ID_VAL_OP
|
||||
{ sizeof (EFI_IFR_EQ_ID_ID), 0 }, // EFI_IFR_EQ_ID_ID_OP
|
||||
{ sizeof (EFI_IFR_EQ_ID_LIST), 0 }, // EFI_IFR_EQ_ID_LIST_OP - 0x14
|
||||
{ sizeof (EFI_IFR_AND), 0 }, // EFI_IFR_AND_OP
|
||||
{ sizeof (EFI_IFR_OR), 0 }, // EFI_IFR_OR_OP
|
||||
{ sizeof (EFI_IFR_NOT), 0 }, // EFI_IFR_NOT_OP
|
||||
{ sizeof (EFI_IFR_RULE), 1 }, // EFI_IFR_RULE_OP
|
||||
{ sizeof (EFI_IFR_GRAY_OUT_IF), 1 }, // EFI_IFR_GRAYOUT_IF_OP - 0x19
|
||||
{ sizeof (EFI_IFR_DATE), 1 }, // EFI_IFR_DATE_OP
|
||||
{ sizeof (EFI_IFR_TIME), 1 }, // EFI_IFR_TIME_OP
|
||||
{ sizeof (EFI_IFR_STRING), 1 }, // EFI_IFR_STRING_OP
|
||||
{ sizeof (EFI_IFR_REFRESH), 1 }, // EFI_IFR_REFRESH_OP
|
||||
{ sizeof (EFI_IFR_DISABLE_IF), 1 }, // EFI_IFR_DISABLE_IF_OP - 0x1E
|
||||
{ 0, 0 }, // 0x1F
|
||||
{ sizeof (EFI_IFR_TO_LOWER), 0 }, // EFI_IFR_TO_LOWER_OP - 0x20
|
||||
{ sizeof (EFI_IFR_TO_UPPER), 0 }, // EFI_IFR_TO_UPPER_OP - 0x21
|
||||
{ 0, 0 }, // 0x22
|
||||
{ sizeof (EFI_IFR_ORDERED_LIST), 1 }, // EFI_IFR_ORDERED_LIST_OP - 0x23
|
||||
{ sizeof (EFI_IFR_VARSTORE), 0 }, // EFI_IFR_VARSTORE_OP
|
||||
{ sizeof (EFI_IFR_VARSTORE_NAME_VALUE), 0 }, // EFI_IFR_VARSTORE_NAME_VALUE_OP
|
||||
{ sizeof (EFI_IFR_VARSTORE_EFI), 0 }, // EFI_IFR_VARSTORE_EFI_OP
|
||||
{ sizeof (EFI_IFR_VARSTORE_DEVICE), 1 }, // EFI_IFR_VARSTORE_DEVICE_OP
|
||||
{ sizeof (EFI_IFR_VERSION), 0 }, // EFI_IFR_VERSION_OP - 0x28
|
||||
{ sizeof (EFI_IFR_END), 0 }, // EFI_IFR_END_OP
|
||||
{ sizeof (EFI_IFR_MATCH), 1 }, // EFI_IFR_MATCH_OP - 0x2A
|
||||
{ 0, 0 }, { 0, 0} , { 0, 0} , { 0, 0} , // 0x2B ~ 0x2E
|
||||
{ sizeof (EFI_IFR_EQUAL), 0 }, // EFI_IFR_EQUAL_OP - 0x2F
|
||||
{ sizeof (EFI_IFR_NOT_EQUAL), 0 }, // EFI_IFR_NOT_EQUAL_OP
|
||||
{ sizeof (EFI_IFR_GREATER_THAN), 0 }, // EFI_IFR_GREATER_THAN_OP
|
||||
{ sizeof (EFI_IFR_GREATER_EQUAL), 0 }, // EFI_IFR_GREATER_EQUAL_OP
|
||||
{ sizeof (EFI_IFR_LESS_THAN), 0 }, // EFI_IFR_LESS_THAN_OP
|
||||
{ sizeof (EFI_IFR_LESS_EQUAL), 0 }, // EFI_IFR_LESS_EQUAL_OP - 0x34
|
||||
{ sizeof (EFI_IFR_BITWISE_AND), 0 }, // EFI_IFR_BITWISE_AND_OP
|
||||
{ sizeof (EFI_IFR_BITWISE_OR), 0 }, // EFI_IFR_BITWISE_OR_OP
|
||||
{ sizeof (EFI_IFR_BITWISE_NOT), 0 }, // EFI_IFR_BITWISE_NOT_OP
|
||||
{ sizeof (EFI_IFR_SHIFT_LEFT), 0 }, // EFI_IFR_SHIFT_LEFT_OP
|
||||
{ sizeof (EFI_IFR_SHIFT_RIGHT), 0 }, // EFI_IFR_SHIFT_RIGHT_OP
|
||||
{ sizeof (EFI_IFR_ADD), 0 }, // EFI_IFR_ADD_OP - 0x3A
|
||||
{ sizeof (EFI_IFR_SUBTRACT), 0 }, // EFI_IFR_SUBTRACT_OP
|
||||
{ sizeof (EFI_IFR_MULTIPLY), 0 }, // EFI_IFR_MULTIPLY_OP
|
||||
{ sizeof (EFI_IFR_DIVIDE), 0 }, // EFI_IFR_DIVIDE_OP
|
||||
{ sizeof (EFI_IFR_MODULO), 0 }, // EFI_IFR_MODULO_OP - 0x3E
|
||||
{ sizeof (EFI_IFR_RULE_REF), 0 }, // EFI_IFR_RULE_REF_OP
|
||||
{ sizeof (EFI_IFR_QUESTION_REF1), 0 }, // EFI_IFR_QUESTION_REF1_OP
|
||||
{ sizeof (EFI_IFR_QUESTION_REF2), 0 }, // EFI_IFR_QUESTION_REF2_OP - 0x41
|
||||
{ sizeof (EFI_IFR_UINT8), 0}, // EFI_IFR_UINT8
|
||||
{ sizeof (EFI_IFR_UINT16), 0}, // EFI_IFR_UINT16
|
||||
{ sizeof (EFI_IFR_UINT32), 0}, // EFI_IFR_UINT32
|
||||
{ sizeof (EFI_IFR_UINT64), 0}, // EFI_IFR_UTNT64
|
||||
{ sizeof (EFI_IFR_TRUE), 0 }, // EFI_IFR_TRUE_OP - 0x46
|
||||
{ sizeof (EFI_IFR_FALSE), 0 }, // EFI_IFR_FALSE_OP
|
||||
{ sizeof (EFI_IFR_TO_UINT), 0 }, // EFI_IFR_TO_UINT_OP
|
||||
{ sizeof (EFI_IFR_TO_STRING), 0 }, // EFI_IFR_TO_STRING_OP
|
||||
{ sizeof (EFI_IFR_TO_BOOLEAN), 0 }, // EFI_IFR_TO_BOOLEAN_OP
|
||||
{ sizeof (EFI_IFR_MID), 0 }, // EFI_IFR_MID_OP
|
||||
{ sizeof (EFI_IFR_FIND), 0 }, // EFI_IFR_FIND_OP
|
||||
{ sizeof (EFI_IFR_TOKEN), 0 }, // EFI_IFR_TOKEN_OP
|
||||
{ sizeof (EFI_IFR_STRING_REF1), 0 }, // EFI_IFR_STRING_REF1_OP - 0x4E
|
||||
{ sizeof (EFI_IFR_STRING_REF2), 0 }, // EFI_IFR_STRING_REF2_OP
|
||||
{ sizeof (EFI_IFR_CONDITIONAL), 0 }, // EFI_IFR_CONDITIONAL_OP
|
||||
{ sizeof (EFI_IFR_QUESTION_REF3), 0 }, // EFI_IFR_QUESTION_REF3_OP
|
||||
{ sizeof (EFI_IFR_ZERO), 0 }, // EFI_IFR_ZERO_OP
|
||||
{ sizeof (EFI_IFR_ONE), 0 }, // EFI_IFR_ONE_OP
|
||||
{ sizeof (EFI_IFR_ONES), 0 }, // EFI_IFR_ONES_OP
|
||||
{ sizeof (EFI_IFR_UNDEFINED), 0 }, // EFI_IFR_UNDEFINED_OP
|
||||
{ sizeof (EFI_IFR_LENGTH), 0 }, // EFI_IFR_LENGTH_OP
|
||||
{ sizeof (EFI_IFR_DUP), 0 }, // EFI_IFR_DUP_OP - 0x57
|
||||
{ sizeof (EFI_IFR_THIS), 0 }, // EFI_IFR_THIS_OP
|
||||
{ sizeof (EFI_IFR_SPAN), 0 }, // EFI_IFR_SPAN_OP
|
||||
{ sizeof (EFI_IFR_VALUE), 1 }, // EFI_IFR_VALUE_OP
|
||||
{ sizeof (EFI_IFR_DEFAULT), 0 }, // EFI_IFR_DEFAULT_OP
|
||||
{ sizeof (EFI_IFR_DEFAULTSTORE), 0 }, // EFI_IFR_DEFAULTSTORE_OP - 0x5C
|
||||
{ 0, 0}, // 0x5D
|
||||
{ sizeof (EFI_IFR_CATENATE), 0 }, // EFI_IFR_CATENATE_OP
|
||||
{ sizeof (EFI_IFR_GUID), 0 }, // EFI_IFR_GUID_OP
|
||||
};
|
||||
|
||||
#ifdef CIFROBJ_DEUBG
|
||||
static struct {
|
||||
INT8 *mIfrName;
|
||||
} gIfrObjPrintDebugTable[] = {
|
||||
"EFI_IFR_INVALID", "EFI_IFR_FORM", "EFI_IFR_SUBTITLE", "EFI_IFR_TEXT", "EFI_IFR_IMAGE", "EFI_IFR_ONE_OF",
|
||||
"EFI_IFR_CHECKBOX", "EFI_IFR_NUMERIC", "EFI_IFR_PASSWORD", "EFI_IFR_ONE_OF_OPTION", "EFI_IFR_SUPPRESS_IF", "EFI_IFR_LOCKED",
|
||||
"EFI_IFR_ACTION", "EFI_IFR_RESET_BUTTON", "EFI_IFR_FORM_SET", "EFI_IFR_REF", "EFI_IFR_NO_SUBMIT_IF", "EFI_IFR_INCONSISTENT_IF",
|
||||
"EFI_IFR_EQ_ID_VAL", "EFI_IFR_EQ_ID_ID", "EFI_IFR_EQ_ID_LIST", "EFI_IFR_AND", "EFI_IFR_OR", "EFI_IFR_NOT",
|
||||
"EFI_IFR_RULE", "EFI_IFR_GRAY_OUT_IF", "EFI_IFR_DATE", "EFI_IFR_TIME", "EFI_IFR_STRING", "EFI_IFR_REFRESH",
|
||||
"EFI_IFR_DISABLE_IF", "EFI_IFR_INVALID", "EFI_IFR_TO_LOWER", "EFI_IFR_TO_UPPER", "EFI_IFR_INVALID", "EFI_IFR_ORDERED_LIST",
|
||||
"EFI_IFR_VARSTORE", "EFI_IFR_VARSTORE_NAME_VALUE", "EFI_IFR_VARSTORE_EFI", "EFI_IFR_VARSTORE_DEVICE", "EFI_IFR_VERSION", "EFI_IFR_END",
|
||||
"EFI_IFR_MATCH", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_EQUAL",
|
||||
"EFI_IFR_NOT_EQUAL", "EFI_IFR_GREATER_THAN", "EFI_IFR_GREATER_EQUAL", "EFI_IFR_LESS_THAN", "EFI_IFR_LESS_EQUAL", "EFI_IFR_BITWISE_AND",
|
||||
"EFI_IFR_BITWISE_OR", "EFI_IFR_BITWISE_NOT", "EFI_IFR_SHIFT_LEFT", "EFI_IFR_SHIFT_RIGHT", "EFI_IFR_ADD", "EFI_IFR_SUBTRACT",
|
||||
"EFI_IFR_MULTIPLY", "EFI_IFR_DIVIDE", "EFI_IFR_MODULO", "EFI_IFR_RULE_REF", "EFI_IFR_QUESTION_REF1", "EFI_IFR_QUESTION_REF2",
|
||||
"EFI_IFR_UINT8", "EFI_IFR_UINT16", "EFI_IFR_UINT32", "EFI_IFR_UINT64", "EFI_IFR_TRUE", "EFI_IFR_FALSE",
|
||||
"EFI_IFR_TO_UINT", "EFI_IFR_TO_STRING", "EFI_IFR_TO_BOOLEAN", "EFI_IFR_MID", "EFI_IFR_FIND", "EFI_IFR_TOKEN",
|
||||
"EFI_IFR_STRING_REF1","EFI_IFR_STRING_REF2", "EFI_IFR_CONDITIONAL", "EFI_IFR_QUESTION_REF3", "EFI_IFR_ZERO", "EFI_IFR_ONE",
|
||||
"EFI_IFR_ONES", "EFI_IFR_UNDEFINED", "EFI_IFR_LENGTH", "EFI_IFR_DUP", "EFI_IFR_THIS", "EFI_IFR_SPAN",
|
||||
"EFI_IFR_VALUE", "EFI_IFR_DEFAULT", "EFI_IFR_DEFAULTSTORE", "EFI_IFR_INVALID", "EFI_IFR_CATENATE", "EFI_IFR_GUID",
|
||||
};
|
||||
|
||||
VOID
|
||||
CIFROBJ_DEBUG_PRINT (
|
||||
IN UINT8 OpCode
|
||||
)
|
||||
{
|
||||
printf ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode].mIfrName);
|
||||
}
|
||||
#else
|
||||
|
||||
#define CIFROBJ_DEBUG_PRINT(OpCode)
|
||||
|
||||
#endif
|
||||
|
||||
bool gCreateOp = TRUE;
|
||||
|
||||
CIfrObj::CIfrObj (
|
||||
IN UINT8 OpCode,
|
||||
OUT CHAR8 **IfrObj,
|
||||
IN UINT8 ObjBinLen,
|
||||
IN BOOLEAN DelayEmit
|
||||
)
|
||||
{
|
||||
mDelayEmit = DelayEmit;
|
||||
mPkgOffset = gCFormPkg.GetPkgLength ();
|
||||
mObjBinLen = (ObjBinLen == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : ObjBinLen;
|
||||
mObjBinBuf = ((DelayEmit == FALSE) && (gCreateOp == TRUE)) ? gCFormPkg.IfrBinBufferGet (mObjBinLen) : new CHAR8[EFI_IFR_MAX_LENGTH];
|
||||
mRecordIdx = (gCreateOp == TRUE) ? gCIfrRecordInfoDB.IfrRecordRegister (0xFFFFFFFF, mObjBinBuf, mObjBinLen, mPkgOffset) : EFI_IFR_RECORDINFO_IDX_INVALUD;
|
||||
|
||||
if (IfrObj != NULL) {
|
||||
*IfrObj = mObjBinBuf;
|
||||
}
|
||||
|
||||
CIFROBJ_DEBUG_PRINT (OpCode);
|
||||
}
|
||||
|
||||
CIfrObj::~CIfrObj (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
if ((mDelayEmit == TRUE) && ((gCreateOp == TRUE))) {
|
||||
_EMIT_PENDING_OBJ ();
|
||||
}
|
||||
|
||||
gCIfrRecordInfoDB.IfrRecordInfoUpdate (mRecordIdx, mLineNo, mObjBinBuf, mObjBinLen, mPkgOffset);
|
||||
}
|
||||
|
||||
/*
|
||||
* The definition of CIfrObj's member function
|
||||
*/
|
||||
UINT8 gScopeCount = 0;
|
||||
|
||||
CIfrOpHeader::CIfrOpHeader (
|
||||
IN UINT8 OpCode,
|
||||
IN VOID *StartAddr,
|
||||
IN UINT8 Length
|
||||
) : mHeader ((EFI_IFR_OP_HEADER *)StartAddr)
|
||||
{
|
||||
mHeader->OpCode = OpCode;
|
||||
mHeader->Length = (Length == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : Length;
|
||||
mHeader->Scope = (gOpcodeSizesScopeTable[OpCode].mScope + gScopeCount > 0) ? 1 : 0;
|
||||
}
|
||||
|
||||
CIfrOpHeader::CIfrOpHeader (
|
||||
IN CIfrOpHeader &OpHdr
|
||||
)
|
||||
{
|
||||
mHeader = OpHdr.mHeader;
|
||||
}
|
||||
|
||||
UINT32 CIfrForm::FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE] = {0, };
|
||||
2252
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
Normal file
2252
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
Normal file
File diff suppressed because it is too large
Load Diff
3201
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrSyntax.g
Normal file
3201
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrSyntax.g
Normal file
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,341 @@
|
||||
#ifndef _VFRUTILITYLIB_H_
|
||||
#define _VFRUTILITYLIB_H_
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "string.h"
|
||||
#include "EfiTypes.h"
|
||||
#include "EfiVfr.h"
|
||||
#include "VfrError.h"
|
||||
|
||||
#define MAX_NAME_LEN 64
|
||||
#define DEFAULT_ALIGN 1
|
||||
#define DEFAULT_PACK_ALIGN 0xFFFFFFFF
|
||||
#define DEFAULT_NAME_TABLE_ITEMS 1024
|
||||
|
||||
#define EFI_BITS_SHIFT_PER_UINT32 0x5
|
||||
#define EFI_BITS_PER_UINT32 (1 << EFI_BITS_SHIFT_PER_UINT32)
|
||||
|
||||
#define BUFFER_SAFE_FREE(Buf) do { if ((Buf) != NULL) { delete (Buf); } } while (0);
|
||||
|
||||
class CVfrBinaryOutput {
|
||||
public:
|
||||
virtual VOID WriteLine (IN FILE *, IN UINT32, IN INT8 *, IN INT8 *, IN UINT32);
|
||||
virtual VOID WriteEnd (IN FILE *, IN UINT32, IN INT8 *, IN INT8 *, IN UINT32);
|
||||
};
|
||||
|
||||
UINT32
|
||||
_STR2U32 (
|
||||
IN INT8 *Str
|
||||
);
|
||||
|
||||
struct SConfigInfo {
|
||||
UINT16 mOffset;
|
||||
UINT16 mWidth;
|
||||
UINT8 *mValue;
|
||||
SConfigInfo *mNext;
|
||||
|
||||
SConfigInfo (IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
|
||||
~SConfigInfo (VOID);
|
||||
};
|
||||
|
||||
struct SConfigItem {
|
||||
INT8 *mId;
|
||||
INT8 *mInfo;
|
||||
SConfigInfo *mInfoStrList;
|
||||
SConfigItem *mNext;
|
||||
|
||||
public:
|
||||
SConfigItem (IN INT8 *, IN INT8 *);
|
||||
SConfigItem (IN INT8 *, IN INT8 *, IN UINT8, IN UINT16, IN UINT16, IN EFI_IFR_TYPE_VALUE);
|
||||
virtual ~SConfigItem ();
|
||||
};
|
||||
|
||||
class CVfrBufferConfig {
|
||||
private:
|
||||
SConfigItem *mItemListHead;
|
||||
SConfigItem *mItemListTail;
|
||||
SConfigItem *mItemListPos;
|
||||
|
||||
public:
|
||||
CVfrBufferConfig (VOID);
|
||||
virtual ~CVfrBufferConfig (VOID);
|
||||
|
||||
virtual UINT8 Register (IN INT8 *, IN INT8 *Info = NULL);
|
||||
virtual VOID Open (VOID);
|
||||
virtual BOOLEAN Eof(VOID);
|
||||
virtual UINT8 Select (IN INT8 *, IN INT8 *Info = NULL);
|
||||
virtual UINT8 Write (IN CONST CHAR8, IN INT8 *, IN INT8 *, IN UINT8, IN UINT16, IN UINT32, IN EFI_IFR_TYPE_VALUE);
|
||||
#if 0
|
||||
virtual UINT8 Read (OUT INT8 **, OUT INT8 **, OUT INT8 **, OUT INT8 **, OUT INT8 **);
|
||||
#endif
|
||||
virtual VOID Close (VOID);
|
||||
virtual VOID OutputCFile (IN FILE *, IN INT8 *);
|
||||
};
|
||||
|
||||
extern CVfrBufferConfig gCVfrBufferConfig;
|
||||
|
||||
#define ALIGN_STUFF(Size, Align) ((Align) - (Size) % (Align))
|
||||
#define INVALID_ARRAY_INDEX 0xFFFFFFFF
|
||||
|
||||
struct SVfrDataType;
|
||||
|
||||
struct SVfrDataField {
|
||||
INT8 mFieldName[MAX_NAME_LEN];
|
||||
SVfrDataType *mFieldType;
|
||||
UINT32 mOffset;
|
||||
UINT32 mArrayNum;
|
||||
SVfrDataField *mNext;
|
||||
};
|
||||
|
||||
struct SVfrDataType {
|
||||
INT8 mTypeName[MAX_NAME_LEN];
|
||||
UINT8 mType;
|
||||
UINT32 mAlign;
|
||||
UINT32 mTotalSize;
|
||||
SVfrDataField *mMembers;
|
||||
SVfrDataType *mNext;
|
||||
};
|
||||
|
||||
class CVfrVarDataTypeDB {
|
||||
private:
|
||||
SVfrDataType *mDataTypeList;
|
||||
UINT32 mPackAlign;
|
||||
|
||||
SVfrDataType *mNewDataType;
|
||||
SVfrDataType *mCurrDataType;
|
||||
SVfrDataField *mCurrDataField;
|
||||
|
||||
VOID InternalTypesListInit (VOID);
|
||||
VOID RegisterNewType (IN SVfrDataType *);
|
||||
|
||||
EFI_VFR_RETURN_CODE ExtractStructTypeName (IN INT8 *&, OUT INT8 *);
|
||||
EFI_VFR_RETURN_CODE ExtractFieldNameAndArrary (IN INT8 *&, OUT INT8 *, OUT UINT32 &);
|
||||
EFI_VFR_RETURN_CODE GetTypeField (IN INT8 *, IN SVfrDataType *, IN SVfrDataField *&);
|
||||
EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT UINT32 &);
|
||||
UINT8 GetFieldWidth (IN SVfrDataField *);
|
||||
UINT32 GetFieldSize (IN SVfrDataField *, IN UINT32);
|
||||
|
||||
public:
|
||||
CVfrVarDataTypeDB (VOID);
|
||||
~CVfrVarDataTypeDB (VOID);
|
||||
|
||||
EFI_VFR_RETURN_CODE Pack (IN UINT32);
|
||||
VOID UnPack (VOID);
|
||||
|
||||
VOID DeclareDataTypeBegin (VOID);
|
||||
EFI_VFR_RETURN_CODE SetNewTypeName (IN INT8 *);
|
||||
EFI_VFR_RETURN_CODE DataTypeAddField (IN INT8 *, IN INT8 *, IN UINT32);
|
||||
VOID DeclareDataTypeEnd (VOID);
|
||||
|
||||
EFI_VFR_RETURN_CODE GetDataType (IN INT8 *, OUT SVfrDataType **);
|
||||
EFI_VFR_RETURN_CODE GetDataTypeSize (IN INT8 *, OUT UINT32 *);
|
||||
EFI_VFR_RETURN_CODE GetDataFieldInfo (IN INT8 *, OUT UINT16 &, OUT UINT8 &, OUT UINT32 &);
|
||||
|
||||
EFI_VFR_RETURN_CODE GetUserDefinedTypeNameList (OUT INT8 ***, OUT UINT32 *);
|
||||
BOOLEAN IsTypeNameDefined (IN INT8 *);
|
||||
|
||||
#ifdef CVFR_VARDATATYPEDB_DEBUG
|
||||
VOID ParserDB ();
|
||||
#endif
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
EFI_VFR_VARSTORE_INVALID,
|
||||
EFI_VFR_VARSTORE_BUFFER,
|
||||
EFI_VFR_VARSTORE_EFI,
|
||||
EFI_VFR_VARSTORE_NAME
|
||||
} EFI_VFR_VARSTORE_TYPE;
|
||||
|
||||
struct SVfrVarStorageNode {
|
||||
EFI_GUID mGuid;
|
||||
INT8 *mVarStoreName;
|
||||
EFI_VARSTORE_ID mVarStoreId;
|
||||
struct SVfrVarStorageNode *mNext;
|
||||
|
||||
EFI_VFR_VARSTORE_TYPE mVarStoreType;
|
||||
union {
|
||||
// EFI Variable
|
||||
struct {
|
||||
EFI_STRING_ID mEfiVarName;
|
||||
UINT32 mEfiVarSize;
|
||||
} mEfiVar;
|
||||
|
||||
// Buffer Storage
|
||||
SVfrDataType *mDataType;
|
||||
|
||||
// NameValue Storage
|
||||
struct {
|
||||
EFI_STRING_ID *mNameTable;
|
||||
UINT32 mTableSize;
|
||||
} mNameSpace;
|
||||
} mStorageInfo;
|
||||
|
||||
public:
|
||||
SVfrVarStorageNode (IN EFI_GUID *, IN INT8 *, IN EFI_VARSTORE_ID, IN EFI_STRING_ID, IN UINT32);
|
||||
SVfrVarStorageNode (IN EFI_GUID *, IN INT8 *, IN EFI_VARSTORE_ID, IN SVfrDataType *);
|
||||
SVfrVarStorageNode (IN INT8 *, IN EFI_VARSTORE_ID);
|
||||
~SVfrVarStorageNode (VOID);
|
||||
};
|
||||
|
||||
struct EFI_VARSTORE_INFO {
|
||||
EFI_VARSTORE_ID mVarStoreId;
|
||||
union {
|
||||
EFI_STRING_ID mVarName;
|
||||
UINT16 mVarOffset;
|
||||
} mInfo;
|
||||
UINT8 mVarType;
|
||||
UINT32 mVarTotalSize;
|
||||
|
||||
EFI_VARSTORE_INFO (VOID);
|
||||
EFI_VARSTORE_INFO (IN EFI_VARSTORE_INFO &);
|
||||
BOOLEAN operator == (IN EFI_VARSTORE_INFO *);
|
||||
};
|
||||
|
||||
#define EFI_VARSTORE_ID_MAX 0xFFFF
|
||||
#define EFI_FREE_VARSTORE_ID_BITMAP_SIZE ((EFI_VARSTORE_ID_MAX + 1) / EFI_BITS_PER_UINT32)
|
||||
|
||||
class CVfrDataStorage {
|
||||
private:
|
||||
UINT32 mFreeVarStoreIdBitMap[EFI_FREE_VARSTORE_ID_BITMAP_SIZE];
|
||||
|
||||
struct SVfrVarStorageNode *mBufferVarStoreList;
|
||||
struct SVfrVarStorageNode *mEfiVarStoreList;
|
||||
struct SVfrVarStorageNode *mNameVarStoreList;
|
||||
|
||||
struct SVfrVarStorageNode *mCurrVarStorageNode;
|
||||
struct SVfrVarStorageNode *mNewVarStorageNode;
|
||||
|
||||
private:
|
||||
|
||||
EFI_VARSTORE_ID GetFreeVarStoreId (VOID);
|
||||
BOOLEAN ChekVarStoreIdFree (IN EFI_VARSTORE_ID);
|
||||
VOID MarkVarStoreIdUsed (IN EFI_VARSTORE_ID);
|
||||
VOID MarkVarStoreIdUnused (IN EFI_VARSTORE_ID);
|
||||
|
||||
public:
|
||||
CVfrDataStorage ();
|
||||
~CVfrDataStorage ();
|
||||
|
||||
EFI_VFR_RETURN_CODE DeclareNameVarStoreBegin (INT8 *);
|
||||
EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);
|
||||
EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *);
|
||||
|
||||
EFI_VFR_RETURN_CODE DeclareEfiVarStore (IN INT8 *, IN EFI_GUID *, IN EFI_STRING_ID, IN UINT32);
|
||||
|
||||
EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN INT8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN INT8 *, IN EFI_VARSTORE_ID);
|
||||
|
||||
EFI_VFR_RETURN_CODE GetVarStoreId (IN INT8 *, OUT EFI_VARSTORE_ID *);
|
||||
EFI_VFR_RETURN_CODE GetVarStoreType (IN INT8 *, OUT EFI_VFR_VARSTORE_TYPE &);
|
||||
EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT INT8 **);
|
||||
|
||||
EFI_VFR_RETURN_CODE GetBufferVarStoreDataTypeName (IN INT8 *, OUT INT8 **);
|
||||
EFI_VFR_RETURN_CODE GetEfiVarStoreInfo (IN EFI_VARSTORE_INFO *);
|
||||
EFI_VFR_RETURN_CODE GetNameVarStoreInfo (IN EFI_VARSTORE_INFO *, IN UINT32);
|
||||
|
||||
EFI_VFR_RETURN_CODE BufferVarStoreRequestElementAdd (IN INT8 *, IN EFI_VARSTORE_INFO &);
|
||||
};
|
||||
|
||||
#define EFI_QUESTION_ID_MAX 0xFFFF
|
||||
#define EFI_FREE_QUESTION_ID_BITMAP_SIZE ((EFI_QUESTION_ID_MAX + 1) / EFI_BITS_PER_UINT32)
|
||||
#define EFI_QUESTION_ID_INVALID 0x0
|
||||
|
||||
#define DATE_YEAR_BITMASK 0x0000FFFF
|
||||
#define DATE_MONTH_BITMASK 0x00FF0000
|
||||
#define DATE_DAY_BITMASK 0xFF000000
|
||||
#define TIME_HOUR_BITMASK 0x000000FF
|
||||
#define TIME_MINUTE_BITMASK 0x0000FF00
|
||||
#define TIME_SECOND_BITMASK 0x00FF0000
|
||||
|
||||
struct SVfrQuestionNode {
|
||||
INT8 *mName;
|
||||
INT8 *mVarIdStr;
|
||||
EFI_QUESTION_ID mQuestionId;
|
||||
UINT32 mBitMask;
|
||||
SVfrQuestionNode *mNext;
|
||||
|
||||
SVfrQuestionNode (IN INT8 *, IN INT8 *, IN UINT32 BitMask = 0);
|
||||
~SVfrQuestionNode ();
|
||||
};
|
||||
|
||||
class CVfrQuestionDB {
|
||||
private:
|
||||
SVfrQuestionNode *mQuestionList;
|
||||
UINT32 mFreeQIdBitMap[EFI_FREE_QUESTION_ID_BITMAP_SIZE];
|
||||
|
||||
private:
|
||||
EFI_QUESTION_ID GetFreeQuestionId (VOID);
|
||||
BOOLEAN ChekQuestionIdFree (IN EFI_QUESTION_ID);
|
||||
VOID MarkQuestionIdUsed (IN EFI_QUESTION_ID);
|
||||
VOID MarkQuestionIdUnused (IN EFI_QUESTION_ID);
|
||||
|
||||
public:
|
||||
CVfrQuestionDB ();
|
||||
~CVfrQuestionDB();
|
||||
|
||||
EFI_VFR_RETURN_CODE RegisterQuestion (IN INT8 *, IN INT8 *, IN OUT EFI_QUESTION_ID &);
|
||||
VOID RegisterOldDateQuestion (IN INT8 *, IN INT8 *, IN INT8 *, IN OUT EFI_QUESTION_ID &);
|
||||
VOID RegisterNewDateQuestion (IN INT8 *, IN INT8 *, IN OUT EFI_QUESTION_ID &);
|
||||
VOID RegisterOldTimeQuestion (IN INT8 *, IN INT8 *, IN INT8 *, IN OUT EFI_QUESTION_ID &);
|
||||
VOID RegisterNewTimeQuestion (IN INT8 *, IN INT8 *, IN OUT EFI_QUESTION_ID &);
|
||||
EFI_VFR_RETURN_CODE UpdateQuestionId (IN EFI_QUESTION_ID, IN EFI_QUESTION_ID);
|
||||
VOID GetQuestionId (IN INT8 *, IN INT8 *, OUT EFI_QUESTION_ID &, OUT UINT32 &);
|
||||
EFI_VFR_RETURN_CODE FindQuestion (IN EFI_QUESTION_ID);
|
||||
EFI_VFR_RETURN_CODE FindQuestion (IN INT8 *);
|
||||
};
|
||||
|
||||
struct SVfrDefaultStoreNode {
|
||||
EFI_IFR_DEFAULTSTORE *mObjBinAddr;
|
||||
INT8 *mRefName;
|
||||
EFI_STRING_ID mDefaultStoreNameId;
|
||||
UINT16 mDefaultId;
|
||||
|
||||
SVfrDefaultStoreNode *mNext;
|
||||
|
||||
SVfrDefaultStoreNode (IN EFI_IFR_DEFAULTSTORE *, IN INT8 *, IN EFI_STRING_ID, IN UINT16);
|
||||
~SVfrDefaultStoreNode();
|
||||
};
|
||||
|
||||
class CVfrDefaultStore {
|
||||
private:
|
||||
SVfrDefaultStoreNode *mDefaultStoreList;
|
||||
|
||||
public:
|
||||
CVfrDefaultStore ();
|
||||
~CVfrDefaultStore ();
|
||||
|
||||
EFI_VFR_RETURN_CODE RegisterDefaultStore (IN CHAR8 *, IN INT8 *, IN EFI_STRING_ID, IN UINT16);
|
||||
EFI_VFR_RETURN_CODE ReRegisterDefaultStoreById (IN UINT16, IN INT8 *, IN EFI_STRING_ID);
|
||||
BOOLEAN DefaultIdRegistered (IN UINT16);
|
||||
EFI_VFR_RETURN_CODE GetDefaultId (IN INT8 *, OUT UINT16 *);
|
||||
EFI_VFR_RETURN_CODE BufferVarStoreAltConfigAdd (IN EFI_VARSTORE_ID, IN EFI_VARSTORE_INFO &, IN INT8 *, IN UINT8, IN EFI_IFR_TYPE_VALUE);
|
||||
};
|
||||
|
||||
#define EFI_RULE_ID_START 0x01
|
||||
#define EFI_RULE_ID_INVALID 0x00
|
||||
|
||||
struct SVfrRuleNode {
|
||||
UINT8 mRuleId;
|
||||
INT8 *mRuleName;
|
||||
SVfrRuleNode *mNext;
|
||||
|
||||
SVfrRuleNode(IN INT8 *, IN UINT8);
|
||||
~SVfrRuleNode();
|
||||
};
|
||||
|
||||
class CVfrRulesDB {
|
||||
private:
|
||||
SVfrRuleNode *mRuleList;
|
||||
UINT8 mFreeRuleId;
|
||||
|
||||
public:
|
||||
CVfrRulesDB ();
|
||||
~CVfrRulesDB();
|
||||
|
||||
VOID RegisterRule (IN INT8 *);
|
||||
UINT8 GetRuleId (IN INT8 *);
|
||||
};
|
||||
|
||||
#define MIN(v1, v2) (((v1) < (v2)) ? (v1) : (v2))
|
||||
#define MAX(v1, v2) (((v1) > (v2)) ? (v1) : (v2))
|
||||
|
||||
#endif
|
||||
149
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/makefile
Normal file
149
EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/makefile
Normal file
@@ -0,0 +1,149 @@
|
||||
#/*++
|
||||
#
|
||||
# Copyright (c) 2004 - 2007, 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:
|
||||
#
|
||||
# makefile
|
||||
#
|
||||
# Abstract:
|
||||
#
|
||||
# Makefile for building the EFI VFR compiler
|
||||
#
|
||||
#--*/
|
||||
|
||||
|
||||
!IFNDEF EDK_SOURCE
|
||||
!ERROR EDK_SOURCE environmental variable not set
|
||||
!ENDIF
|
||||
|
||||
!IFNDEF TOOLCHAIN
|
||||
TOOLCHAIN = TOOLCHAIN_MSVC
|
||||
!ENDIF
|
||||
|
||||
!INCLUDE $(BUILD_DIR)\PlatformTools.env
|
||||
|
||||
.SUFFIXES :
|
||||
|
||||
TARGET_NAME = VfrCompile
|
||||
|
||||
ETO = $(EDK_TOOLS_OUTPUT)
|
||||
SRC = $(EDK_TOOLS_SOURCE)\Uefi$(TARGET_NAME)
|
||||
TARGET_EXE = $(ETO)\$(TARGET_NAME).exe
|
||||
|
||||
|
||||
|
||||
INC = -I $(SRC) \
|
||||
-I $(EDK_SOURCE)\Foundation\Include\Ia32 \
|
||||
-I $(EDK_SOURCE)\Foundation\Efi\Include \
|
||||
-I $(EDK_SOURCE)\Foundation\Framework\Include \
|
||||
-I $(EDK_SOURCE)\Foundation\Include\IndustryStandard \
|
||||
-I $(EDK_SOURCE)\Foundation\ \
|
||||
-I $(EDK_SOURCE)\Foundation\Core\Dxe \
|
||||
-I $(EDK_SOURCE)\Foundation\Efi \
|
||||
-I $(EDK_SOURCE)\Foundation\Framework \
|
||||
-I $(EDK_TOOLS_SOURCE)\Common \
|
||||
-I $(EDK_SOURCE)\Foundation\Include
|
||||
|
||||
ANTLR_FLAGS = -CC -e3 -ck 3 -k 2
|
||||
DLG_FLAGS = -C2 -i -CC
|
||||
LINK_FLAGS_PCCTS = /DEBUG /PDB:$*.pdb
|
||||
C_FLAGS_PCCTS = -I. -I$(ANTLR_H) /WX /Od /EHsc /Zi /Fd$(ETO)\$(TARGET_NAME)Obj /D _CRT_SECURE_NO_DEPRECATE $(VERSION_FLAGS) /D PCCTS_USE_NAMESPACE_STD #/D CVFR_VARDATATYPEDB_DEBUG /D CIFROBJ_DEUBG /D VFREXP_DEBUG
|
||||
|
||||
VFR_GRAMMER_FILE = $(SRC)\VfrSyntax.g
|
||||
|
||||
VFR_ANTLR_SPAWN = $(ETO)\VfrSyntax.cpp \
|
||||
$(ETO)\EfiVfrParser.cpp \
|
||||
$(ETO)\EfiVfrParser.h \
|
||||
$(ETO)\VfrParser.dlg \
|
||||
$(ETO)\VfrTokens.h
|
||||
|
||||
VFR_DLG_SPAWN = $(ETO)\VfrLexer.cpp \
|
||||
$(ETO)\VfrLexer.h
|
||||
|
||||
ANTLR_H = $(PCCTS_DIR)\h
|
||||
|
||||
HEADER_FILES = $(SRC)\VfrFormPkg.h \
|
||||
$(SRC)\EfiVfr.h \
|
||||
$(SRC)\VfrCompiler.h \
|
||||
$(SRC)\VfrError.h \
|
||||
$(SRC)\VfrUtilityLib.h
|
||||
|
||||
OBJECTS = $(ETO)\AParser.obj \
|
||||
$(ETO)\DLexerBase.obj \
|
||||
$(ETO)\ATokenBuffer.obj \
|
||||
$(ETO)\VfrSyntax.obj \
|
||||
$(ETO)\EfiVfrParser.obj \
|
||||
$(ETO)\VfrLexer.obj \
|
||||
$(ETO)\VfrFormPkg.obj \
|
||||
$(ETO)\VfrError.obj \
|
||||
$(ETO)\VfrUtilityLib.obj \
|
||||
$(ETO)\VfrCompiler.obj
|
||||
|
||||
all : $(TARGET_EXE)
|
||||
|
||||
$(VFR_ANTLR_SPAWN) : $(VFR_GRAMMER_FILE)
|
||||
$(ANTLR) $(ANTLR_FLAGS) -fl VfrParser.dlg -ft VfrTokens.h -o $(ETO) $(VFR_GRAMMER_FILE)
|
||||
|
||||
$(VFR_DLG_SPAWN) : $(ETO)\VfrParser.dlg
|
||||
$(DLG) $(DLG_FLAGS) -cl VfrLexer -o $(ETO) $(ETO)\VfrParser.dlg
|
||||
|
||||
$(ETO)\VfrSyntax.obj : $(ETO)\VfrSyntax.cpp $(VFR_DLG_SPAWN)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(INC) $(ETO)\VfrSyntax.cpp
|
||||
|
||||
$(ETO)\EfiVfrParser.obj : $(ETO)\EfiVfrParser.cpp $(ETO)\EfiVfrParser.h $(VFR_DLG_SPAWN)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(INC) $(ETO)\EfiVfrParser.cpp
|
||||
|
||||
|
||||
$(ETO)\AParser.obj : $(ANTLR_H)\AParser.cpp
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(ANTLR_H)\AParser.cpp
|
||||
|
||||
$(ETO)\ATokenBuffer.obj : $(ANTLR_H)\ATokenBuffer.cpp
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(ANTLR_H)\ATokenBuffer.cpp
|
||||
|
||||
$(ETO)\DLexerBase.obj : $(ANTLR_H)\DLexerBase.cpp
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(ANTLR_H)\DLexerBase.cpp
|
||||
|
||||
$(ETO)\VfrLexer.obj : $(ETO)\VfrLexer.cpp $(VFR_DLG_SPAWN)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) /Fo$@ $(INC) $(ETO)\VfrLexer.cpp
|
||||
|
||||
$(ETO)\VfrFormPkg.obj : $(SRC)\VfrFormPkg.cpp $(HEADER_FILES)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) $(INC) /Fo$@ $(SRC)\VfrFormPkg.cpp
|
||||
|
||||
$(ETO)\VfrError.obj : $(SRC)\VfrError.cpp $(HEADER_FILES)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) $(INC) /Fo$@ $(SRC)\VfrError.cpp
|
||||
|
||||
$(ETO)\VfrUtilityLib.obj : $(SRC)\VfrUtilityLib.cpp $(HEADER_FILES)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) $(INC) /Fo$@ $(SRC)\VfrUtilityLib.cpp
|
||||
|
||||
$(ETO)\VfrCompiler.obj : $(SRC)\VfrCompiler.cpp $(HEADER_FILES)
|
||||
$(CC) -c $(C_FLAGS_PCCTS) $(INC) /Fo$@ $(SRC)\VfrCompiler.cpp
|
||||
|
||||
#
|
||||
# Add Binary Build description for this tools.
|
||||
#
|
||||
|
||||
!IF (("$(EFI_BINARY_TOOLS)" == "YES") && EXIST($(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).exe))
|
||||
$(TARGET_EXE): $(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).exe
|
||||
copy $(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).exe $(TARGET_EXE) /Y
|
||||
if exist $(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).pdb \
|
||||
copy $(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).pdb $(EDK_TOOLS_OUTPUT)\$(TARGET_NAME).pdb /Y
|
||||
!ELSE
|
||||
$(TARGET_EXE) : $(OBJECTS) $(HEADER_FILES)
|
||||
$(LINK) $(MSVS_LINK_LIBPATHS) $(LINK_FLAGS_PCCTS) /OUT:$(TARGET_EXE) $(OBJECTS)
|
||||
!IF ("$(EFI_BINARY_BUILD)" == "YES")
|
||||
if not exist $(EFI_PLATFORM_BIN)\Tools mkdir $(EFI_PLATFORM_BIN)\Tools
|
||||
if exist $(TARGET_EXE) copy $(TARGET_EXE) $(EFI_PLATFORM_BIN)\tools\$(TARGET_NAME).exe /Y
|
||||
if exist $(EDK_TOOLS_OUTPUT)\$(TARGET_NAME).pdb \
|
||||
copy $(EDK_TOOLS_OUTPUT)\$(TARGET_NAME).pdb $(EFI_PLATFORM_BIN)\Tools\$(TARGET_NAME).pdb /Y
|
||||
!ENDIF
|
||||
!ENDIF
|
||||
|
||||
clean:
|
||||
Reference in New Issue
Block a user