EFI_STATUS
SpecShellModeCheckFun (
IN CHAR16 *Value,
IN BOOLEAN Delete,
IN BOOLEAN Volatile
)
{
UINTN Index;
if (Delete || !Volatile) {
PrintToken (STRING_TOKEN (STR_SHELLENV_VAR_RESERVED), HiiEnvHandle, L"set", L"efishellmode");
return EFI_INVALID_PARAMETER;
}
for (Index = 0; mShellMode[Index] != NULL; Index++) {
if (StrCmp (mShellMode[Index], Value) == 0) {
return EFI_SUCCESS;
}
}
PrintToken (STRING_TOKEN (STR_SHELLENV_VAR_MODE_OPTIONS), HiiEnvHandle);
for (Index = 0; mShellMode[Index] != NULL; Index++) {
Print (mShellMode[Index]);
Print (L"\n");
}
return EFI_INVALID_PARAMETER;
}
VOID
EFIAPI
SEnvTextOut (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_SIMPLE_TEXT_OUT_PROTOCOL *Dev;
INTN Index;
UINTN Col;
UINTN Row;
EFI_STATUS Status;
Dev = Interface;
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_ATTRIB_X),
HiiEnvHandle,
Dev->Mode->Attribute
);
//
// Dump TextOut Info
//
for (Index = 0; Index < Dev->Mode->MaxMode; Index++) {
Status = Dev->QueryMode (Dev, Index, &Col, &Row);
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_MODE),
HiiEnvHandle,
Index == Dev->Mode->Mode ? '*' : ' ',
Index
);
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_ERROR), HiiEnvHandle, Status);
} else {
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_COL_ROW), HiiEnvHandle, Col, Row);
}
}
}
VOID
EFIAPI
SEnvUsbIo (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_USB_IO_PROTOCOL *UsbIo;
EFI_USB_INTERFACE_DESCRIPTOR InterfaceDesc;
UsbIo = Interface;
UsbIo->UsbGetInterfaceDescriptor (UsbIo, &InterfaceDesc);
//
// Dump UsbIo Info
//
Print (L"\n");
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_NUMBER),
HiiEnvHandle,
InterfaceDesc.InterfaceNumber
);
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_CLASS),
HiiEnvHandle,
InterfaceDesc.InterfaceClass
);
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_SUBCLASS),
HiiEnvHandle,
InterfaceDesc.InterfaceSubClass
);
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_INTERFACE_PROTOCOL),
HiiEnvHandle,
InterfaceDesc.InterfaceProtocol
);
}
VOID
SEnvPrintDevicePathEntry (
IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,
IN BOOLEAN Verbose
)
/*++
Routine Description:
Arguments:
DevicePath - The device path
Verbose - Verbose
Returns:
--*/
{
UINT8 Type;
UINT8 SubType;
INTN Index;
//
// Process print device path entry
//
Type = (UINT8) DevicePathType (DevicePath);
SubType = DevicePathSubType (DevicePath);
for (Index = 0; SEnvDP_Strings[Index].Type != END_DEVICE_PATH_TYPE; Index++) {
if (Type == SEnvDP_Strings[Index].Type) {
if (SubType > SEnvDP_Strings[Index].MaxSubType) {
SubType = 0;
}
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_PATH_FOR),
HiiEnvHandle,
SEnvDP_Strings[Index].TypeString,
SEnvDP_Strings[Index].SubTypeStr[SubType]
);
if (Verbose) {
if (SEnvDP_Strings[Index].Function != NULL) {
SEnvDP_Strings[Index].Function (DevicePath);
}
}
return ;
}
}
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_DEVICE_PATH_ERROR), HiiEnvHandle);
}
STATIC
VOID
PrintHelpInfo (
VOID
)
/*++
Routine Description:
Print out help information.
Arguments:
None.
Returns:
None.
--*/
{
PrintToken (STRING_TOKEN (STR_FWUPDATE_FIRMWARE_VOL_UPDATE), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_VERSION), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_COPYRIGHT), HiiHandle);
Print (L"\n");
PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_1), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_2), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_3), HiiHandle);
PrintToken (STRING_TOKEN (STR_FWUPDATE_USAGE_4), HiiHandle);
Print (L"\n");
}
EFI_STATUS
LibSmbiosInit (
VOID
)
/*++
Routine Description:
Init the SMBIOS VIEW API's environment.
Arguments:
None
Returns:
EFI_SUCCESS - Successful to init the SMBIOS VIEW Lib
Others - Cannot get SMBIOS Table
--*/
{
EFI_STATUS Status;
//
// Init only once
//
if (mInit == 1) {
return EFI_SUCCESS;
}
//
// Get SMBIOS table from System Configure table
//
Status = LibGetSystemConfigurationTable (&gEfiSmbiosTableGuid, &mSmbiosTable);
if (mSmbiosTable == NULL) {
PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_LIBSMBIOSVIEW_CANNOT_GET_TABLE), HiiHandle);
return EFI_NOT_FOUND;
}
if (EFI_ERROR (Status)) {
PrintToken (STRING_TOKEN (STR_SMBIOSVIEW_LIBSMBIOSVIEW_GET_TABLE_ERROR), HiiHandle, Status);
return Status;
}
//
// Init SMBIOS structure table address
//
mSmbiosStruct->Raw = (UINT8 *) (UINTN) (mSmbiosTable->TableAddress);
mInit = 1;
return EFI_SUCCESS;
}
std::string PrintTokens( const TokenSet& setTokens )
{
std::string strTokens( " " );
for ( TokenSet::const_iterator i = setTokens.begin() ; i != setTokens.end() ; i++ )
strTokens += PrintToken( *i, true ) + " ";
return strTokens;
}
void
PrintIdentifier(const CodeSource &src, const IdentifierNode *node, Printer pr,
int tabDepth)
{
pr("ID:");
PrintToken(src, node->token(), pr);
}
VOID
SEnvPrintLabelNotFound (
VOID
)
/*++
Routine Description:
Print an error message when a label referenced by a GOTO is not
found in the script file..
Arguments:
Returns:
--*/
{
PrintToken (
STRING_TOKEN (STR_SHELLENV_GOTO_TARGET_LABEL),
HiiEnvHandle,
TargetLabel,
SEnvGetLineNumber ()
);
return ;
}
void
PrintStringLiteral(const CodeSource &src, const StringLiteralNode *node,
Printer pr, int tabDepth)
{
pr("STR:");
PrintToken(src, node->value(), pr);
}
static int ListenUsingGCD(size_t noteCount, const char **noteNames)
{
int retVal;
uint32_t noteErr;
size_t noteIndex;
int noteTokens[noteCount];
const int * noteTokensPtr;
// We need to capture the base of the noteTokens array, but the compiler won't let us do that
// because it's of variable size. In our specific case this isn't a problem because, if things
// go well, we never leave this routine but rather block forever in dispatch_main(). In a real
// program you'd have to be a bit more careful (but then again, in a real program you wouldn't be
// registering for an unbounded number of arbitrary notifications :-).
noteTokensPtr = ¬eTokens[0];
noteErr = NOTIFY_STATUS_OK;
for (noteIndex = 0; noteIndex < noteCount; noteIndex++) {
noteErr = notify_register_dispatch(noteNames[noteIndex], ¬eTokens[noteIndex], dispatch_get_main_queue(), ^(int token) {
PrintToken(
token,
noteCount,
noteTokensPtr,
noteNames
);
});
if (noteErr != NOTIFY_STATUS_OK) {
break;
}
}
void
PrintNumericLiteral(const CodeSource &src, const NumericLiteralNode *node,
Printer pr, int tabDepth)
{
pr("NUM:");
PrintToken(src, node->value(), pr);
}
void
PrintRegularExpressionLiteral(const CodeSource &src,
const RegularExpressionLiteralNode *node,
Printer pr, int tabDepth)
{
pr("RE:");
PrintToken(src, node->value(), pr);
}
void
PrintGetPropertyExpression(const CodeSource &src,
const GetPropertyExpressionNode *node,
Printer pr, int tabDepth)
{
PrintNode(src, node->object(), pr, tabDepth);
pr(".");
PrintToken(src, node->property(), pr);
}
static int ListenUsingMach(size_t noteCount, const char **noteNames)
// Implements the "listenMach" command. Register for the noteCount
// notifications whose names are in the noteNames array. Then read
// the notification Mach port, printing information about any
// notifications that arrive.
{
int retVal;
uint32_t noteErr;
size_t noteIndex;
int noteTokens[noteCount];
mach_port_t port = MACH_PORT_NULL;
// Register. The first time around this loop fd == -1 and so we don't
// specify NOTIFY_REUSE. notify_register_mach_port then allocates
// a Mach port and returns it in port. For subsequent iterations
// we /do/ specify NOTIFY_REUSE and notify_register_mach_port just
// reuses the existing port.
noteErr = NOTIFY_STATUS_OK;
for (noteIndex = 0; noteIndex < noteCount; noteIndex++) {
noteErr = notify_register_mach_port(
noteNames[noteIndex],
&port,
(port == MACH_PORT_NULL) ? 0 : NOTIFY_REUSE,
¬eTokens[noteIndex]
);
if (noteErr != NOTIFY_STATUS_OK) {
break;
}
}
if (noteErr != NOTIFY_STATUS_OK) {
PrintNotifyError("registration failed", noteNames[noteIndex], noteErr);
retVal = EXIT_FAILURE;
} else {
kern_return_t kr;
mach_msg_empty_rcv_t msg;
// Listen for and print any incoming notifications.
fprintf(stdout, "Listening using Mach:\n");
fflush(stdout);
do {
msg.header.msgh_local_port = port;
msg.header.msgh_size = sizeof(msg);
kr = mach_msg_receive(&msg.header);
if (kr == KERN_SUCCESS) {
PrintToken(msg.header.msgh_id, noteCount, noteTokens, noteNames);
}
} while (kr == KERN_SUCCESS);
fprintf(stderr, "error reading Mach message: %s (0x%x)\n", mach_error_string(kr), kr);
retVal = EXIT_FAILURE;
}
return retVal;
}
void
PrintLabelledStatement(const CodeSource &src,
const LabelledStatementNode *node,
Printer pr, int tabDepth)
{
PrintToken(src, node->label(), pr);
pr(":\n");
PrintTabDepth(tabDepth, pr);
PrintNode(src, node->statement(), pr, tabDepth);
}
/**
Gather and print cumulative data.
Traverse the measurement records and:<BR>
For each record with a Token listed in the CumData array:<BR>
- Update the instance count and the total, minimum, and maximum durations.
Finally, print the gathered cumulative statistics.
**/
VOID
ProcessCumulative(
VOID
)
{
UINT64 AvgDur; // the computed average duration
UINT64 Dur;
UINT64 MinDur;
UINT64 MaxDur;
EFI_STRING StringPtr;
UINTN TIndex;
EFI_STRING StringPtrUnknown;
StringPtrUnknown = HiiGetString (gHiiHandle, STRING_TOKEN (STR_ALIT_UNKNOWN), NULL);
StringPtr = HiiGetString (gHiiHandle, STRING_TOKEN (STR_DP_SECTION_CUMULATIVE), NULL);
PrintToken( STRING_TOKEN (STR_DP_SECTION_HEADER),
(StringPtr == NULL) ? StringPtrUnknown: StringPtr);
FreePool (StringPtr);
FreePool (StringPtrUnknown);
PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_1));
PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_SECT_2));
PrintToken (STRING_TOKEN (STR_DP_DASHES));
for ( TIndex = 0; TIndex < NumCum; ++TIndex) {
if (CumData[TIndex].Count != 0) {
AvgDur = DivU64x32 (CumData[TIndex].Duration, CumData[TIndex].Count);
AvgDur = DurationInMicroSeconds(AvgDur);
Dur = DurationInMicroSeconds(CumData[TIndex].Duration);
MaxDur = DurationInMicroSeconds(CumData[TIndex].MaxDur);
MinDur = DurationInMicroSeconds(CumData[TIndex].MinDur);
PrintToken (STRING_TOKEN (STR_DP_CUMULATIVE_STATS),
CumData[TIndex].Name,
CumData[TIndex].Count,
Dur,
AvgDur,
MinDur,
MaxDur
);
}
}
}
/* El main solo define las variables necesarias para la funcion
* PrintToken, crea el archivo de errores y por medio del loop
* se toma cada token y su salida es por el stdout si no hay errores
* o por stderr si los hay.
*/
int main()
{
TokenType token;
OpenErrorFile();
while ((token = (TokenType)yylex()) != 0)
PrintToken(token, yytext, yylval);
CloseErrorFile();
return 0;
}
void
PrintBreakStatement(const CodeSource &src, const BreakStatementNode *node,
Printer pr, int tabDepth)
{
pr("break");
if (node->label()) {
pr(" ");
PrintToken(src, *node->label(), pr);
}
pr(";\n");
}
void
PrintFunctionExpression(const CodeSource &src,
const FunctionExpressionNode *node,
Printer pr, int tabDepth)
{
pr("function ");
if (node->name())
PrintToken(src, *node->name(), pr);
pr("(");
bool first = true;
for (auto arg : node->formalParameters()) {
if (!first)
pr(",");
PrintToken(src, arg, pr);
first = false;
}
pr(") {\n");
PrintSourceElementList(src, node->functionBody(), pr, tabDepth+1);
PrintTabDepth(tabDepth, pr);
pr("}");
}
void
PrintForInVarStatement(const CodeSource &src,
const ForInVarStatementNode *node,
Printer pr, int tabDepth)
{
pr("for (var ");
PrintToken(src, node->name(), pr);
pr(" in ");
PrintNode(src, node->object(), pr, tabDepth);
pr(")\n");
PrintTabDepth(tabDepth+1, pr);
PrintNode(src, node->body(), pr, tabDepth+1);
}
void
PrintObjectSlotName(const CodeSource &src,
const ObjectLiteralNode::PropertyDefinition *defn,
Printer pr)
{
if (defn->hasIdentifierName())
pr("ID:");
else if (defn->hasStringName())
pr("STR:");
else if (defn->hasNumericName())
pr("NUM:");
PrintToken(src, defn->name(), pr);
}
void
PrintTryCatchStatement(const CodeSource &src,
const TryCatchStatementNode *node,
Printer pr, int tabDepth)
{
pr("try ");
PrintBlock(src, node->tryBlock(), pr, tabDepth + 1);
PrintTabDepth(tabDepth, pr);
pr("catch (");
PrintToken(src, node->catchName(), pr);
pr(") ");
PrintBlock(src, node->catchBlock(), pr, tabDepth + 1);
}
void DwRfc1521Tokenizer::ParseToken()
{
// Assume the field body has already been extracted. That is, we don't
// have to watch for the end of the field body or folding. We just
// treat any CRs or LFs as white space.
mTokenStart = mNextStart;
mTokenLength = 0;
mTkType = eTkNull;
if (mTokenStart >= mString.length()) {
return;
}
// Skip leading space. Also, since control chars are not permitted
// in atoms, skip these, too.
while (1) {
if (mTokenStart >= mString.length()) {
return;
}
if (!isspace(mString[mTokenStart]) && !iscntrl(mString[mTokenStart]))
break;
++mTokenStart;
}
char ch = mString[mTokenStart];
// Quoted string
if (ch == '"') {
mTkType = eTkQuotedString;
ParseQuotedString();
}
// Comment
else if (ch == '(') {
mTkType = eTkComment;
ParseComment();
}
// Domain literal
else if (ch == '[') {
mTkType = eTkDomainLiteral;
ParseDomainLiteral();
}
// Special
else if (istspecial(ch)) {
mTkType = eTkTspecial;
mTokenLength = 1;
mToken = mString.substr(mTokenStart, 1);
mNextStart = mTokenStart + 1;
}
// Atom
else {
mTkType = eTkToken;
ParseAtom();
}
if (mDebugOut) PrintToken(mDebugOut);
}
VOID
EFIAPI
SEnvImageTok (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_LOADED_IMAGE_PROTOCOL *Image;
CHAR16 *ImageName;
CHAR16 *Tok;
Image = Interface;
ImageName = LibGetImageName (Image);
if (ImageName != NULL) {
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE_2), HiiEnvHandle);
Print (ImageName);
Print (L") ");
FreePool (ImageName);
} else {
Tok = LibDevicePathToStr (Image->FilePath);
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE), HiiEnvHandle, Tok);
FreePool (Tok);
}
}
void
PrintDeclarationList(const CodeSource &src, const DeclarationList &decls,
Printer pr, int tabDepth)
{
bool first = true;
for (auto decl : decls) {
if (!first)
pr(", ");
PrintToken(src, decl.name(), pr);
if (decl.initialiser()) {
pr(" = ");
PrintNode(src, decl.initialiser(), pr, tabDepth);
}
};
}
VOID
EFIAPI
SEnvBusSpecificDriverOverride (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_STATUS Status;
EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL *BusSpecificDriverOverride;
EFI_HANDLE ImageHandle;
EFI_LOADED_IMAGE_PROTOCOL *Image;
Print (L"\n");
BusSpecificDriverOverride = Interface;
do {
Status = BusSpecificDriverOverride->GetDriver (
BusSpecificDriverOverride,
&ImageHandle
);
if (!EFI_ERROR (Status)) {
Status = BS->HandleProtocol (
ImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **) &Image
);
if (!EFI_ERROR (Status)) {
PrintToken (
STRING_TOKEN (STR_SHELLENV_DPROT_DRV_FILE),
HiiEnvHandle,
SEnvHandleToNumber (ImageHandle),
LibDevicePathToStr (Image->FilePath)
);
}
}
} while (!EFI_ERROR (Status));
}
VOID
EFIAPI
SEnvDriverEFIVersionTok (
IN EFI_HANDLE h,
IN VOID *Interface
)
{
EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *DriverEfiVersion;
DriverEfiVersion = (EFI_DRIVER_SUPPORTED_EFI_VERSION_PROTOCOL *) Interface;
PrintToken (
STRING_TOKEN (STR_SHELLENV_PROTID_DRV_EFI_VER_TOK),
HiiEnvHandle,
DriverEfiVersion->FirmwareVersion
);
}
VOID
EFIAPI
SEnvImageDPathTok (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
CHAR16 *Str;
CHAR16 *Disp;
UINTN Len;
DevicePath = Interface;
Str = LibDevicePathToStr (DevicePath);
Disp = L"";
//
// Print device path token
//
if (Str) {
Len = StrLen (Str);
Disp = Str;
if (Len > 30) {
Disp = Str + Len - 30;
Disp[0] = '.';
Disp[1] = '.';
}
}
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_IMAGE_DEVPATH), HiiEnvHandle, Disp);
if (Str) {
FreePool (Str);
}
}
VOID
EFIAPI
SEnvDebugSupport (
IN EFI_HANDLE h,
IN VOID *Interface
)
/*++
Routine Description:
Arguments:
h - An EFI handle
Interface - The interface
Returns:
--*/
{
EFI_DEBUG_SUPPORT_PROTOCOL *DebugSupport;
DebugSupport = Interface;
//
// Dump Debug support info
//
Print (L"\n");
Print (L"Isa = ");
switch (DebugSupport->Isa) {
case (IsaIa32):
Print (L"IA-32");
break;
case (IsaIpf):
Print (L"IPF");
break;
case (IsaEbc):
Print (L"EBC");
break;
default:
PrintToken (STRING_TOKEN (STR_SHELLENV_DPROT_UNKNOWN), HiiEnvHandle, DebugSupport->Isa);
break;
}
}
