Changeset 58459 for trunk/src/VBox/Devices/EFI/Firmware/ShellPkg – Oracle VirtualBox

trunk/src/VBox/Devices/EFI/Firmware

Property svn:mergeinfo set to (toggle deleted branches)
/vendor/edk2/current 103735-103757

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ConsoleLogger.c

-              r48674
+              r58459
   Provides interface to shell console logger.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 **/
-#include "ConsoleLogger.h"
 #include "Shell.h"
-STATIC CONST CHAR16                     mCrLfString[3] = { CHAR_CARRIAGE_RETURN, CHAR_LINEFEED, CHAR_NULL };
 /**
 …
             ; Index++
            ){
           *(ConsoleInfo->Attributes + (CopySize/sizeof(ConsoleInfo->Attributes)) + Index) = ConsoleInfo->HistoryMode.Attribute;
+          *(ConsoleInfo->Attributes + (CopySize/sizeof(ConsoleInfo->Attributes[0])) + Index) = ConsoleInfo->HistoryMode.Attribute;
+        }
 …
     FreePool(Resp);
     ShellInfoObject.ConsoleInfo->Enabled = FALSE;
+    //
+    // When user wants to quit, the shell should stop running the command.
+    //
+    gBS->SignalEvent (ShellInfoObject.NewEfiShellProtocol->ExecutionBreak);
     return (EFI_DEVICE_ERROR);
   } else {
 …
+  )
+{
+  EFI_INPUT_KEY               Key;
+  UINTN                       EventIndex;
+  CONSOLE_LOGGER_PRIVATE_DATA *ConsoleInfo;
+  EFI_STATUS                        Status;
+  EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL *TxtInEx;
+  EFI_KEY_DATA                      KeyData;
+  UINTN                             EventIndex;
+  CONSOLE_LOGGER_PRIVATE_DATA       *ConsoleInfo;
   ConsoleInfo = CONSOLE_LOGGER_PRIVATE_DATA_FROM_THIS(This);
   if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut) {
 …
+  }
   ASSERT(ShellInfoObject.ConsoleInfo == ConsoleInfo);
+  if (ShellInfoObject.HaltOutput) {
+    //
+    // just get some key
+    //
+    gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
+    gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+    ShellInfoObject.HaltOutput = FALSE;
+  }
+  Status = gBS->HandleProtocol (gST->ConsoleInHandle, &gEfiSimpleTextInputExProtocolGuid, (VOID **) &TxtInEx);
+  if (!EFI_ERROR (Status)) {
+    while (ShellInfoObject.HaltOutput) {
+      ShellInfoObject.HaltOutput = FALSE;
+      //
+      // just get some key
+      //
+      Status = gBS->WaitForEvent (1, &TxtInEx->WaitForKeyEx, &EventIndex);
+      ASSERT_EFI_ERROR (Status);
+      Status = TxtInEx->ReadKeyStrokeEx (TxtInEx, &KeyData);
+      if (EFI_ERROR(Status)) {
+        break;
+      }
+      if ((KeyData.Key.UnicodeChar == L's') && (KeyData.Key.ScanCode == SCAN_NULL) &&
+          ((KeyData.KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID | EFI_LEFT_CONTROL_PRESSED)) ||
+           (KeyData.KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID | EFI_RIGHT_CONTROL_PRESSED))
+          )
+         ) {
+        ShellInfoObject.HaltOutput = TRUE;
+      }
+    }
+  }
   if (!ShellInfoObject.ConsoleInfo->Enabled) {
     return (EFI_DEVICE_ERROR);
 …
   //
   if (!EFI_ERROR (Status)) {
     Screen = &ConsoleInfo->Buffer[(ConsoleInfo->ColsPerScreen + 1) * ConsoleInfo->CurrentStartRow];
+    Screen = &ConsoleInfo->Buffer[(ConsoleInfo->ColsPerScreen + 2) * ConsoleInfo->CurrentStartRow];
     Attributes = &ConsoleInfo->Attributes[ConsoleInfo->ColsPerScreen * ConsoleInfo->CurrentStartRow];
     for ( Row = ConsoleInfo->OriginalStartRow
 …
       // Skip the NULL on each column end in text buffer only
       //
       Screen++;
+      Screen += 2;
+    }
     ConsoleInfo->HistoryMode.CursorColumn = 0;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ConsoleLogger.h

-              r48674
+              r58459
 #define _CONSOLE_LOGGER_HEADER_
+#include <Uefi.h>
+#include <Protocol/SimpleTextOut.h>
+#include <Protocol/EfiShell.h>
+#include <Protocol/EfiShellParameters.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/HiiLib.h>
+#include <Library/ShellLib.h>
+#include "Shell.h"
 #define CONSOLE_LOGGER_PRIVATE_DATA_SIGNATURE  SIGNATURE_32 ('c', 'o', 'P', 'D')

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ConsoleWrappers.c

-              r48674
+              r58459
   Function definitions for shell simple text in and out on top of file handles.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 **/
-#include <Uefi.h>
-#include <ShellBase.h>
-#include "ConsoleWrappers.h"
 #include "Shell.h"
 …
   SHELL_FILE_HANDLE               FileHandle;
   EFI_HANDLE                      TheHandle;
+  UINT64                          RemainingBytesOfInputFile;
 } SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL;
 …
   SHELL_FILE_HANDLE               FileHandle;
   EFI_HANDLE                      TheHandle;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *OriginalSimpleTextOut;
 } SHELL_EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL;
 …
+  )
+{
+  UINT64 Position;
+  UINT64 Size;
+  //
+  // Someone is waiting on the keystroke event, if there's
+  // a key pending, signal the event
+  //
+  // Context is the pointer to EFI_SIMPLE_TEXT_INPUT_PROTOCOL
+  //
+  ShellInfoObject.NewEfiShellProtocol->GetFilePosition(((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)Context)->FileHandle, &Position);
+  ShellInfoObject.NewEfiShellProtocol->GetFileSize    (((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)Context)->FileHandle, &Size    );
+  if (Position < Size) {
+    gBS->SignalEvent (Event);
+  }
+  gBS->SignalEvent (Event);
+}
 …
+{
   UINTN Size;
+  Size = sizeof(CHAR16);
+  //
+  // Verify the parameters
+  //
   if (Key == NULL || This == NULL) {
     return (EFI_INVALID_PARAMETER);
+  }
+  //
+  // Check if we have any characters left in the stream.
+  //
+  if (((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)This)->RemainingBytesOfInputFile == 0) {
+    return (EFI_NOT_READY);
+  }
+  Size = sizeof(CHAR16);
+  //
+  // Decrement the amount of free space by Size or set to zero (for odd length files)
+  //
+  if (((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)This)->RemainingBytesOfInputFile > Size) {
+    ((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)This)->RemainingBytesOfInputFile -= Size;
+  } else {
+    ((SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL *)This)->RemainingBytesOfInputFile = 0;
+  }
   Key->ScanCode = 0;
   return (ShellInfoObject.NewEfiShellProtocol->ReadFile(
 …
   SHELL_EFI_SIMPLE_TEXT_INPUT_PROTOCOL  *ProtocolToReturn;
   EFI_STATUS                            Status;
+  UINT64                                CurrentPosition;
+  UINT64                                FileSize;
   if (HandleLocation == NULL || FileHandleToUse == NULL) {
 …
     return (NULL);
+  }
+  ProtocolToReturn->FileHandle                  = FileHandleToUse;
+  ShellGetFileSize    (FileHandleToUse, &FileSize);
+  ShellGetFilePosition(FileHandleToUse, &CurrentPosition);
+  //
+  // Initialize the protocol members
+  //
+  ProtocolToReturn->RemainingBytesOfInputFile  = FileSize - CurrentPosition;
+  ProtocolToReturn->FileHandle                 = FileHandleToUse;
   ProtocolToReturn->SimpleTextIn.Reset         = FileBasedSimpleTextInReset;
   ProtocolToReturn->SimpleTextIn.ReadKeyStroke = FileBasedSimpleTextInReadKeyStroke;
 …
+  )
+{
+  return (EFI_UNSUPPORTED);
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *PassThruProtocol;
+  PassThruProtocol = ((SHELL_EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *)This)->OriginalSimpleTextOut;
+  // Pass the QueryMode call thru to the original SimpleTextOutProtocol
+  return (PassThruProtocol->QueryMode(
+    PassThruProtocol,
+    ModeNumber,
+    Columns,
+    Rows));
+}
 …
   SHELL_FILE_HANDLE to support redirecting output from a file.
+  @param[in]  FileHandleToUse The pointer to the SHELL_FILE_HANDLE to use.
+  @param[in]  HandleLocation  The pointer of a location to copy handle with protocol to.
+  @param[in]  FileHandleToUse  The pointer to the SHELL_FILE_HANDLE to use.
+  @param[in]  HandleLocation   The pointer of a location to copy handle with protocol to.
+  @param[in]  OriginalProtocol The pointer to the original output protocol for pass thru of functions.
   @retval NULL                There was insufficient memory available.
 …
 EFIAPI
 CreateSimpleTextOutOnFile(
+  IN SHELL_FILE_HANDLE  FileHandleToUse,
+  IN EFI_HANDLE         *HandleLocation
+  IN SHELL_FILE_HANDLE               FileHandleToUse,
+  IN EFI_HANDLE                      *HandleLocation,
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *OriginalProtocol
+  )
+{
 …
+  }
   ProtocolToReturn->FileHandle                      = FileHandleToUse;
+  ProtocolToReturn->OriginalSimpleTextOut           = OriginalProtocol;
   ProtocolToReturn->SimpleTextOut.Reset             = FileBasedSimpleTextOutReset;
   ProtocolToReturn->SimpleTextOut.TestString        = FileBasedSimpleTextOutTestString;
 …
     return (NULL);
+  }
   ProtocolToReturn->SimpleTextOut.Mode->MaxMode       = 0;
   ProtocolToReturn->SimpleTextOut.Mode->Mode          = 0;
   ProtocolToReturn->SimpleTextOut.Mode->Attribute     = 0;
   ProtocolToReturn->SimpleTextOut.Mode->CursorColumn  = 0;
   ProtocolToReturn->SimpleTextOut.Mode->CursorRow     = 0;
   ProtocolToReturn->SimpleTextOut.Mode->CursorVisible = FALSE;
+  ProtocolToReturn->SimpleTextOut.Mode->MaxMode       = OriginalProtocol->Mode->MaxMode;
+  ProtocolToReturn->SimpleTextOut.Mode->Mode          = OriginalProtocol->Mode->Mode;
+  ProtocolToReturn->SimpleTextOut.Mode->Attribute     = OriginalProtocol->Mode->Attribute;
+  ProtocolToReturn->SimpleTextOut.Mode->CursorColumn  = OriginalProtocol->Mode->CursorColumn;
+  ProtocolToReturn->SimpleTextOut.Mode->CursorRow     = OriginalProtocol->Mode->CursorRow;
+  ProtocolToReturn->SimpleTextOut.Mode->CursorVisible = OriginalProtocol->Mode->CursorVisible;
   Status = gBS->InstallProtocolInterface(

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ConsoleWrappers.h

-              r48674
+              r58459
   Function definitions for shell simple text in and out on top of file handles.
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
   SHELL_FILE_HANDLE to support redirecting output from a file.
+  @param[in]  FileHandleToUse The pointer to the SHELL_FILE_HANDLE to use.
+  @param[in]  HandleLocation  The pointer of a location to copy handle with protocol to.
+  @param[in]  FileHandleToUse  The pointer to the SHELL_FILE_HANDLE to use.
+  @param[in]  HandleLocation   The pointer of a location to copy handle with protocol to.
+  @param[in]  OriginalProtocol The pointer to the original output protocol for pass thru of functions.
   @retval NULL                There was insufficient memory available.
 …
 EFIAPI
 CreateSimpleTextOutOnFile(
+  IN SHELL_FILE_HANDLE  FileHandleToUse,
+  IN EFI_HANDLE         *HandleLocation
+  IN SHELL_FILE_HANDLE               FileHandleToUse,
+  IN EFI_HANDLE                      *HandleLocation,
+  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *OriginalProtocol
   );

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/FileHandleWrappers.c

-              r48674
+              r58459
   StdIn, StdOut, StdErr, etc...).
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
     Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
     if (EFI_ERROR (Status)) {
       continue;
+      break;
+    }
 …
           Cwd = ShellInfoObject.NewEfiShellProtocol->GetCurDir(NULL);
           if (Cwd != NULL) {
             StrCpy(TabStr, Cwd);
+            StrnCpy(TabStr, Cwd, (*BufferSize)/sizeof(CHAR16) - 1);
             if (TabStr[StrLen(TabStr)-1] == L'\\' && *(CurrentString + TabPos) == L'\\' ) {
               TabStr[StrLen(TabStr)-1] = CHAR_NULL;
 …
             StrnCat(TabStr, CurrentString + TabPos, (StringLen - TabPos) * sizeof (CHAR16));
           } else {
             StrCpy(TabStr, L"");
+            *TabStr = CHAR_NULL;
             StrnCat(TabStr, CurrentString + TabPos, (StringLen - TabPos) * sizeof (CHAR16));
+          }
         } else {
           StrCpy(TabStr, CurrentString + TabPos);
+          StrnCpy(TabStr, CurrentString + TabPos, (*BufferSize)/sizeof(CHAR16) - 1);
+        }
         StrCat(TabStr, L"*");
+        StrnCat(TabStr, L"*", (*BufferSize)/sizeof(CHAR16) - 1 - StrLen(TabStr));
         FoundFileList = NULL;
-//        TabStr = PathCleanUpDirectories(TabStr);
         Status  = ShellInfoObject.NewEfiShellProtocol->FindFiles(TabStr, &FoundFileList);
         for ( TempStr = CurrentString
 …
   ASSERT(FoundFileList == NULL);
   return EFI_SUCCESS;
+  return Status;
+}
 …
+  )
+{
+  VOID*       NewBuffer;
+  UINTN       NewSize;
+  EFI_STATUS  Status;
+  //
+  // Most if not all UEFI commands will have an '\r\n' at the end of any output.
+  // Since the output was redirected to a variable, it does not make sense to
+  // keep this.  So, before closing, strip the trailing '\r\n' from the variable
+  // if it exists.
+  //
+  NewBuffer   = NULL;
+  NewSize     = 0;
+  Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
+  if (Status == EFI_BUFFER_TOO_SMALL) {
+    NewBuffer = AllocateZeroPool(NewSize + sizeof(CHAR16));
+    if (NewBuffer == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+    Status = SHELL_GET_ENVIRONMENT_VARIABLE(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, &NewSize, NewBuffer);
+  }
+  if (!EFI_ERROR(Status) && NewBuffer != NULL) {
+    if (StrSize(NewBuffer) > 6)
+    {
+      if ((((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 2] == CHAR_LINEFEED)
+           && (((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 3] == CHAR_CARRIAGE_RETURN)) {
+        ((CHAR16*)NewBuffer)[(StrSize(NewBuffer)/2) - 3] = CHAR_NULL;
+      }
+      if (IsVolatileEnv(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name)) {
+        Status = SHELL_SET_ENVIRONMENT_VARIABLE_V(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, StrSize(NewBuffer), NewBuffer);
+      } else {
+        Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV(((EFI_FILE_PROTOCOL_ENVIRONMENT*)This)->Name, StrSize(NewBuffer), NewBuffer);
+      }
+    }
+  }
+  SHELL_FREE_NON_NULL(NewBuffer);
   FreePool((EFI_FILE_PROTOCOL_ENVIRONMENT*)This);
   return (EFI_SUCCESS);
+  return (Status);
+}
 …
+{
   EFI_FILE_PROTOCOL_ENVIRONMENT  *EnvFileInterface;
+  UINTN                          EnvNameSize;
   if (EnvName == NULL) {
 …
   // Get some memory
   //
+  EnvFileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_ENVIRONMENT)+StrSize(EnvName));
+  EnvNameSize = StrSize(EnvName);
+  EnvFileInterface = AllocateZeroPool(sizeof(EFI_FILE_PROTOCOL_ENVIRONMENT)+EnvNameSize);
   if (EnvFileInterface == NULL){
     return (NULL);
 …
   EnvFileInterface->Delete      = FileInterfaceEnvDelete;
   EnvFileInterface->Read        = FileInterfaceEnvRead;
   StrCpy(EnvFileInterface->Name, EnvName);
+  CopyMem(EnvFileInterface->Name, EnvName, EnvNameSize);
   //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/Shell.c

-              r48674
+              r58459
   This is THE shell (application)
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   FALSE,
+  {
+,
+,
+,
+,
+,
+,
+,
+,
+,
+    {{
+,
+,
+,
+,
+,
+,
+,
+,
+    }},
 ,
     NULL,
     NULL
   },
   {0,0},
+  {{NULL, NULL}, NULL},
+  {
     {0,0},
+    {{NULL, NULL}, NULL},
 ,
 ,
 …
   NULL,
   NULL,
+  {0,0,NULL,NULL},
+  {0,0},
+  {{NULL, NULL}, NULL, NULL},
+  {{NULL, NULL}, NULL, NULL},
+  NULL,
+  NULL,
+  NULL,
+  NULL,
   NULL,
   NULL,
 …
 STATIC CONST CHAR16 mExecutableExtensions[] = L".NSH;.EFI";
 STATIC CONST CHAR16 mStartupScript[]        = L"startup.nsh";
+/**
+  Cleans off leading and trailing spaces and tabs.
+  @param[in] String pointer to the string to trim them off.
+**/
+EFI_STATUS
+EFIAPI
+TrimSpaces(
+  IN CHAR16 **String
+  )
+{
+  ASSERT(String != NULL);
+  ASSERT(*String!= NULL);
+  //
+  // Remove any spaces and tabs at the beginning of the (*String).
+  //
+  while (((*String)[0] == L' ') || ((*String)[0] == L'\t')) {
+    CopyMem((*String), (*String)+1, StrSize((*String)) - sizeof((*String)[0]));
+  }
+  //
+  // Remove any spaces and tabs at the end of the (*String).
+  //
+  while ((StrLen (*String) > 0) && (((*String)[StrLen((*String))-1] == L' ') || ((*String)[StrLen((*String))-1] == L'\t'))) {
+    (*String)[StrLen((*String))-1] = CHAR_NULL;
+  }
+  return (EFI_SUCCESS);
+}
+/**
+  Parse for the next instance of one string within another string. Can optionally make sure that
+  the string was not escaped (^ character) per the shell specification.
+  @param[in] SourceString             The string to search within
+  @param[in] FindString               The string to look for
+  @param[in] CheckForEscapeCharacter  TRUE to skip escaped instances of FinfString, otherwise will return even escaped instances
+**/
+CHAR16*
+EFIAPI
+FindNextInstance(
+  IN CONST CHAR16   *SourceString,
+  IN CONST CHAR16   *FindString,
+  IN CONST BOOLEAN  CheckForEscapeCharacter
+  )
+{
+  CHAR16 *Temp;
+  if (SourceString == NULL) {
+    return (NULL);
+  }
+  Temp = StrStr(SourceString, FindString);
+  //
+  // If nothing found, or we dont care about escape characters
+  //
+  if (Temp == NULL || !CheckForEscapeCharacter) {
+    return (Temp);
+  }
+  //
+  // If we found an escaped character, try again on the remainder of the string
+  //
+  if ((Temp > (SourceString)) && *(Temp-1) == L'^') {
+    return FindNextInstance(Temp+1, FindString, CheckForEscapeCharacter);
+  }
+  //
+  // we found the right character
+  //
+  return (Temp);
+}
+/**
+  Check whether the string between a pair of % is a valid envifronment variable name.
+  @param[in] BeginPercent       pointer to the first percent.
+  @param[in] EndPercent          pointer to the last percent.
+  @retval TRUE                          is a valid environment variable name.
+  @retval FALSE                         is NOT a valid environment variable name.
+**/
+BOOLEAN
+IsValidEnvironmentVariableName(
+  IN CONST CHAR16     *BeginPercent,
+  IN CONST CHAR16     *EndPercent
+  )
+{
+  CONST CHAR16    *Walker;
+  Walker = NULL;
+  ASSERT (BeginPercent != NULL);
+  ASSERT (EndPercent != NULL);
+  ASSERT (BeginPercent < EndPercent);
+  if ((BeginPercent + 1) == EndPercent) {
+    return FALSE;
+  }
+  for (Walker = BeginPercent + 1; Walker < EndPercent; Walker++) {
+    if (
+        (*Walker >= L'0' && *Walker <= L'9') ||
+        (*Walker >= L'A' && *Walker <= L'Z') ||
+        (*Walker >= L'a' && *Walker <= L'z') ||
+        (*Walker == L'_')
+      ) {
+      if (Walker == BeginPercent + 1 && (*Walker >= L'0' && *Walker <= L'9')) {
+        return FALSE;
+      } else {
+        continue;
+      }
+    } else {
+      return FALSE;
+    }
+  }
+  return TRUE;
+}
+/**
+  Determine if a command line contains a split operation
+  @param[in] CmdLine      The command line to parse.
+  @retval TRUE            CmdLine has a valid split.
+  @retval FALSE           CmdLine does not have a valid split.
+**/
+BOOLEAN
+EFIAPI
+ContainsSplit(
+  IN CONST CHAR16 *CmdLine
+  )
+{
+  CONST CHAR16 *TempSpot;
+  CONST CHAR16 *FirstQuote;
+  CONST CHAR16 *SecondQuote;
+  FirstQuote    = FindNextInstance (CmdLine, L"\"", TRUE);
+  SecondQuote   = NULL;
+  TempSpot      = FindFirstCharacter(CmdLine, L"|", L'^');
+  if (FirstQuote == NULL    ||
+      TempSpot == NULL      ||
+      TempSpot == CHAR_NULL ||
+      FirstQuote > TempSpot
+      ) {
+    return (BOOLEAN) ((TempSpot != NULL) && (*TempSpot != CHAR_NULL));
+  }
+  while ((TempSpot != NULL) && (*TempSpot != CHAR_NULL)) {
+    if (FirstQuote == NULL || FirstQuote > TempSpot) {
+      break;
+    }
+    SecondQuote = FindNextInstance (FirstQuote + 1, L"\"", TRUE);
+    if (SecondQuote == NULL) {
+      break;
+    }
+    if (SecondQuote < TempSpot) {
+      FirstQuote = FindNextInstance (SecondQuote + 1, L"\"", TRUE);
+      continue;
+    } else {
+      FirstQuote = FindNextInstance (SecondQuote + 1, L"\"", TRUE);
+      TempSpot = FindFirstCharacter(TempSpot + 1, L"|", L'^');
+      continue;
+    }
+  }
+  return (BOOLEAN) ((TempSpot != NULL) && (*TempSpot != CHAR_NULL));
+}
 /**
 …
       &KeyData,
       NotificationFunction,
       &ShellInfoObject.CtrlSNotifyHandle2);
+      &ShellInfoObject.CtrlSNotifyHandle3);
+  }
   KeyData.KeyState.KeyShiftState  = EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED;
 …
       &KeyData,
       NotificationFunction,
       &ShellInfoObject.CtrlSNotifyHandle2);
+      &ShellInfoObject.CtrlSNotifyHandle4);
+  }
   return (Status);
 …
+      }
       if (ShellInfoObject.HiiHandle == NULL) {
+        return (EFI_NOT_STARTED);
+        Status = EFI_NOT_STARTED;
+        goto FreeResources;
+      }
+    }
 …
     // Check the command line
     //
+    Status = ProcessCommandLine();
+    Status = ProcessCommandLine ();
+    if (EFI_ERROR (Status)) {
+      goto FreeResources;
+    }
     //
 …
         gST->ConOut->Mode->CursorRow,
         NULL,
         STRING_TOKEN (STR_VER_OUTPUT_MAIN),
+        STRING_TOKEN (STR_VER_OUTPUT_MAIN_SHELL),
         ShellInfoObject.HiiHandle,
         SupportLevel[PcdGet8(PcdShellSupportLevel)],
         gEfiShellProtocol->MajorVersion,
+        gEfiShellProtocol->MinorVersion,
+        gEfiShellProtocol->MinorVersion
+       );
+      ShellPrintHiiEx (
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN (STR_VER_OUTPUT_MAIN_SUPPLIER),
+        ShellInfoObject.HiiHandle,
+        (CHAR16 *) PcdGetPtr (PcdShellSupplier)
+       );
+      ShellPrintHiiEx (
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN (STR_VER_OUTPUT_MAIN_UEFI),
+        ShellInfoObject.HiiHandle,
         (gST->Hdr.Revision&0xffff0000)>>16,
         (gST->Hdr.Revision&0x0000ffff),
 …
+      }
       if (!ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel) >= 3 || PcdGetBool(PcdShellForceConsole)) && !EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
+      if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit && !ShellCommandGetExit() && (PcdGet8(PcdShellSupportLevel) >= 3 || PcdGetBool(PcdShellForceConsole)) && !EFI_ERROR(Status) && !ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
         //
         // begin the UI waiting loop
 …
           //
           ShellInfoObject.PageBreakEnabled        = PcdGetBool(PcdShellPageBreakDefault);
+          ASSERT (ShellInfoObject.ConsoleInfo != NULL);
           ShellInfoObject.ConsoleInfo->Enabled    = TRUE;
           ShellInfoObject.ConsoleInfo->RowCounter = 0;
 …
+  }
+FreeResources:
   //
   // uninstall protocols / free memory / etc...
 …
   if (ShellInfoObject.NewEfiShellProtocol != NULL){
     if (ShellInfoObject.NewEfiShellProtocol->IsRootShell()){
       ShellInfoObject.NewEfiShellProtocol->SetEnv(L"cwd", L"", TRUE);
+      InternalEfiShellSetEnv(L"cwd", NULL, TRUE);
+    }
     CleanUpShellProtocol(ShellInfoObject.NewEfiShellProtocol);
 …
+}
-STATIC CONST SHELL_PARAM_ITEM mShellParamList[] = {
-  {L"-nostartup",     TypeFlag},
-  {L"-startup",       TypeFlag},
-  {L"-noconsoleout",  TypeFlag},
-  {L"-noconsolein",   TypeFlag},
-  {L"-nointerrupt",   TypeFlag},
-  {L"-nomap",         TypeFlag},
-  {L"-noversion",     TypeFlag},
-  {L"-startup",       TypeFlag},
-  {L"-delay",         TypeValue},
-  {NULL, TypeMax}
-  };
 /**
   Process all Uefi Shell 2.0 command line options.
 …
+  )
+{
+  EFI_STATUS    Status;
+  LIST_ENTRY    *Package;
+  UINTN         Size;
+  CONST CHAR16  *TempConst;
+  UINTN         Count;
+  UINTN         LoopVar;
+  CHAR16        *ProblemParam;
+  UINT64        Intermediate;
+  Package       = NULL;
+  ProblemParam  = NULL;
+  Status = ShellCommandLineParse (mShellParamList, &Package, NULL, FALSE);
+  Count = 1;
+  Size = 0;
+  TempConst = ShellCommandLineGetRawValue(Package, Count++);
+  if (TempConst != NULL && StrLen(TempConst)) {
+    ShellInfoObject.ShellInitSettings.FileName = AllocateZeroPool(StrSize(TempConst));
+    if (ShellInfoObject.ShellInitSettings.FileName == NULL) {
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    StrCpy(ShellInfoObject.ShellInitSettings.FileName, TempConst);
+    ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = 1;
+    for (LoopVar = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
+      if (StrCmp(gEfiShellParametersProtocol->Argv[LoopVar], ShellInfoObject.ShellInitSettings.FileName)==0) {
+        LoopVar++;
+        //
+        // We found the file... add the rest of the params...
+        //
+        for ( ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
+          ASSERT((ShellInfoObject.ShellInitSettings.FileOptions == NULL && Size == 0) || (ShellInfoObject.ShellInitSettings.FileOptions != NULL));
+          StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
+                      &Size,
+                      L" ",
+);
+          if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
+            SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
+            return (EFI_OUT_OF_RESOURCES);
+          }
+          StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
+                      &Size,
+                      gEfiShellParametersProtocol->Argv[LoopVar],
+);
+          if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
+            SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
+            return (EFI_OUT_OF_RESOURCES);
+          }
+  UINTN                           Size;
+  UINTN                           LoopVar;
+  CHAR16                          *CurrentArg;
+  CHAR16                          *DelayValueStr;
+  UINT64                          DelayValue;
+  EFI_STATUS                      Status;
+  EFI_UNICODE_COLLATION_PROTOCOL  *UnicodeCollation;
+  // `file-name-options` will contain arguments to `file-name` that we don't
+  // know about. This would cause ShellCommandLineParse to error, so we parse
+  // arguments manually, ignoring those after the first thing that doesn't look
+  // like a shell option (which is assumed to be `file-name`).
+  Status = gBS->LocateProtocol (
+                  &gEfiUnicodeCollationProtocolGuid,
+                  NULL,
+                  (VOID **) &UnicodeCollation
+                  );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  // Set default options
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup      = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup    = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn  = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt  = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap        = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion    = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay        = FALSE;
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit         = FALSE;
+  ShellInfoObject.ShellInitSettings.Delay = 5;
+  //
+  // Start LoopVar at 0 to parse only optional arguments at Argv[0]
+  // and parse other parameters from Argv[1].  This is for use case that
+  // UEFI Shell boot option is created, and OptionalData is provided
+  // that starts with shell command-line options.
+  //
+  for (LoopVar = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
+    CurrentArg = gEfiShellParametersProtocol->Argv[LoopVar];
+    if (UnicodeCollation->StriColl (
+                            UnicodeCollation,
+                            L"-startup",
+                            CurrentArg
+                            ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup      = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-nostartup",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup    = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-noconsoleout",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-noconsolein",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn  = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-nointerrupt",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt  = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-nomap",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap        = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-noversion",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion    = TRUE;
+    }
+    else if (UnicodeCollation->StriColl (
+                                 UnicodeCollation,
+                                 L"-delay",
+                                 CurrentArg
+                                 ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay        = TRUE;
+      // Check for optional delay value following "-delay"
+      DelayValueStr = gEfiShellParametersProtocol->Argv[LoopVar + 1];
+      if (DelayValueStr != NULL){
+        if (*DelayValueStr == L':') {
+          DelayValueStr++;
+        }
+      }
+    }
+  } else {
+    ShellCommandLineFreeVarList(Package);
+    Package = NULL;
+    Status = ShellCommandLineParse (mShellParamList, &Package, &ProblemParam, FALSE);
+    if (EFI_ERROR(Status)) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), ShellInfoObject.HiiHandle, ProblemParam);
+      FreePool(ProblemParam);
+      ShellCommandLineFreeVarList(Package);
+      return (EFI_INVALID_PARAMETER);
+    }
+  }
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.Startup      = ShellCommandLineGetFlag(Package, L"-startup");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup    = ShellCommandLineGetFlag(Package, L"-nostartup");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleOut = ShellCommandLineGetFlag(Package, L"-noconsoleout");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn  = ShellCommandLineGetFlag(Package, L"-noconsolein");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt  = ShellCommandLineGetFlag(Package, L"-nointerrupt");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoMap        = ShellCommandLineGetFlag(Package, L"-nomap");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoVersion    = ShellCommandLineGetFlag(Package, L"-noversion");
+  ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay        = ShellCommandLineGetFlag(Package, L"-delay");
+  ShellInfoObject.ShellInitSettings.Delay = 5;
+        if (!EFI_ERROR(ShellConvertStringToUint64 (
+                        DelayValueStr,
+                        &DelayValue,
+                        FALSE,
+                        FALSE
+                        ))) {
+          ShellInfoObject.ShellInitSettings.Delay = (UINTN)DelayValue;
+          LoopVar++;
+        }
+      }
+    } else if (UnicodeCollation->StriColl (
+                                   UnicodeCollation,
+                                   L"-_exit",
+                                   CurrentArg
+                                   ) == 0) {
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.Exit         = TRUE;
+    } else if (StrnCmp (L"-", CurrentArg, 1) == 0) {
+      // Unrecognised option
+      ShellPrintHiiEx(-1, -1, NULL,
+        STRING_TOKEN (STR_GEN_PROBLEM),
+        ShellInfoObject.HiiHandle,
+        CurrentArg
+        );
+      return EFI_INVALID_PARAMETER;
+    } else {
+      //
+      // First argument should be Shell.efi image name
+      //
+      if (LoopVar == 0) {
+        continue;
+      }
+      ShellInfoObject.ShellInitSettings.FileName = AllocateCopyPool(StrSize(CurrentArg), CurrentArg);
+      if (ShellInfoObject.ShellInitSettings.FileName == NULL) {
+        return (EFI_OUT_OF_RESOURCES);
+      }
+      //
+      // We found `file-name`.
+      //
+      ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoStartup = 1;
+      LoopVar++;
+      // Add `file-name-options`
+      for (Size = 0 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
+        ASSERT((ShellInfoObject.ShellInitSettings.FileOptions == NULL && Size == 0) || (ShellInfoObject.ShellInitSettings.FileOptions != NULL));
+        StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
+                    &Size,
+                    L" ",
+);
+        if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
+          SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
+          return (EFI_OUT_OF_RESOURCES);
+        }
+        StrnCatGrow(&ShellInfoObject.ShellInitSettings.FileOptions,
+                    &Size,
+                    gEfiShellParametersProtocol->Argv[LoopVar],
+);
+        if (ShellInfoObject.ShellInitSettings.FileOptions == NULL) {
+          SHELL_FREE_NON_NULL(ShellInfoObject.ShellInitSettings.FileName);
+          return (EFI_OUT_OF_RESOURCES);
+        }
+      }
+    }
+  }
+  // "-nointerrupt" overrides "-delay"
   if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoInterrupt) {
     ShellInfoObject.ShellInitSettings.Delay = 0;
+  } else if (ShellInfoObject.ShellInitSettings.BitUnion.Bits.Delay) {
+    TempConst = ShellCommandLineGetValue(Package, L"-delay");
+    if (TempConst != NULL && *TempConst == L':') {
+      TempConst++;
+    }
+    if (TempConst != NULL && !EFI_ERROR(ShellConvertStringToUint64(TempConst, &Intermediate, FALSE, FALSE))) {
+      ShellInfoObject.ShellInitSettings.Delay = (UINTN)Intermediate;
+    }
+  }
+  ShellCommandLineFreeVarList(Package);
+  return (Status);
+  }
+  return EFI_SUCCESS;
+}
 …
 EFIAPI
 DoStartupScript(
   EFI_DEVICE_PATH_PROTOCOL *ImagePath,
   EFI_DEVICE_PATH_PROTOCOL *FilePath
+  IN EFI_DEVICE_PATH_PROTOCOL *ImagePath,
+  IN EFI_DEVICE_PATH_PROTOCOL *FilePath
+  )
+{
 …
       return (EFI_OUT_OF_RESOURCES);
+    }
     StrCpy(FileStringPath, ShellInfoObject.ShellInitSettings.FileName);
+    StrnCpy(FileStringPath, ShellInfoObject.ShellInitSettings.FileName, NewSize/sizeof(CHAR16) -1);
     if (ShellInfoObject.ShellInitSettings.FileOptions != NULL) {
       StrCat(FileStringPath, L" ");
       StrCat(FileStringPath, ShellInfoObject.ShellInitSettings.FileOptions);
+      StrnCat(FileStringPath, L" ", NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);
+      StrnCat(FileStringPath, ShellInfoObject.ShellInitSettings.FileOptions, NewSize/sizeof(CHAR16) - StrLen(FileStringPath) -1);
+    }
     Status = RunCommand(FileStringPath);
 …
+  }
+  gST->ConOut->EnableCursor(gST->ConOut, FALSE);
   //
   // print out our warning and see if they press a key
   //
   for ( Status = EFI_UNSUPPORTED, Delay = ShellInfoObject.ShellInitSettings.Delay * 10
+  for ( Status = EFI_UNSUPPORTED, Delay = ShellInfoObject.ShellInitSettings.Delay
       ; Delay != 0 && EFI_ERROR(Status)
       ; Delay--
      ){
     ShellPrintHiiEx(0, gST->ConOut->Mode->CursorRow, NULL, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION), ShellInfoObject.HiiHandle, Delay/10);
     gBS->Stall (100000);
+    ShellPrintHiiEx(0, gST->ConOut->Mode->CursorRow, NULL, STRING_TOKEN (STR_SHELL_STARTUP_QUESTION), ShellInfoObject.HiiHandle, Delay);
+    gBS->Stall (1000000);
     if (!ShellInfoObject.ShellInitSettings.BitUnion.Bits.NoConsoleIn) {
       Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
 …
+  }
   ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_CRLF), ShellInfoObject.HiiHandle);
+  gST->ConOut->EnableCursor(gST->ConOut, TRUE);
   //
 …
   //
   if (!EFI_ERROR(Status) && FileHandle != NULL) {
     Status = RunScriptFileHandle (FileHandle, mStartupScript);
+    Status = RunScriptFile (mStartupScript, FileHandle, L"", ShellInfoObject.NewShellParametersProtocol);
     ShellInfoObject.NewEfiShellProtocol->CloseFile(FileHandle);
   } else {
 …
       ASSERT(FileHandle == NULL);
     } else {
       Status = RunScriptFile(FileStringPath);
+      Status = RunScriptFile(FileStringPath, NULL, L"", ShellInfoObject.NewShellParametersProtocol);
       FreePool(FileStringPath);
+    }
 …
     CmdLine[BufferSize / sizeof (CHAR16)] = CHAR_NULL;
     Status = RunCommand(CmdLine);
+  }
+    }
   //
 …
   Node = AllocateZeroPool(sizeof(BUFFER_LIST));
   ASSERT(Node != NULL);
   Node->Buffer = AllocateZeroPool(StrSize(Buffer));
+  Node->Buffer = AllocateCopyPool(StrSize(Buffer), Buffer);
   ASSERT(Node->Buffer != NULL);
-  StrCpy(Node->Buffer, Buffer);
   InsertTailList(&ShellInfoObject.ViewingSettings.CommandHistory.Link, &Node->Link);
 …
+  }
   FreePool(*CommandString);
   *CommandString = AllocateZeroPool(StrSize(NewString));
+  *CommandString = AllocateCopyPool(StrSize(NewString), NewString);
   if (*CommandString == NULL) {
     return (EFI_OUT_OF_RESOURCES);
+  }
+  StrCpy(*CommandString, NewString);
+  return (EFI_SUCCESS);
+}
+/**
+  This function will eliminate unreplaced (and therefore non-found) environment variables.
+  @param[in,out] CmdLine   The command line to update.
+**/
+EFI_STATUS
+EFIAPI
+StripUnreplacedEnvironmentVariables(
+  IN OUT CHAR16 *CmdLine
+  )
+{
+  CHAR16 *FirstPercent;
+  CHAR16 *FirstQuote;
+  CHAR16 *SecondPercent;
+  CHAR16 *SecondQuote;
+  CHAR16 *CurrentLocator;
+  for (CurrentLocator = CmdLine ; CurrentLocator != NULL ; ) {
+    FirstQuote = FindNextInstance(CurrentLocator, L"\"", TRUE);
+    FirstPercent = FindNextInstance(CurrentLocator, L"%", TRUE);
+    SecondPercent = FirstPercent!=NULL?FindNextInstance(FirstPercent+1, L"%", TRUE):NULL;
+    if (FirstPercent == NULL || SecondPercent == NULL) {
+      //
+      // If we ever dont have 2 % we are done.
+      //
+      break;
+    }
+    if (FirstQuote!= NULL && FirstQuote < FirstPercent) {
+      SecondQuote = FindNextInstance(FirstQuote+1, L"\"", TRUE);
+      //
+      // Quote is first found
+      //
+      if (SecondQuote < FirstPercent) {
+        //
+        // restart after the pair of "
+        //
+        CurrentLocator = SecondQuote + 1;
+      } else /* FirstPercent < SecondQuote */{
+        //
+        // Restart on the first percent
+        //
+        CurrentLocator = FirstPercent;
+      }
+      continue;
+    }
+    if (FirstQuote == NULL || SecondPercent < FirstQuote) {
+      if (IsValidEnvironmentVariableName(FirstPercent, SecondPercent)) {
+        //
+        // We need to remove from FirstPercent to SecondPercent
+        //
+        CopyMem(FirstPercent, SecondPercent + 1, StrSize(SecondPercent + 1));
+        //
+        // dont need to update the locator.  both % characters are gone.
+        //
+      } else {
+        CurrentLocator = SecondPercent + 1;
+      }
+      continue;
+    }
+    CurrentLocator = FirstQuote;
+  }
   return (EFI_SUCCESS);
+}
 …
   //
-  // Quick out if none were found...
-  //
-  if (NewSize == StrSize(OriginalCommandLine)) {
-    ASSERT(Temp == NULL);
-    Temp = StrnCatGrow(&Temp, NULL, OriginalCommandLine, 0);
-    return (Temp);
+  }
-  //
   // now do the replacements...
   //
   NewCommandLine1 = AllocateZeroPool(NewSize);
+  NewCommandLine1 = AllocateCopyPool(NewSize, OriginalCommandLine);
   NewCommandLine2 = AllocateZeroPool(NewSize);
   ItemTemp        = AllocateZeroPool(ItemSize+(2*sizeof(CHAR16)));
 …
     return (NULL);
+  }
-  StrCpy(NewCommandLine1, OriginalCommandLine);
   for (MasterEnvList = EfiShellGetEnv(NULL)
     ;  MasterEnvList != NULL && *MasterEnvList != CHAR_NULL //&& *(MasterEnvList+1) != CHAR_NULL
+    ;  MasterEnvList != NULL && *MasterEnvList != CHAR_NULL
     ;  MasterEnvList += StrLen(MasterEnvList) + 1
    ){
     StrCpy(ItemTemp, L"%");
     StrCat(ItemTemp, MasterEnvList);
     StrCat(ItemTemp, L"%");
+    StrnCpy(ItemTemp, L"%", ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16))-1);
+    StrnCat(ItemTemp, MasterEnvList, ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16))-1 - StrLen(ItemTemp));
+    StrnCat(ItemTemp, L"%", ((ItemSize+(2*sizeof(CHAR16)))/sizeof(CHAR16))-1 - StrLen(ItemTemp));
     ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, ItemTemp, EfiShellGetEnv(MasterEnvList), TRUE, FALSE);
     StrCpy(NewCommandLine1, NewCommandLine2);
+    StrnCpy(NewCommandLine1, NewCommandLine2, NewSize/sizeof(CHAR16)-1);
+  }
   if (CurrentScriptFile != NULL) {
 …
    ){
     ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, AliasListNode->Alias, AliasListNode->CommandString, TRUE, FALSE);
+    StrCpy(NewCommandLine1, NewCommandLine2);
+    }
+  }
+    StrnCpy(NewCommandLine1, NewCommandLine2, NewSize/sizeof(CHAR16)-1);
+    }
+  }
+  //
+  // Remove non-existant environment variables
+  //
+  StripUnreplacedEnvironmentVariables(NewCommandLine1);
+  //
+  // Now cleanup any straggler intentionally ignored "%" characters
+  //
+  ShellCopySearchAndReplace(NewCommandLine1, NewCommandLine2, NewSize, L"^%", L"%", TRUE, FALSE);
+  StrnCpy(NewCommandLine1, NewCommandLine2, NewSize/sizeof(CHAR16)-1);
   FreePool(NewCommandLine2);
   FreePool(ItemTemp);
 …
     SHELL_FREE_NON_NULL(NextCommandLine);
     return (EFI_OUT_OF_RESOURCES);
+  }
+  if (NextCommandLine[0] != CHAR_NULL &&
+  } else if (StrStr(OurCommandLine, L"|") != NULL || Size1 == 0 || Size2 == 0) {
+    SHELL_FREE_NON_NULL(OurCommandLine);
+    SHELL_FREE_NON_NULL(NextCommandLine);
+    return (EFI_INVALID_PARAMETER);
+  } else if (NextCommandLine[0] != CHAR_NULL &&
       NextCommandLine[0] == L'a' &&
       NextCommandLine[1] == L' '
 …
   InsertHeadList(&ShellInfoObject.SplitList.Link, &Split->Link);
-  ASSERT(StrStr(OurCommandLine, L"|") == NULL);
   Status = RunCommand(OurCommandLine);
 …
 /**
+  Function will process and run a command line.
+  This will determine if the command line represents an internal shell
+  command or dispatch an external application.
+  Take the original command line, substitute any variables, free
+  the original string, return the modified copy.
+  @param[in] CmdLine  pointer to the command line to update.
+  @retval EFI_SUCCESS           the function was successful.
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.
+**/
+EFI_STATUS
+EFIAPI
+ShellSubstituteVariables(
+  IN CHAR16 **CmdLine
+  )
+{
+  CHAR16      *NewCmdLine;
+  NewCmdLine = ShellConvertVariables(*CmdLine);
+  SHELL_FREE_NON_NULL(*CmdLine);
+  if (NewCmdLine == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  *CmdLine = NewCmdLine;
+  return (EFI_SUCCESS);
+}
+/**
+  Take the original command line, substitute any alias in the first group of space delimited characters, free
+  the original string, return the modified copy.
+  @param[in] CmdLine  pointer to the command line to update.
+  @retval EFI_SUCCESS           the function was successful.
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.
+**/
+EFI_STATUS
+EFIAPI
+ShellSubstituteAliases(
+  IN CHAR16 **CmdLine
+  )
+{
+  CHAR16      *NewCmdLine;
+  CHAR16      *CommandName;
+  EFI_STATUS  Status;
+  UINTN       PostAliasSize;
+  ASSERT(CmdLine != NULL);
+  ASSERT(*CmdLine!= NULL);
+  CommandName = NULL;
+  if (StrStr((*CmdLine), L" ") == NULL){
+    StrnCatGrow(&CommandName, NULL, (*CmdLine), 0);
+  } else {
+    StrnCatGrow(&CommandName, NULL, (*CmdLine), StrStr((*CmdLine), L" ") - (*CmdLine));
+  }
+  //
+  // This cannot happen 'inline' since the CmdLine can need extra space.
+  //
+  NewCmdLine = NULL;
+  if (!ShellCommandIsCommandOnList(CommandName)) {
+    //
+    // Convert via alias
+    //
+    Status = ShellConvertAlias(&CommandName);
+    if (EFI_ERROR(Status)){
+      return (Status);
+    }
+    PostAliasSize = 0;
+    NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, CommandName, 0);
+    if (NewCmdLine == NULL) {
+      SHELL_FREE_NON_NULL(CommandName);
+      SHELL_FREE_NON_NULL(*CmdLine);
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    NewCmdLine = StrnCatGrow(&NewCmdLine, &PostAliasSize, StrStr((*CmdLine), L" "), 0);
+    if (NewCmdLine == NULL) {
+      SHELL_FREE_NON_NULL(CommandName);
+      SHELL_FREE_NON_NULL(*CmdLine);
+      return (EFI_OUT_OF_RESOURCES);
+    }
+  } else {
+    NewCmdLine = StrnCatGrow(&NewCmdLine, NULL, (*CmdLine), 0);
+  }
+  SHELL_FREE_NON_NULL(*CmdLine);
+  SHELL_FREE_NON_NULL(CommandName);
+  //
+  // re-assign the passed in double pointer to point to our newly allocated buffer
+  //
+  *CmdLine = NewCmdLine;
+  return (EFI_SUCCESS);
+}
+/**
+  Takes the Argv[0] part of the command line and determine the meaning of it.
+  @param[in] CmdName  pointer to the command line to update.
+  @retval Internal_Command    The name is an internal command.
+  @retval File_Sys_Change     the name is a file system change.
+  @retval Script_File_Name    the name is a NSH script file.
+  @retval Unknown_Invalid     the name is unknown.
+  @retval Efi_Application     the name is an application (.EFI).
+**/
+SHELL_OPERATION_TYPES
+EFIAPI
+GetOperationType(
+  IN CONST CHAR16 *CmdName
+  )
+{
+        CHAR16* FileWithPath;
+  CONST CHAR16* TempLocation;
+  CONST CHAR16* TempLocation2;
+  FileWithPath = NULL;
+  //
+  // test for an internal command.
+  //
+  if (ShellCommandIsCommandOnList(CmdName)) {
+    return (Internal_Command);
+  }
+  //
+  // Test for file system change request.  anything ending with first : and cant have spaces.
+  //
+  if (CmdName[(StrLen(CmdName)-1)] == L':') {
+    if ( StrStr(CmdName, L" ") != NULL
+      || StrLen(StrStr(CmdName, L":")) > 1
+      ) {
+      return (Unknown_Invalid);
+    }
+    return (File_Sys_Change);
+  }
+  //
+  // Test for a file
+  //
+  if ((FileWithPath = ShellFindFilePathEx(CmdName, mExecutableExtensions)) != NULL) {
+    //
+    // See if that file has a script file extension
+    //
+    if (StrLen(FileWithPath) > 4) {
+      TempLocation = FileWithPath+StrLen(FileWithPath)-4;
+      TempLocation2 = mScriptExtension;
+      if (StringNoCaseCompare((VOID*)(&TempLocation), (VOID*)(&TempLocation2)) == 0) {
+        SHELL_FREE_NON_NULL(FileWithPath);
+        return (Script_File_Name);
+      }
+    }
+    //
+    // Was a file, but not a script.  we treat this as an application.
+    //
+    SHELL_FREE_NON_NULL(FileWithPath);
+    return (Efi_Application);
+  }
+  SHELL_FREE_NON_NULL(FileWithPath);
+  //
+  // No clue what this is... return invalid flag...
+  //
+  return (Unknown_Invalid);
+}
+/**
+  Determine if the first item in a command line is valid.
+  @param[in] CmdLine            The command line to parse.
+  @retval EFI_SUCCESS           The item is valid.
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
+  @retval EFI_NOT_FOUND         The operation type is unknown or invalid.
+**/
+EFI_STATUS
+EFIAPI
+IsValidSplit(
+  IN CONST CHAR16 *CmdLine
+  )
+{
+  CHAR16        *Temp;
+  CHAR16        *FirstParameter;
+  CHAR16        *TempWalker;
+  EFI_STATUS    Status;
+  Temp           = NULL;
+  Temp = StrnCatGrow(&Temp, NULL, CmdLine, 0);
+  if (Temp == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  FirstParameter = StrStr(Temp, L"|");
+  if (FirstParameter != NULL) {
+    *FirstParameter = CHAR_NULL;
+  }
+  FirstParameter = NULL;
+  //
+  // Process the command line
+  //
+  Status = ProcessCommandLineToFinal(&Temp);
+  if (!EFI_ERROR(Status)) {
+    FirstParameter = AllocateZeroPool(StrSize(CmdLine));
+    if (FirstParameter == NULL) {
+      SHELL_FREE_NON_NULL(Temp);
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    TempWalker = (CHAR16*)Temp;
+    if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CmdLine)))) {
+      if (GetOperationType(FirstParameter) == Unknown_Invalid) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);
+        SetLastError(SHELL_NOT_FOUND);
+        Status = EFI_NOT_FOUND;
+      }
+    }
+  }
+  SHELL_FREE_NON_NULL(Temp);
+  SHELL_FREE_NON_NULL(FirstParameter);
+  return Status;
+}
+/**
+  Determine if a command line contains with a split contains only valid commands.
   @param[in] CmdLine      The command line to parse.
+  @retval EFI_SUCCESS     CmdLine has only valid commands, application, or has no split.
+  @retval EFI_ABORTED     CmdLine has at least one invalid command or application.
+**/
+EFI_STATUS
+EFIAPI
+VerifySplit(
+  IN CONST CHAR16 *CmdLine
+  )
+{
+  CONST CHAR16  *TempSpot;
+  EFI_STATUS    Status;
+  //
+  // Verify up to the pipe or end character
+  //
+  Status = IsValidSplit(CmdLine);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+  //
+  // If this was the only item, then get out
+  //
+  if (!ContainsSplit(CmdLine)) {
+    return (EFI_SUCCESS);
+  }
+  //
+  // recurse to verify the next item
+  //
+  TempSpot = FindFirstCharacter(CmdLine, L"|", L'^') + 1;
+  return (VerifySplit(TempSpot));
+}
+/**
+  Process a split based operation.
+  @param[in] CmdLine    pointer to the command line to process
+  @retval EFI_SUCCESS   The operation was successful
+  @return               an error occured.
+**/
+EFI_STATUS
+EFIAPI
+ProcessNewSplitCommandLine(
+  IN CONST CHAR16 *CmdLine
+  )
+{
+  SPLIT_LIST                *Split;
+  EFI_STATUS                Status;
+  Status = VerifySplit(CmdLine);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+  Split = NULL;
+  //
+  // are we in an existing split???
+  //
+  if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {
+    Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);
+  }
+  if (Split == NULL) {
+    Status = RunSplitCommand(CmdLine, NULL, NULL);
+  } else {
+    Status = RunSplitCommand(CmdLine, Split->SplitStdIn, Split->SplitStdOut);
+  }
+  if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_SPLIT), ShellInfoObject.HiiHandle, CmdLine);
+  }
+  return (Status);
+}
+/**
+  Handle a request to change the current file system.
+  @param[in] CmdLine  The passed in command line.
+  @retval EFI_SUCCESS The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ChangeMappedDrive(
+  IN CONST CHAR16 *CmdLine
+  )
+{
+  EFI_STATUS Status;
+  Status = EFI_SUCCESS;
+  //
+  // make sure we are the right operation
+  //
+  ASSERT(CmdLine[(StrLen(CmdLine)-1)] == L':' && StrStr(CmdLine, L" ") == NULL);
+  //
+  // Call the protocol API to do the work
+  //
+  Status = ShellInfoObject.NewEfiShellProtocol->SetCurDir(NULL, CmdLine);
+  //
+  // Report any errors
+  //
+  if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_MAPPING), ShellInfoObject.HiiHandle, CmdLine);
+  }
+  return (Status);
+}
+/**
+  Reprocess the command line to direct all -? to the help command.
+  if found, will add "help" as argv[0], and move the rest later.
+  @param[in,out] CmdLine        pointer to the command line to update
+**/
+EFI_STATUS
+EFIAPI
+DoHelpUpdate(
+  IN OUT CHAR16 **CmdLine
+  )
+{
+  CHAR16 *CurrentParameter;
+  CHAR16 *Walker;
+  CHAR16 *LastWalker;
+  CHAR16 *NewCommandLine;
+  EFI_STATUS Status;
+  Status = EFI_SUCCESS;
+  CurrentParameter = AllocateZeroPool(StrSize(*CmdLine));
+  if (CurrentParameter == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  Walker = *CmdLine;
+  while(Walker != NULL && *Walker != CHAR_NULL) {
+    LastWalker = Walker;
+    if (!EFI_ERROR(GetNextParameter(&Walker, &CurrentParameter, StrSize(*CmdLine)))) {
+      if (StrStr(CurrentParameter, L"-?") == CurrentParameter) {
+        LastWalker[0] = L' ';
+        LastWalker[1] = L' ';
+        NewCommandLine = AllocateZeroPool(StrSize(L"help ") + StrSize(*CmdLine));
+        if (NewCommandLine == NULL) {
+          Status = EFI_OUT_OF_RESOURCES;
+          break;
+        }
+        //
+        // We know the space is sufficient since we just calculated it.
+        //
+        StrnCpy(NewCommandLine, L"help ", 5);
+        StrnCat(NewCommandLine, *CmdLine, StrLen(*CmdLine));
+        SHELL_FREE_NON_NULL(*CmdLine);
+        *CmdLine = NewCommandLine;
+        break;
+      }
+    }
+  }
+  SHELL_FREE_NON_NULL(CurrentParameter);
+  return (Status);
+}
+/**
+  Function to update the shell variable "lasterror".
+  @param[in] ErrorCode      the error code to put into lasterror.
+**/
+EFI_STATUS
+EFIAPI
+SetLastError(
+  IN CONST SHELL_STATUS   ErrorCode
+  )
+{
+  CHAR16 LeString[19];
+  if (sizeof(EFI_STATUS) == sizeof(UINT64)) {
+    UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ErrorCode);
+  } else {
+    UnicodeSPrint(LeString, sizeof(LeString), L"0x%x", ErrorCode);
+  }
+  DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););
+  InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);
+  return (EFI_SUCCESS);
+}
+/**
+  Converts the command line to it's post-processed form.  this replaces variables and alias' per UEFI Shell spec.
+  @param[in,out] CmdLine        pointer to the command line to update
+  @retval EFI_SUCCESS           The operation was successful
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
+  @return                       some other error occured
+**/
+EFI_STATUS
+EFIAPI
+ProcessCommandLineToFinal(
+  IN OUT CHAR16 **CmdLine
+  )
+{
+  EFI_STATUS                Status;
+  TrimSpaces(CmdLine);
+  Status = ShellSubstituteAliases(CmdLine);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+  TrimSpaces(CmdLine);
+  Status = ShellSubstituteVariables(CmdLine);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+  ASSERT (*CmdLine != NULL);
+  TrimSpaces(CmdLine);
+  //
+  // update for help parsing
+  //
+  if (StrStr(*CmdLine, L"?") != NULL) {
+    //
+    // This may do nothing if the ? does not indicate help.
+    // Save all the details for in the API below.
+    //
+    Status = DoHelpUpdate(CmdLine);
+  }
+  TrimSpaces(CmdLine);
+  return (EFI_SUCCESS);
+}
+/**
+  Run an internal shell command.
+  This API will upadate the shell's environment since these commands are libraries.
+  @param[in] CmdLine          the command line to run.
+  @param[in] FirstParameter   the first parameter on the command line
+  @param[in] ParamProtocol    the shell parameters protocol pointer
   @retval EFI_SUCCESS     The command was completed.
 …
 EFI_STATUS
 EFIAPI
+RunCommand(
+  IN CONST CHAR16   *CmdLine
+  )
+RunInternalCommand(
+  IN CONST CHAR16                   *CmdLine,
+  IN       CHAR16                   *FirstParameter,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
+)
+{
   EFI_STATUS                Status;
-  CHAR16                    *CommandName;
-  SHELL_STATUS              ShellStatus;
   UINTN                     Argc;
   CHAR16                    **Argv;
+  SHELL_STATUS              CommandReturnedStatus;
   BOOLEAN                   LastError;
+  CHAR16                    LeString[11];
+  CHAR16                    *PostAliasCmdLine;
+  UINTN                     PostAliasSize;
+  CHAR16                    *PostVariableCmdLine;
+  CHAR16                    *Walker;
+  CHAR16                    *NewCmdLine;
+  NewCmdLine = AllocateCopyPool (StrSize (CmdLine), CmdLine);
+  if (NewCmdLine == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  for (Walker = NewCmdLine; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
+    if (*Walker == L'^' && *(Walker+1) == L'#') {
+      CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
+    }
+  }
+  //
+  // get the argc and argv updated for internal commands
+  //
+  Status = UpdateArgcArgv(ParamProtocol, NewCmdLine, &Argv, &Argc);
+  if (!EFI_ERROR(Status)) {
+    //
+    // Run the internal command.
+    //
+    Status = ShellCommandRunCommandHandler(FirstParameter, &CommandReturnedStatus, &LastError);
+    if (!EFI_ERROR(Status)) {
+      //
+      // Update last error status.
+      // some commands do not update last error.
+      //
+      if (LastError) {
+        SetLastError(CommandReturnedStatus);
+      }
+      //
+      // Pass thru the exitcode from the app.
+      //
+      if (ShellCommandGetExit()) {
+        //
+        // An Exit was requested ("exit" command), pass its value up.
+        //
+        Status = CommandReturnedStatus;
+      } else if (CommandReturnedStatus != SHELL_SUCCESS && IsScriptOnlyCommand(FirstParameter)) {
+        //
+        // Always abort when a script only command fails for any reason
+        //
+        Status = EFI_ABORTED;
+      } else if (ShellCommandGetCurrentScriptFile() != NULL && CommandReturnedStatus == SHELL_ABORTED) {
+        //
+        // Abort when in a script and a command aborted
+        //
+        Status = EFI_ABORTED;
+      }
+    }
+  }
+  //
+  // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
+  // This is safe even if the update API failed.  In this case, it may be a no-op.
+  //
+  RestoreArgcArgv(ParamProtocol, &Argv, &Argc);
+  //
+  // If a script is running and the command is not a scipt only command, then
+  // change return value to success so the script won't halt (unless aborted).
+  //
+  // Script only commands have to be able halt the script since the script will
+  // not operate if they are failing.
+  //
+  if ( ShellCommandGetCurrentScriptFile() != NULL
+    && !IsScriptOnlyCommand(FirstParameter)
+    && Status != EFI_ABORTED
+    ) {
+    Status = EFI_SUCCESS;
+  }
+  FreePool (NewCmdLine);
+  return (Status);
+}
+/**
+  Function to run the command or file.
+  @param[in] Type             the type of operation being run.
+  @param[in] CmdLine          the command line to run.
+  @param[in] FirstParameter   the first parameter on the command line
+  @param[in] ParamProtocol    the shell parameters protocol pointer
+  @retval EFI_SUCCESS     The command was completed.
+  @retval EFI_ABORTED     The command's operation was aborted.
+**/
+EFI_STATUS
+EFIAPI
+RunCommandOrFile(
+  IN       SHELL_OPERATION_TYPES    Type,
+  IN CONST CHAR16                   *CmdLine,
+  IN       CHAR16                   *FirstParameter,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
+)
+{
+  EFI_STATUS                Status;
+  EFI_STATUS                StartStatus;
   CHAR16                    *CommandWithPath;
+  CONST EFI_DEVICE_PATH_PROTOCOL  *DevPath;
+  CONST CHAR16              *TempLocation;
+  CONST CHAR16              *TempLocation2;
+  EFI_DEVICE_PATH_PROTOCOL  *DevPath;
+  SHELL_STATUS              CalleeExitStatus;
+  Status            = EFI_SUCCESS;
+  CommandWithPath   = NULL;
+  DevPath           = NULL;
+  CalleeExitStatus  = SHELL_INVALID_PARAMETER;
+  switch (Type) {
+    case   Internal_Command:
+      Status = RunInternalCommand(CmdLine, FirstParameter, ParamProtocol);
+      break;
+    case   Script_File_Name:
+    case   Efi_Application:
+      //
+      // Process a fully qualified path
+      //
+      if (StrStr(FirstParameter, L":") != NULL) {
+        ASSERT (CommandWithPath == NULL);
+        if (ShellIsFile(FirstParameter) == EFI_SUCCESS) {
+          CommandWithPath = StrnCatGrow(&CommandWithPath, NULL, FirstParameter, 0);
+        }
+      }
+      //
+      // Process a relative path and also check in the path environment variable
+      //
+      if (CommandWithPath == NULL) {
+        CommandWithPath = ShellFindFilePathEx(FirstParameter, mExecutableExtensions);
+      }
+      //
+      // This should be impossible now.
+      //
+      ASSERT(CommandWithPath != NULL);
+      //
+      // Make sure that path is not just a directory (or not found)
+      //
+      if (!EFI_ERROR(ShellIsDirectory(CommandWithPath))) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);
+        SetLastError(SHELL_NOT_FOUND);
+      }
+      switch (Type) {
+        case   Script_File_Name:
+          Status = RunScriptFile (CommandWithPath, NULL, CmdLine, ParamProtocol);
+          break;
+        case   Efi_Application:
+          //
+          // Get the device path of the application image
+          //
+          DevPath = ShellInfoObject.NewEfiShellProtocol->GetDevicePathFromFilePath(CommandWithPath);
+          if (DevPath == NULL){
+            Status = EFI_OUT_OF_RESOURCES;
+            break;
+          }
+          //
+          // Execute the device path
+          //
+          Status = InternalShellExecuteDevicePath(
+            &gImageHandle,
+            DevPath,
+            CmdLine,
+            NULL,
+            &StartStatus
+           );
+          SHELL_FREE_NON_NULL(DevPath);
+          if(EFI_ERROR (Status)) {
+            CalleeExitStatus = (SHELL_STATUS) (Status & (~MAX_BIT));
+          } else {
+            CalleeExitStatus = (SHELL_STATUS) StartStatus;
+          }
+          //
+          // Update last error status.
+          //
+          // Status is an EFI_STATUS. Clear top bit to convert to SHELL_STATUS
+          SetLastError(CalleeExitStatus);
+          break;
+        default:
+          //
+          // Do nothing.
+          //
+          break;
+      }
+      break;
+    default:
+      //
+      // Do nothing.
+      //
+      break;
+  }
+  SHELL_FREE_NON_NULL(CommandWithPath);
+  return (Status);
+}
+/**
+  Function to setup StdIn, StdErr, StdOut, and then run the command or file.
+  @param[in] Type             the type of operation being run.
+  @param[in] CmdLine          the command line to run.
+  @param[in] FirstParameter   the first parameter on the command line.
+  @param[in] ParamProtocol    the shell parameters protocol pointer
+  @retval EFI_SUCCESS     The command was completed.
+  @retval EFI_ABORTED     The command's operation was aborted.
+**/
+EFI_STATUS
+EFIAPI
+SetupAndRunCommandOrFile(
+  IN SHELL_OPERATION_TYPES          Type,
+  IN CHAR16                         *CmdLine,
+  IN CHAR16                         *FirstParameter,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
+)
+{
+  EFI_STATUS                Status;
   SHELL_FILE_HANDLE         OriginalStdIn;
   SHELL_FILE_HANDLE         OriginalStdOut;
   SHELL_FILE_HANDLE         OriginalStdErr;
   SYSTEM_TABLE_INFO         OriginalSystemTableInfo;
+  CHAR16                    *TempLocation3;
+  UINTN                     Count;
+  UINTN                     Count2;
+  //
+  // Update the StdIn, StdOut, and StdErr for redirection to environment variables, files, etc... unicode and ASCII
+  //
+  Status = UpdateStdInStdOutStdErr(ParamProtocol, CmdLine, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
+  //
+  // The StdIn, StdOut, and StdErr are set up.
+  // Now run the command, script, or application
+  //
+  if (!EFI_ERROR(Status)) {
+    TrimSpaces(&CmdLine);
+    Status = RunCommandOrFile(Type, CmdLine, FirstParameter, ParamProtocol);
+  }
+  //
+  // Now print errors
+  //
+  if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_ERROR), ShellInfoObject.HiiHandle, (VOID*)(Status));
+  }
+  //
+  // put back the original StdIn, StdOut, and StdErr
+  //
+  RestoreStdInStdOutStdErr(ParamProtocol, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
+  return (Status);
+}
+/**
+  Function will process and run a command line.
+  This will determine if the command line represents an internal shell
+  command or dispatch an external application.
+  @param[in] CmdLine      The command line to parse.
+  @retval EFI_SUCCESS     The command was completed.
+  @retval EFI_ABORTED     The command's operation was aborted.
+**/
+EFI_STATUS
+EFIAPI
+RunCommand(
+  IN CONST CHAR16   *CmdLine
+  )
+{
+  EFI_STATUS                Status;
   CHAR16                    *CleanOriginal;
+  SPLIT_LIST                *Split;
+  CHAR16                    *FirstParameter;
+  CHAR16                    *TempWalker;
+  SHELL_OPERATION_TYPES     Type;
   ASSERT(CmdLine != NULL);
 …
+  }
-  CommandName         = NULL;
-  PostVariableCmdLine = NULL;
-  PostAliasCmdLine    = NULL;
-  CommandWithPath     = NULL;
-  DevPath             = NULL;
   Status              = EFI_SUCCESS;
   CleanOriginal       = NULL;
-  Split               = NULL;
   CleanOriginal = StrnCatGrow(&CleanOriginal, NULL, CmdLine, 0);
 …
     return (EFI_OUT_OF_RESOURCES);
+  }
+  while (CleanOriginal[StrLen(CleanOriginal)-1] == L' ') {
+    CleanOriginal[StrLen(CleanOriginal)-1] = CHAR_NULL;
+  }
+  while (CleanOriginal[0] == L' ') {
+    CopyMem(CleanOriginal, CleanOriginal+1, StrSize(CleanOriginal) - sizeof(CleanOriginal[0]));
+  }
+  CommandName = NULL;
+  if (StrStr(CleanOriginal, L" ") == NULL){
+    StrnCatGrow(&CommandName, NULL, CleanOriginal, 0);
+  TrimSpaces(&CleanOriginal);
+  //
+  // NULL out comments (leveraged from RunScriptFileHandle() ).
+  // The # character on a line is used to denote that all characters on the same line
+  // and to the right of the # are to be ignored by the shell.
+  // Afterward, again remove spaces, in case any were between the last command-parameter and '#'.
+  //
+  for (TempWalker = CleanOriginal; TempWalker != NULL && *TempWalker != CHAR_NULL; TempWalker++) {
+    if (*TempWalker == L'^') {
+      if (*(TempWalker + 1) == L'#') {
+        TempWalker++;
+      }
+    } else if (*TempWalker == L'#') {
+      *TempWalker = CHAR_NULL;
+    }
+  }
+  TrimSpaces(&CleanOriginal);
+  //
+  // Handle case that passed in command line is just 1 or more " " characters.
+  //
+  if (StrLen (CleanOriginal) == 0) {
+    SHELL_FREE_NON_NULL(CleanOriginal);
+    return (EFI_SUCCESS);
+  }
+  Status = ProcessCommandLineToFinal(&CleanOriginal);
+  if (EFI_ERROR(Status)) {
+    SHELL_FREE_NON_NULL(CleanOriginal);
+    return (Status);
+  }
+  //
+  // We dont do normal processing with a split command line (output from one command input to another)
+  //
+  if (ContainsSplit(CleanOriginal)) {
+    Status = ProcessNewSplitCommandLine(CleanOriginal);
+    SHELL_FREE_NON_NULL(CleanOriginal);
+    return (Status);
+  }
+  //
+  // We need the first parameter information so we can determine the operation type
+  //
+  FirstParameter = AllocateZeroPool(StrSize(CleanOriginal));
+  if (FirstParameter == NULL) {
+    SHELL_FREE_NON_NULL(CleanOriginal);
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  TempWalker = CleanOriginal;
+  if (!EFI_ERROR(GetNextParameter(&TempWalker, &FirstParameter, StrSize(CleanOriginal)))) {
+    //
+    // Depending on the first parameter we change the behavior
+    //
+    switch (Type = GetOperationType(FirstParameter)) {
+      case   File_Sys_Change:
+        Status = ChangeMappedDrive (FirstParameter);
+        break;
+      case   Internal_Command:
+      case   Script_File_Name:
+      case   Efi_Application:
+        Status = SetupAndRunCommandOrFile(Type, CleanOriginal, FirstParameter, ShellInfoObject.NewShellParametersProtocol);
+        break;
+      default:
+        //
+        // Whatever was typed, it was invalid.
+        //
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);
+        SetLastError(SHELL_NOT_FOUND);
+        break;
+    }
   } else {
+    StrnCatGrow(&CommandName, NULL, CleanOriginal, StrStr(CleanOriginal, L" ") - CleanOriginal);
+  }
+  ASSERT(PostAliasCmdLine == NULL);
+  if (!ShellCommandIsCommandOnList(CommandName)) {
+    //
+    // Convert via alias
+    //
+    Status = ShellConvertAlias(&CommandName);
+    PostAliasSize = 0;
+    PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, &PostAliasSize, CommandName, 0);
+    PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, &PostAliasSize, StrStr(CleanOriginal, L" "), 0);
+    ASSERT_EFI_ERROR(Status);
+  } else {
+    PostAliasCmdLine = StrnCatGrow(&PostAliasCmdLine, NULL, CleanOriginal, 0);
+  }
+  if (CleanOriginal != NULL) {
+    FreePool(CleanOriginal);
+    CleanOriginal = NULL;
+  }
+  if (CommandName != NULL) {
+    FreePool(CommandName);
+    CommandName = NULL;
+  }
+  PostVariableCmdLine = ShellConvertVariables(PostAliasCmdLine);
+  //
+  // we can now free the modified by alias command line
+  //
+  if (PostAliasCmdLine != NULL) {
+    FreePool(PostAliasCmdLine);
+    PostAliasCmdLine = NULL;
+  }
+  if (PostVariableCmdLine == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  while (PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] == L' ') {
+    PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] = CHAR_NULL;
+  }
+  while (PostVariableCmdLine[0] == L' ') {
+    CopyMem(PostVariableCmdLine, PostVariableCmdLine+1, StrSize(PostVariableCmdLine) - sizeof(PostVariableCmdLine[0]));
+  }
+  //
+  // We dont do normal processing with a split command line (output from one command input to another)
+  //
+  TempLocation3 = NULL;
+  if (StrStr(PostVariableCmdLine, L"|") != NULL) {
+    for (TempLocation3 = PostVariableCmdLine ; TempLocation3 != NULL && *TempLocation3 != CHAR_NULL ; TempLocation3++) {
+      if (*TempLocation3 == L'^' && *(TempLocation3+1) == L'|') {
+        TempLocation3++;
+      } else if (*TempLocation3 == L'|') {
+        break;
+      }
+    }
+  }
+  if (TempLocation3 != NULL && *TempLocation3 != CHAR_NULL) {
+    //
+    // are we in an existing split???
+    //
+    if (!IsListEmpty(&ShellInfoObject.SplitList.Link)) {
+      Split = (SPLIT_LIST*)GetFirstNode(&ShellInfoObject.SplitList.Link);
+    }
+    if (Split == NULL) {
+      Status = RunSplitCommand(PostVariableCmdLine, NULL, NULL);
+    } else {
+      Status = RunSplitCommand(PostVariableCmdLine, Split->SplitStdIn, Split->SplitStdOut);
+    }
+  } else {
+    //
+    // If this is a mapped drive change handle that...
+    //
+    if (PostVariableCmdLine[(StrLen(PostVariableCmdLine)-1)] == L':' && StrStr(PostVariableCmdLine, L" ") == NULL) {
+      Status = ShellInfoObject.NewEfiShellProtocol->SetCurDir(NULL, PostVariableCmdLine);
+      if (EFI_ERROR(Status)) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_MAPPING), ShellInfoObject.HiiHandle, PostVariableCmdLine);
+      }
+      FreePool(PostVariableCmdLine);
+      return (Status);
+    }
+    ///@todo update this section to divide into 3 ways - run internal command, run split (above), and run an external file...
+    ///      We waste a lot of time doing processing like StdIn,StdOut,Argv,Argc for things that are external files...
+    Status = UpdateStdInStdOutStdErr(ShellInfoObject.NewShellParametersProtocol, PostVariableCmdLine, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
+    if (EFI_ERROR(Status)) {
+      if (Status == EFI_NOT_FOUND) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_REDUNDA_REDIR), ShellInfoObject.HiiHandle);
+      } else {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_REDIR), ShellInfoObject.HiiHandle);
+      }
+    } else {
+      while (PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] == L' ') {
+        PostVariableCmdLine[StrLen(PostVariableCmdLine)-1] = CHAR_NULL;
+      }
+      while (PostVariableCmdLine[0] == L' ') {
+        CopyMem(PostVariableCmdLine, PostVariableCmdLine+1, StrSize(PostVariableCmdLine) - sizeof(PostVariableCmdLine[0]));
+      }
+      //
+      // get the argc and argv updated for internal commands
+      //
+      Status = UpdateArgcArgv(ShellInfoObject.NewShellParametersProtocol, PostVariableCmdLine, &Argv, &Argc);
+      ASSERT_EFI_ERROR(Status);
+      for (Count = 0 ; Count < ShellInfoObject.NewShellParametersProtocol->Argc ; Count++) {
+        if (StrStr(ShellInfoObject.NewShellParametersProtocol->Argv[Count], L"-?") == ShellInfoObject.NewShellParametersProtocol->Argv[Count]
+        ||  (ShellInfoObject.NewShellParametersProtocol->Argv[0][0] == L'?' && ShellInfoObject.NewShellParametersProtocol->Argv[0][1] == CHAR_NULL)
+          ) {
+          //
+          // We need to redo the arguments since a parameter was -?
+          // move them all down 1 to the end, then up one then replace the first with help
+          //
+          FreePool(ShellInfoObject.NewShellParametersProtocol->Argv[Count]);
+          ShellInfoObject.NewShellParametersProtocol->Argv[Count] = NULL;
+          for (Count2 = Count ; (Count2 + 1) < ShellInfoObject.NewShellParametersProtocol->Argc ; Count2++) {
+            ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = ShellInfoObject.NewShellParametersProtocol->Argv[Count2+1];
+          }
+          ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = NULL;
+          for (Count2 = ShellInfoObject.NewShellParametersProtocol->Argc -1 ; Count2 > 0 ; Count2--) {
+            ShellInfoObject.NewShellParametersProtocol->Argv[Count2] = ShellInfoObject.NewShellParametersProtocol->Argv[Count2-1];
+          }
+          ShellInfoObject.NewShellParametersProtocol->Argv[0] = NULL;
+          ShellInfoObject.NewShellParametersProtocol->Argv[0] = StrnCatGrow(&ShellInfoObject.NewShellParametersProtocol->Argv[0], NULL, L"help", 0);
+          break;
+        }
+      }
+      //
+      // command or file?
+      //
+      if (ShellCommandIsCommandOnList(ShellInfoObject.NewShellParametersProtocol->Argv[0])) {
+        //
+        // Run the command (which was converted if it was an alias)
+        //
+        if (!EFI_ERROR(Status))  {
+          Status = ShellCommandRunCommandHandler(ShellInfoObject.NewShellParametersProtocol->Argv[0], &ShellStatus, &LastError);
+          ASSERT_EFI_ERROR(Status);
+          UnicodeSPrint(LeString, sizeof(LeString)*sizeof(LeString[0]), L"0x%08x", ShellStatus);
+          DEBUG_CODE(InternalEfiShellSetEnv(L"DebugLasterror", LeString, TRUE););
+          if (LastError) {
+            InternalEfiShellSetEnv(L"Lasterror", LeString, TRUE);
+          }
+          //
+          // Pass thru the exitcode from the app.
+          //
+          if (ShellCommandGetExit()) {
+            Status = ShellStatus;
+          } else if (ShellStatus != 0 && IsScriptOnlyCommand(ShellInfoObject.NewShellParametersProtocol->Argv[0])) {
+            Status = EFI_ABORTED;
+          }
+        }
+      } else {
+        //
+        // run an external file (or script)
+        //
+        if (StrStr(ShellInfoObject.NewShellParametersProtocol->Argv[0], L":") != NULL) {
+          ASSERT (CommandWithPath == NULL);
+          if (ShellIsFile(ShellInfoObject.NewShellParametersProtocol->Argv[0]) == EFI_SUCCESS) {
+            CommandWithPath = StrnCatGrow(&CommandWithPath, NULL, ShellInfoObject.NewShellParametersProtocol->Argv[0], 0);
+          }
+        }
+        if (CommandWithPath == NULL) {
+          CommandWithPath = ShellFindFilePathEx(ShellInfoObject.NewShellParametersProtocol->Argv[0], mExecutableExtensions);
+        }
+        if (CommandWithPath == NULL || ShellIsDirectory(CommandWithPath) == EFI_SUCCESS) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, ShellInfoObject.NewShellParametersProtocol->Argv[0]);
+        } else {
+          //
+          // Check if it's a NSH (script) file.
+          //
+          TempLocation = CommandWithPath+StrLen(CommandWithPath)-4;
+          TempLocation2 = mScriptExtension;
+          if ((StrLen(CommandWithPath) > 4) && (StringNoCaseCompare((VOID*)(&TempLocation), (VOID*)(&TempLocation2)) == 0)) {
+            Status = RunScriptFile (CommandWithPath);
+          } else {
+            DevPath = ShellInfoObject.NewEfiShellProtocol->GetDevicePathFromFilePath(CommandWithPath);
+            ASSERT(DevPath != NULL);
+            Status = InternalShellExecuteDevicePath(
+              &gImageHandle,
+              DevPath,
+              PostVariableCmdLine,
+              NULL,
+              NULL
+             );
+          }
+        }
+      }
+      CommandName = StrnCatGrow(&CommandName, NULL, ShellInfoObject.NewShellParametersProtocol->Argv[0], 0);
+      RestoreArgcArgv(ShellInfoObject.NewShellParametersProtocol, &Argv, &Argc);
+      RestoreStdInStdOutStdErr(ShellInfoObject.NewShellParametersProtocol, &OriginalStdIn, &OriginalStdOut, &OriginalStdErr, &OriginalSystemTableInfo);
+    }
+    if (CommandName != NULL) {
+      if (ShellCommandGetCurrentScriptFile() != NULL &&  !IsScriptOnlyCommand(CommandName)) {
+        //
+        // if this is NOT a scipt only command return success so the script won't quit.
+        // prevent killing the script - this is the only place where we know the actual command name (after alias and variable replacement...)
+        //
+        Status = EFI_SUCCESS;
+      }
+    }
+  }
+  SHELL_FREE_NON_NULL(CommandName);
+  SHELL_FREE_NON_NULL(CommandWithPath);
+  SHELL_FREE_NON_NULL(PostVariableCmdLine);
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_NOT_FOUND), ShellInfoObject.HiiHandle, FirstParameter);
+    SetLastError(SHELL_NOT_FOUND);
+  }
+  SHELL_FREE_NON_NULL(CleanOriginal);
+  SHELL_FREE_NON_NULL(FirstParameter);
   return (Status);
 …
     CommandLine = ShellFileHandleReturnLine(Handle, &Ascii);
     LineCount++;
+    if (CommandLine == NULL || StrLen(CommandLine) == 0) {
+    if (CommandLine == NULL || StrLen(CommandLine) == 0 || CommandLine[0] == '#') {
+      SHELL_FREE_NON_NULL(CommandLine);
       continue;
+    }
     NewScriptFile->CurrentCommand = AllocateZeroPool(sizeof(SCRIPT_COMMAND_LIST));
     if (NewScriptFile->CurrentCommand == NULL) {
+      SHELL_FREE_NON_NULL(CommandLine);
       DeleteScriptFileStruct(NewScriptFile);
       return (EFI_OUT_OF_RESOURCES);
 …
   ){
     ASSERT(CommandLine2 != NULL);
     StrCpy(CommandLine2, NewScriptFile->CurrentCommand->Cl);
+    StrnCpy(CommandLine2, NewScriptFile->CurrentCommand->Cl, PcdGet16(PcdShellPrintBufferSize)/sizeof(CHAR16)-1);
     //
 …
     for (CommandLine3 = CommandLine2 ; CommandLine3 != NULL && *CommandLine3 != CHAR_NULL ; CommandLine3++) {
       if (*CommandLine3 == L'^') {
         if (*(CommandLine3+1) == L'#' || *(CommandLine3+1) == L':') {
+        if ( *(CommandLine3+1) == L':') {
           CopyMem(CommandLine3, CommandLine3+1, StrSize(CommandLine3) - sizeof(CommandLine3[0]));
+        } else if (*(CommandLine3+1) == L'#') {
+          CommandLine3++;
+        }
       } else if (*CommandLine3 == L'#') {
 …
       // Due to variability in starting the find and replace action we need to have both buffers the same.
       //
       StrCpy(CommandLine, CommandLine2);
+      StrnCpy(CommandLine, CommandLine2, PcdGet16(PcdShellPrintBufferSize)/sizeof(CHAR16)-1);
       //
 …
       Status = ShellCopySearchAndReplace(CommandLine2,  CommandLine, PcdGet16 (PcdShellPrintBufferSize), L"%9", L"\"\"", FALSE, FALSE);
       StrCpy(CommandLine2, CommandLine);
+      StrnCpy(CommandLine2, CommandLine, PcdGet16(PcdShellPrintBufferSize)/sizeof(CHAR16)-1);
       LastCommand = NewScriptFile->CurrentCommand;
 …
             //
             // Now restore the pre-'@' echo state.
+            // If command was "@echo -off" or "@echo -on" then don't restore echo state
             //
+            ShellCommandSetEchoState(PreCommandEchoState);
+            if (StrCmp (L"@echo -off", CommandLine3) != 0 &&
+                StrCmp (L"@echo -on", CommandLine3) != 0) {
+              //
+              // Now restore the pre-'@' echo state.
+              //
+              ShellCommandSetEchoState(PreCommandEchoState);
+            }
           } else {
             if (ShellCommandGetEchoState()) {
 …
         if (ShellCommandGetScriptExit()) {
+          UnicodeSPrint(LeString, sizeof(LeString)*sizeof(LeString[0]), L"0x%Lx", ShellCommandGetExitCode());
+          DEBUG_CODE(InternalEfiShellSetEnv(L"DebugLasterror", LeString, TRUE););
+          InternalEfiShellSetEnv(L"Lasterror", LeString, TRUE);
+          //
+          // ShellCommandGetExitCode() always returns a UINT64
+          //
+          UnicodeSPrint(LeString, sizeof(LeString), L"0x%Lx", ShellCommandGetExitCode());
+          DEBUG_CODE(InternalEfiShellSetEnv(L"debuglasterror", LeString, TRUE););
+          InternalEfiShellSetEnv(L"lasterror", LeString, TRUE);
           ShellCommandRegisterExit(FALSE, 0);
           Status = EFI_SUCCESS;
+          break;
+        }
+        if (ShellGetExecutionBreakFlag()) {
           break;
+        }
 …
   @param[in] ScriptPath         Pointer to the script file name (including file system path).
+  @param[in] Handle             the handle of the script file already opened.
+  @param[in] CmdLine            the command line to run.
+  @param[in] ParamProtocol      the shell parameters protocol pointer
   @retval EFI_SUCCESS           the script completed sucessfully
 …
 EFIAPI
 RunScriptFile (
+  IN CONST CHAR16 *ScriptPath
+  IN CONST CHAR16                   *ScriptPath,
+  IN SHELL_FILE_HANDLE              Handle OPTIONAL,
+  IN CONST CHAR16                   *CmdLine,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
+  )
+{
   EFI_STATUS          Status;
   SHELL_FILE_HANDLE   FileHandle;
+  UINTN                     Argc;
+  CHAR16                    **Argv;
   if (ShellIsFile(ScriptPath) != EFI_SUCCESS) {
 …
+  }
+  Status = ShellOpenFileByName(ScriptPath, &FileHandle, EFI_FILE_MODE_READ, 0);
+  if (EFI_ERROR(Status)) {
+    return (Status);
+  }
+  Status = RunScriptFileHandle(FileHandle, ScriptPath);
+  ShellCloseFile(&FileHandle);
+  //
+  // get the argc and argv updated for scripts
+  //
+  Status = UpdateArgcArgv(ParamProtocol, CmdLine, &Argv, &Argc);
+  if (!EFI_ERROR(Status)) {
+    if (Handle == NULL) {
+      //
+      // open the file
+      //
+      Status = ShellOpenFileByName(ScriptPath, &FileHandle, EFI_FILE_MODE_READ, 0);
+      if (!EFI_ERROR(Status)) {
+        //
+        // run it
+        //
+        Status = RunScriptFileHandle(FileHandle, ScriptPath);
+        //
+        // now close the file
+        //
+        ShellCloseFile(&FileHandle);
+      }
+    } else {
+      Status = RunScriptFileHandle(Handle, ScriptPath);
+    }
+  }
+  //
+  // This is guarenteed to be called after UpdateArgcArgv no matter what else happened.
+  // This is safe even if the update API failed.  In this case, it may be a no-op.
+  //
+  RestoreArgcArgv(ParamProtocol, &Argv, &Argc);
   return (Status);
+}
+/**
+  Return the pointer to the first occurance of any character from a list of characters
+  @param[in] String           the string to parse
+  @param[in] CharacterList    the list of character to look for
+  @param[in] EscapeCharacter  An escape character to skip
+  @return the location of the first character in the string
+  @retval CHAR_NULL no instance of any character in CharacterList was found in String
+**/
+CONST CHAR16*
+EFIAPI
+FindFirstCharacter(
+  IN CONST CHAR16 *String,
+  IN CONST CHAR16 *CharacterList,
+  IN CONST CHAR16 EscapeCharacter
+  )
+{
+  UINT32 WalkChar;
+  UINT32 WalkStr;
+  for (WalkStr = 0; WalkStr < StrLen(String); WalkStr++) {
+    if (String[WalkStr] == EscapeCharacter) {
+      WalkStr++;
+      continue;
+    }
+    for (WalkChar = 0; WalkChar < StrLen(CharacterList); WalkChar++) {
+      if (String[WalkStr] == CharacterList[WalkChar]) {
+        return (&String[WalkStr]);
+      }
+    }
+  }
+  return (String + StrLen(String));
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/Shell.h

-              r48674
+              r58459
   function definitions for internal to shell functions.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Guid/ShellVariableGuid.h>
+#include <Guid/ShellAliasGuid.h>
 #include <Protocol/LoadedImage.h>
 …
 #include <Library/HandleParsingLib.h>
 #include <Library/PathLib.h>
+#include <Library/FileHandleLib.h>
 #include "ShellParametersProtocol.h"
 …
 #include "ShellManParser.h"
 #include "ConsoleWrappers.h"
+#include "FileHandleWrappers.h"
 typedef struct {
 …
   UINT32  NoVersion:1;    ///< Was "-noversion"     found on command line.
   UINT32  Delay:1;        ///< Was "-delay[:n]      found on command line
+  UINT32  Reserved:8;     ///< Extra bits
+  UINT32  Exit:1;         ///< Was "-_exit"          found on command line
+  UINT32  Reserved:7;     ///< Extra bits
 } SHELL_BITS;
 …
   SHELL_PROTOCOL_HANDLE_LIST    OldShellList;         ///< List of other instances to reinstall when closing.
   SPLIT_LIST                    SplitList;            ///< List of Splits in FILO stack.
   EFI_HANDLE                    CtrlCNotifyHandle1;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlCNotifyHandle2;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlCNotifyHandle3;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlCNotifyHandle4;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlSNotifyHandle1;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlSNotifyHandle2;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlSNotifyHandle3;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   EFI_HANDLE                    CtrlSNotifyHandle4;   ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlCNotifyHandle1;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlCNotifyHandle2;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlCNotifyHandle3;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlCNotifyHandle4;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlSNotifyHandle1;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlSNotifyHandle2;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlSNotifyHandle3;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
+  VOID                          *CtrlSNotifyHandle4;  ///< The NotifyHandle returned from SimpleTextInputEx.RegisterKeyNotify.
   BOOLEAN                       HaltOutput;           ///< TRUE to start a CTRL-S halt.
 } SHELL_INFO;
 extern SHELL_INFO ShellInfoObject;
+typedef enum {
+  Internal_Command,
+  Script_File_Name,
+  Efi_Application,
+  File_Sys_Change,
+  Unknown_Invalid
+} SHELL_OPERATION_TYPES;
+/**
+  Converts the command line to it's post-processed form.  this replaces variables and alias' per UEFI Shell spec.
+  @param[in,out] CmdLine        pointer to the command line to update
+  @retval EFI_SUCCESS           The operation was successful
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed.
+  @return                       some other error occured
+**/
+EFI_STATUS
+EFIAPI
+ProcessCommandLineToFinal(
+  IN OUT CHAR16 **CmdLine
+  );
+/**
+  Function to update the shell variable "lasterror".
+  @param[in] ErrorCode      the error code to put into lasterror
+**/
+EFI_STATUS
+EFIAPI
+SetLastError(
+  IN CONST SHELL_STATUS   ErrorCode
+  );
 /**
 …
   @param[in] ScriptPath         Pointer to the script file name (including file system path).
+  @param[in] Handle             the handle of the script file already opened.
+  @param[in] CmdLine            the command line to run.
+  @param[in] ParamProtocol      the shell parameters protocol pointer
   @retval EFI_SUCCESS           the script completed sucessfully
 …
 EFIAPI
 RunScriptFile (
+  IN CONST CHAR16 *ScriptPath
+  );
+  IN CONST CHAR16                   *ScriptPath,
+  IN SHELL_FILE_HANDLE              Handle OPTIONAL,
+  IN CONST CHAR16                   *CmdLine,
+  IN EFI_SHELL_PARAMETERS_PROTOCOL  *ParamProtocol
+  );
+/**
+  Return the pointer to the first occurance of any character from a list of characters
+  @param[in] String           the string to parse
+  @param[in] CharacterList    the list of character to look for
+  @param[in] EscapeCharacter  An escape character to skip
+  @return the location of the first character in the string
+  @retval CHAR_NULL no instance of any character in CharacterList was found in String
+**/
+CONST CHAR16*
+EFIAPI
+FindFirstCharacter(
+  IN CONST CHAR16 *String,
+  IN CONST CHAR16 *CharacterList,
+  IN CONST CHAR16 EscapeCharacter
+  );
 #endif //_SHELL_INTERNAL_HEADER_

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/Shell.inf

-              r48674
+              r58459
 #  This is the shell application
+#
+#  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+#  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
+#  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
+#
 #  This program and the accompanying materials
 …
 [Guids]
   gShellVariableGuid                                      # ALWAYS_CONSUMED
   gShellMapGuid                                           # ALWAYS_CONSUMED
   gShellAliasGuid                                         # ALWAYS_CONSUMED
+  gShellVariableGuid                                      ## CONSUMES ## GUID
+  gShellMapGuid                                           ## CONSUMES ## GUID
+  gShellAliasGuid                                         ## CONSUMES ## GUID
 [Protocols]
   gEfiShellProtocolGuid                                   # ALWAYS_PRODUCED
                                                           # SOMETIMES_CONSUMED
   gEfiShellParametersProtocolGuid                         # ALWAYS_PRODUCED
                                                           # SOMETIMES_CONSUMED
+  gEfiShellProtocolGuid                                   ## PRODUCES
+                                                          ## SOMETIMES_CONSUMES
+  gEfiShellParametersProtocolGuid                         ## PRODUCES
+                                                          ## SOMETIMES_CONSUMES
 #  gEfiShellEnvironment2Guid                               # SOMETIMES_PRODUCED
 #  gEfiShellInterfaceGuid                                  # SOMETIMES_PRODUCED
+#  gEfiShellEnvironment2Guid                              ## SOMETIMES_PRODUCES
+#  gEfiShellInterfaceGuid                                 ## SOMETIMES_PRODUCES
+  gEfiSimpleTextInputExProtocolGuid                       # ALWAYS_CONSUMED
+  gEfiSimpleTextInProtocolGuid                            # ALWAYS_CONSUMED
+  gEfiSimpleTextOutProtocolGuid                           # ALWAYS_CONSUMED
+  gEfiSimpleFileSystemProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiLoadedImageProtocolGuid                             # ALWAYS_CONSUMED
+  gEfiComponentName2ProtocolGuid                          # ALWAYS_CONSUMED
+  gEfiUnicodeCollation2ProtocolGuid                       # ALWAYS_CONSUMED
+  gEfiDevicePathProtocolGuid                              # ALWAYS_CONSUMED
+  gEfiDevicePathToTextProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiSimpleTextInputExProtocolGuid                       ## CONSUMES
+  gEfiSimpleTextInProtocolGuid                            ## CONSUMES
+  gEfiSimpleTextOutProtocolGuid                           ## CONSUMES
+  gEfiSimpleFileSystemProtocolGuid                        ## CONSUMES
+  gEfiLoadedImageProtocolGuid                             ## CONSUMES
+  gEfiComponentName2ProtocolGuid                          ## CONSUMES
+  gEfiUnicodeCollation2ProtocolGuid                       ## CONSUMES
+  gEfiDevicePathProtocolGuid                              ## CONSUMES
 [Pcd]
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportOldProtocols  # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellRequireHiiPlatform   # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportFrameworkHii  # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellPageBreakDefault     # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize    # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellInsertModeDefault    # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellScreenLogCount       # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellMapNameLength        # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize      # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellForceConsole         # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportOldProtocols  ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellRequireHiiPlatform   ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportFrameworkHii  ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellPageBreakDefault     ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize    ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellInsertModeDefault    ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellScreenLogCount       ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellMapNameLength        ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize      ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellForceConsole         ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupplier             ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellEnvVar.c

-              r48674
+              r58459
   function declarations for shell environment functions.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 **/
+#include <Uefi.h>
+#include <ShellBase.h>
+#include <Guid/ShellVariableGuid.h>
+#include <Library/BaseLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/DebugLib.h>
+#include <Library/BaseMemoryLib.h>
+#include "ShellEnvVar.h"
+#include "Shell.h"
+#define INIT_NAME_BUFFER_SIZE  128
+#define INIT_DATA_BUFFER_SIZE  1024
 /**
 …
   for ( Node = (ENV_VAR_LIST*)GetFirstNode(List)
       ; IsListEmpty(List)
+      ; !IsListEmpty(List)
       ; Node = (ENV_VAR_LIST*)GetFirstNode(List)
      ){
 …
   CHAR16            *VariableName;
   UINTN             NameSize;
+  UINT64            MaxStorSize;
+  UINT64            RemStorSize;
+  UINT64            MaxVarSize;
+  UINTN             NameBufferSize;
   EFI_STATUS        Status;
   EFI_GUID          Guid;
   UINTN             ValSize;
+  UINTN             ValBufferSize;
   ENV_VAR_LIST      *VarList;
 …
     return (EFI_INVALID_PARAMETER);
+  }
+  if (gRT->Hdr.Revision >= EFI_2_00_SYSTEM_TABLE_REVISION) {
+    Status = gRT->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS, &MaxStorSize, &RemStorSize, &MaxVarSize);
+    if (EFI_ERROR(Status)) {
+      return (Status);
+    }
+  } else {
+    Status = EFI_SUCCESS;
+    MaxVarSize = 16384;
+  }
+  NameSize = (UINTN)MaxVarSize;
+  VariableName = AllocateZeroPool(NameSize);
+  Status = EFI_SUCCESS;
+  ValBufferSize = INIT_DATA_BUFFER_SIZE;
+  NameBufferSize = INIT_NAME_BUFFER_SIZE;
+  VariableName = AllocateZeroPool(NameBufferSize);
   if (VariableName == NULL) {
     return (EFI_OUT_OF_RESOURCES);
+  }
   StrCpy(VariableName, L"");
+  *VariableName = CHAR_NULL;
   while (!EFI_ERROR(Status)) {
     NameSize = (UINTN)MaxVarSize;
+    NameSize = NameBufferSize;
     Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
     if (Status == EFI_NOT_FOUND){
       Status = EFI_SUCCESS;
       break;
+    }
+    } else if (Status == EFI_BUFFER_TOO_SMALL) {
+      NameBufferSize = NameSize > NameBufferSize * 2 ? NameSize : NameBufferSize * 2;
+      SHELL_FREE_NON_NULL(VariableName);
+      VariableName = AllocateZeroPool(NameBufferSize);
+      if (VariableName == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        break;
+      }
+      NameSize = NameBufferSize;
+      Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
+    }
     if (!EFI_ERROR(Status) && CompareGuid(&Guid, &gShellVariableGuid)){
       VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
 …
         Status = EFI_OUT_OF_RESOURCES;
       } else {
+        ValSize = 0;
+        ValSize = ValBufferSize;
+        VarList->Val = AllocateZeroPool(ValSize);
+        if (VarList->Val == NULL) {
+            SHELL_FREE_NON_NULL(VarList);
+            Status = EFI_OUT_OF_RESOURCES;
+            break;
+        }
         Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
         if (Status == EFI_BUFFER_TOO_SMALL){
+          VarList->Val = AllocateZeroPool(ValSize);
+          ValBufferSize = ValSize > ValBufferSize * 2 ? ValSize : ValBufferSize * 2;
+          SHELL_FREE_NON_NULL (VarList->Val);
+          VarList->Val = AllocateZeroPool(ValBufferSize);
           if (VarList->Val == NULL) {
             SHELL_FREE_NON_NULL(VarList);
             Status = EFI_OUT_OF_RESOURCES;
+          } else {
+            Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
+            break;
+          }
+          ValSize = ValBufferSize;
+          Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(VariableName, &VarList->Atts, &ValSize, VarList->Val);
+        }
         if (!EFI_ERROR(Status) && VarList != NULL) {
           VarList->Key = AllocateZeroPool(StrSize(VariableName));
+        if (!EFI_ERROR(Status)) {
+          VarList->Key = AllocateCopyPool(StrSize(VariableName), VariableName);
           if (VarList->Key == NULL) {
             SHELL_FREE_NON_NULL(VarList->Val);
 …
             Status = EFI_OUT_OF_RESOURCES;
           } else {
-            StrCpy(VarList->Key, VariableName);
             InsertTailList(ListHead, &VarList->Link);
+          }
+        } else {
+          SHELL_FREE_NON_NULL(VarList->Val);
+          SHELL_FREE_NON_NULL(VarList);
+        }
+      }
+      } // if (VarList == NULL) ... else ...
     } // compare guid
   } // while
   FreePool(VariableName);
+  SHELL_FREE_NON_NULL (VariableName);
   if (EFI_ERROR(Status)) {
 …
   ENV_VAR_LIST  *VarList;
   ENV_VAR_LIST  *Node;
-  UINTN         NewSize;
   VarList = NULL;
 …
     ASSERT(StrStr(CurrentString, L"=") != NULL);
     Node = AllocateZeroPool(sizeof(ENV_VAR_LIST));
+    ASSERT(Node != NULL);
+    if (Node == NULL) {
+      SetEnvironmentVariableList(&VarList->Link);
+      return (EFI_OUT_OF_RESOURCES);
+    }
     Node->Key = AllocateZeroPool((StrStr(CurrentString, L"=") - CurrentString + 1) * sizeof(CHAR16));
+    ASSERT(Node->Key != NULL);
+    if (Node->Key == NULL) {
+      SHELL_FREE_NON_NULL(Node);
+      SetEnvironmentVariableList(&VarList->Link);
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    //
+    // Copy the string into the Key, leaving the last character allocated as NULL to terminate
+    //
     StrnCpy(Node->Key, CurrentString, StrStr(CurrentString, L"=") - CurrentString);
+    NewSize = StrSize(CurrentString);
+    NewSize -= StrLen(Node->Key) - 1;
+    Node->Val = AllocateZeroPool(NewSize);
+    ASSERT(Node->Val != NULL);
+    StrCpy(Node->Val, CurrentString + StrLen(Node->Key) + 1);
+    //
+    // ValueSize = TotalSize - already removed size - size for '=' + size for terminator (the last 2 items cancel each other)
+    //
+    Node->Val = AllocateCopyPool(StrSize(CurrentString) - StrSize(Node->Key), CurrentString + StrLen(Node->Key) + 1);
+    if (Node->Val == NULL) {
+      SHELL_FREE_NON_NULL(Node->Key);
+      SHELL_FREE_NON_NULL(Node);
+      SetEnvironmentVariableList(&VarList->Link);
+      return (EFI_OUT_OF_RESOURCES);
+    }
     Node->Atts = EFI_VARIABLE_BOOTSERVICE_ACCESS;
     if (VarList == NULL) {
       VarList = AllocateZeroPool(sizeof(ENV_VAR_LIST));
+      ASSERT(VarList != NULL);
+      if (VarList == NULL) {
+        SHELL_FREE_NON_NULL(Node->Key);
+        SHELL_FREE_NON_NULL(Node->Val);
+        SHELL_FREE_NON_NULL(Node);
+        return (EFI_OUT_OF_RESOURCES);
+      }
       InitializeListHead(&VarList->Link);
+    }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellManParser.c

-              r48674
+              r58459
   Provides interface to shell MAN file parser.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   //
   if (StrnCmp(ManFileName+StrLen(ManFileName)-4, L".man", 4)==0) {
+    Buffer = AllocateZeroPool(StrSize(ManFileName));
+    if (Buffer != NULL) {
+      StrCpy(Buffer, ManFileName);
+    }
+    Buffer = AllocateCopyPool(StrSize(ManFileName), ManFileName);
   } else {
     Buffer = AllocateZeroPool(StrSize(ManFileName) + 4*sizeof(CHAR16));
     if (Buffer != NULL) {
       StrCpy(Buffer, ManFileName);
       StrCat(Buffer, L".man");
+      StrnCpy(Buffer, ManFileName, StrLen(ManFileName));
+      StrnCat(Buffer, L".man", 4);
+    }
+  }
 …
   CHAR16        *TitleEnd;
   CHAR16        *CurrentLocation;
+  UINTN         TitleLength;
+  CONST CHAR16  StartString[] = L".TH ";
+  CONST CHAR16  EndString[]   = L" 0 ";
   if ( Buffer     == NULL
 …
   Status    = EFI_SUCCESS;
+  TitleString = AllocateZeroPool((7*sizeof(CHAR16)) + StrSize(Command));
+  //
+  // more characters for StartString and EndString
+  //
+  TitleLength = StrSize(Command) + (StrLen(StartString) + StrLen(EndString)) * sizeof(CHAR16);
+  TitleString = AllocateZeroPool(TitleLength);
   if (TitleString == NULL) {
     return (EFI_OUT_OF_RESOURCES);
+  }
   StrCpy(TitleString, L".TH ");
   StrCat(TitleString, Command);
   StrCat(TitleString, L" 0 ");
+  StrnCpy(TitleString, StartString, TitleLength/sizeof(CHAR16) - 1);
+  StrnCat(TitleString, Command,     TitleLength/sizeof(CHAR16) - 1 - StrLen(TitleString));
+  StrnCat(TitleString, EndString,   TitleLength/sizeof(CHAR16) - 1 - StrLen(TitleString));
   CurrentLocation = StrStr(*Buffer, TitleString);
 …
   UINTN       TitleLen;
   BOOLEAN     Found;
+  UINTN       TitleSize;
   if ( Handle     == NULL
 …
+  }
+  TitleString = AllocateZeroPool((4*sizeof(CHAR16)) + StrSize(Command));
+  TitleSize = (4*sizeof(CHAR16)) + StrSize(Command);
+  TitleString = AllocateZeroPool(TitleSize);
   if (TitleString == NULL) {
     FreePool(ReadLine);
     return (EFI_OUT_OF_RESOURCES);
+  }
+  StrCpy(TitleString, L".TH ");
+  StrCat(TitleString, Command);
+  StrnCpy(TitleString, L".TH ", TitleSize/sizeof(CHAR16) - 1);
+  StrnCat(TitleString, Command, TitleSize/sizeof(CHAR16) - 1 - StrLen(TitleString));
   TitleLen = StrLen(TitleString);
   for (;!ShellFileHandleEof(Handle);Size = 1024) {
 …
           break;
+        }
         StrCpy(*BriefDesc, TitleEnd);
+        StrnCpy(*BriefDesc, TitleEnd, (*BriefSize)/sizeof(CHAR16) - 1);
+      }
       break;
 …
   BriefSize   = 0;
   TempString  = NULL;
+  Ascii       = FALSE;
   //
   // See if it's in HII first

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellParametersProtocol.c

-              r48674
+              r58459
   manipulation, and initialization of EFI_SHELL_PARAMETERS_PROTOCOL.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (C) 2014, Red Hat, Inc.
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 **/
+#include "ShellParametersProtocol.h"
+#include "ConsoleWrappers.h"
+/**
+  return the next parameter from a command line string;
+#include "Shell.h"
+/**
+  Return the next parameter's end from a command line string.
+  @param[in] String        the string to parse
+**/
+CONST CHAR16*
+EFIAPI
+FindEndOfParameter(
+  IN CONST CHAR16 *String
+  )
+{
+  CONST CHAR16 *First;
+  CONST CHAR16 *CloseQuote;
+  First = FindFirstCharacter(String, L" \"", L'^');
+  //
+  // nothing, all one parameter remaining
+  //
+  if (*First == CHAR_NULL) {
+    return (First);
+  }
+  //
+  // If space before a quote (or neither found, i.e. both CHAR_NULL),
+  // then that's the end.
+  //
+  if (*First == L' ') {
+    return (First);
+  }
+  CloseQuote = FindFirstCharacter (First+1, L"\"", L'^');
+  //
+  // We did not find a terminator...
+  //
+  if (*CloseQuote == CHAR_NULL) {
+    return (NULL);
+  }
+  return (FindEndOfParameter (CloseQuote+1));
+}
+/**
+  Return the next parameter from a command line string.
   This function moves the next parameter from Walker into TempParameter and moves
 …
   function.
+  This will also remove all remaining ^ characters after processing.
   @param[in, out] Walker        pointer to string of command line.  Adjusted to
                                 reminaing command line on return
   @param[in, out] TempParameter pointer to string of command line item extracted.
+**/
+VOID
+  @param[in]      Length        buffer size of TempParameter.
+  @return   EFI_INALID_PARAMETER  A required parameter was NULL or pointed to a NULL or empty string.
+  @return   EFI_NOT_FOUND         A closing " could not be found on the specified string
+**/
+EFI_STATUS
 EFIAPI
 GetNextParameter(
+  CHAR16 **Walker,
+  CHAR16 **TempParameter
+  )
+{
+  CHAR16 *NextDelim;
+  CHAR16 *TempLoc;
+  ASSERT(Walker           != NULL);
+  ASSERT(*Walker          != NULL);
+  ASSERT(TempParameter    != NULL);
+  ASSERT(*TempParameter   != NULL);
+  IN OUT CHAR16   **Walker,
+  IN OUT CHAR16   **TempParameter,
+  IN CONST UINTN  Length
+  )
+{
+  CONST CHAR16 *NextDelim;
+  if (Walker           == NULL
+    ||*Walker          == NULL
+    ||TempParameter    == NULL
+    ||*TempParameter   == NULL
+    ){
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
   //
   if (StrLen(*Walker) == 0) {
+    ASSERT((*Walker)[0] == CHAR_NULL);
+    *Walker = NULL;
+    return;
+  }
+  //
+  // we have a quoted parameter
+  // could be the last parameter, but SHOULD have a trailing quote
+  //
+  if ((*Walker)[0] == L'\"') {
+    NextDelim = NULL;
+    for (TempLoc = *Walker + 1 ; TempLoc != NULL && *TempLoc != CHAR_NULL ; TempLoc++) {
+      if (*TempLoc == L'^' && *(TempLoc+1) == L'\"') {
+        TempLoc++;
+      } else if (*TempLoc == L'\"') {
+        NextDelim = TempLoc;
+        break;
+      }
+    }
+    if (NextDelim - ((*Walker)+1) == 0) {
+      //
+      // found ""
+      //
+      StrCpy(*TempParameter, L"");
+      *Walker = NextDelim + 1;
+    } else if (NextDelim != NULL) {
+      StrnCpy(*TempParameter, (*Walker)+1, NextDelim - ((*Walker)+1));
+      *Walker = NextDelim + 1;
+    } else {
+      //
+      // last one... someone forgot the training quote!
+      //
+      StrCpy(*TempParameter, *Walker);
+      *Walker = NULL;
+    }
+    for (TempLoc = *TempParameter ; TempLoc != NULL && *TempLoc != CHAR_NULL ; TempLoc++) {
+      if (*TempLoc == L'^' && *(TempLoc+1) == L'\"') {
+        CopyMem(TempLoc, TempLoc+1, StrSize(TempLoc) - sizeof(TempLoc[0]));
+      }
+    }
+  } else {
+    //
+    // we have a regular parameter (no quote) OR
+    // we have the final parameter (no trailing space)
+    //
+    NextDelim = StrStr((*Walker), L" ");
+    if (NextDelim != NULL) {
+      StrnCpy(*TempParameter, *Walker, NextDelim - (*Walker));
+      (*TempParameter)[NextDelim - (*Walker)] = CHAR_NULL;
+      *Walker = NextDelim+1;
+    } else {
+      //
+      // last one.
+      //
+      StrCpy(*TempParameter, *Walker);
+      *Walker = NULL;
+    }
+    for (NextDelim = *TempParameter ; NextDelim != NULL && *NextDelim != CHAR_NULL ; NextDelim++) {
+      if (*NextDelim == L'^' && *(NextDelim+1) == L'^') {
+        CopyMem(NextDelim, NextDelim+1, StrSize(NextDelim) - sizeof(NextDelim[0]));
+      }
+    }
+    while ((*TempParameter)[StrLen(*TempParameter)-1] == L' ') {
+      (*TempParameter)[StrLen(*TempParameter)-1] = CHAR_NULL;
+    }
+    while ((*TempParameter)[0] == L' ') {
+      CopyMem(*TempParameter, (*TempParameter)+1, StrSize(*TempParameter) - sizeof((*TempParameter)[0]));
+    }
+  }
+  return;
+DEBUG_CODE_BEGIN();
+    *Walker        = NULL;
+DEBUG_CODE_END();
+    return (EFI_INVALID_PARAMETER);
+  }
+  NextDelim = FindEndOfParameter(*Walker);
+  if (NextDelim == NULL){
+DEBUG_CODE_BEGIN();
+    *Walker        = NULL;
+DEBUG_CODE_END();
+    return (EFI_NOT_FOUND);
+  }
+  StrnCpy(*TempParameter, (*Walker), NextDelim - *Walker);
+  //
+  // Add a CHAR_NULL if we didnt get one via the copy
+  //
+  if (*NextDelim != CHAR_NULL) {
+    (*TempParameter)[NextDelim - *Walker] = CHAR_NULL;
+  }
+  //
+  // Update Walker for the next iteration through the function
+  //
+  *Walker = (CHAR16*)NextDelim;
+  //
+  // Remove any non-escaped quotes in the string
+  // Remove any remaining escape characters in the string
+  //
+  for (NextDelim = FindFirstCharacter(*TempParameter, L"\"^", CHAR_NULL)
+    ; *NextDelim != CHAR_NULL
+    ; NextDelim = FindFirstCharacter(NextDelim, L"\"^", CHAR_NULL)
+    ) {
+    if (*NextDelim == L'^') {
+      //
+      // eliminate the escape ^
+      //
+      CopyMem ((CHAR16*)NextDelim, NextDelim + 1, StrSize (NextDelim + 1));
+      NextDelim++;
+    } else if (*NextDelim == L'\"') {
+      //
+      // eliminate the unescaped quote
+      //
+      CopyMem ((CHAR16*)NextDelim, NextDelim + 1, StrSize (NextDelim + 1));
+    }
+  }
+  return EFI_SUCCESS;
+}
 …
   parameters for inclusion in EFI_SHELL_PARAMETERS_PROTOCOL.  this supports space
   delimited and quote surrounded parameter definition.
+  All special character processing (alias, environment variable, redirection,
+  etc... must be complete before calling this API.
   @param[in] CommandLine         String of command line to parse
 …
       , Walker = (CHAR16*)CommandLine
       ; Walker != NULL && *Walker != CHAR_NULL
+      ; GetNextParameter(&Walker, &TempParameter)
+      , Count++
+     );
+/*  Count = 0;
+  Walker = (CHAR16*)CommandLine;
+  while(Walker != NULL) {
+    GetNextParameter(&Walker, &TempParameter);
+    Count++;
+  }
+*/
+      ; Count++
+      ) {
+    if (EFI_ERROR(GetNextParameter(&Walker, &TempParameter, Size))) {
+      break;
+    }
+  }
   //
   // lets allocate the pointer array
 …
   (*Argv) = AllocateZeroPool((Count)*sizeof(CHAR16*));
   if (*Argv == NULL) {
+    SHELL_FREE_NON_NULL(TempParameter);
     return (EFI_OUT_OF_RESOURCES);
+  }
 …
   while(Walker != NULL && *Walker != CHAR_NULL) {
     SetMem16(TempParameter, Size, CHAR_NULL);
+    GetNextParameter(&Walker, &TempParameter);
+    NewParam = AllocateZeroPool(StrSize(TempParameter));
+    ASSERT(NewParam != NULL);
+    StrCpy(NewParam, TempParameter);
+    if (EFI_ERROR(GetNextParameter(&Walker, &TempParameter, Size))) {
+      SHELL_FREE_NON_NULL(TempParameter);
+      return (EFI_INVALID_PARAMETER);
+    }
+    NewParam = AllocateCopyPool(StrSize(TempParameter), TempParameter);
+    if (NewParam == NULL){
+      SHELL_FREE_NON_NULL(TempParameter);
+      return (EFI_OUT_OF_RESOURCES);
+    }
     ((CHAR16**)(*Argv))[(*Argc)] = NewParam;
     (*Argc)++;
+  }
   ASSERT(Count >= (*Argc));
+  SHELL_FREE_NON_NULL(TempParameter);
   return (EFI_SUCCESS);
+}
 …
   // Build the full command line
   //
   Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);
+  Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, FullCommandLine);
   if (Status == EFI_BUFFER_TOO_SMALL) {
     FullCommandLine = AllocateZeroPool(Size + LoadedImage->LoadOptionsSize);
     Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, &FullCommandLine);
+    Status = SHELL_GET_ENVIRONMENT_VARIABLE(L"ShellOpt", &Size, FullCommandLine);
+  }
   if (Status == EFI_NOT_FOUND) {
 …
+  }
   if (FullCommandLine != NULL) {
+    if (LoadedImage->LoadOptionsSize != 0){
+      StrCpy(FullCommandLine, LoadedImage->LoadOptions);
+    }
+    CopyMem (FullCommandLine, LoadedImage->LoadOptions, LoadedImage->LoadOptionsSize);
     //
     // Populate Argc and Argv
 …
   } else {
     Copy = FileName;
+    while(Copy[0] == L' ') {
+      Copy++;
+    }
     if ((TempLocation = StrStr(Copy , L" ")) != NULL) {
       TempLocation[0] = CHAR_NULL;
 …
   return (Copy);
+}
+/**
+  Fix a string to only have the environment variable name, removing starting at the first space of whatever is quoted and removing the leading and trailing %.
+  @param[in]  FileName    The filename to start with.
+  @retval NULL  FileName was invalid.
+  @return       The modified FileName.
+**/
+CHAR16*
+EFIAPI
+FixVarName (
+  IN CHAR16 *FileName
+  )
+{
+  CHAR16  *Copy;
+  CHAR16  *TempLocation;
+  Copy = FileName;
+  if (FileName[0] == L'%') {
+    Copy = FileName+1;
+    if ((TempLocation = StrStr(Copy , L"%")) != NULL) {
+      TempLocation[0] = CHAR_NULL;
+    }
+  }
+  return (FixFileName(Copy));
+}
+/**
+  Remove the unicode file tag from the begining of the file buffer since that will not be
+  used by StdIn.
+  @param[in]  Handle    Pointer to the handle of the file to be processed.
+  @retval EFI_SUCCESS   The unicode file tag has been moved successfully.
+**/
+EFI_STATUS
+EFIAPI
+RemoveFileTag(
+  IN SHELL_FILE_HANDLE *Handle
+  )
+{
+  UINTN             CharSize;
+  CHAR16            CharBuffer;
+  CharSize    = sizeof(CHAR16);
+  CharBuffer  = 0;
+  gEfiShellProtocol->ReadFile(*Handle, &CharSize, &CharBuffer);
+  if (CharBuffer != gUnicodeFileTag) {
+    gEfiShellProtocol->SetFilePosition(*Handle, 0);
+  }
+  return (EFI_SUCCESS);
+}
+/**
+  Write the unicode file tag to the specified file.
+  It is the caller's responsibility to ensure that
+  ShellInfoObject.NewEfiShellProtocol has been initialized before calling this
+  function.
+  @param[in] FileHandle  The file to write the unicode file tag to.
+  @return  Status code from ShellInfoObject.NewEfiShellProtocol->WriteFile.
+**/
+EFI_STATUS
+WriteFileTag (
+  IN SHELL_FILE_HANDLE FileHandle
+  )
+{
+  CHAR16     FileTag;
+  UINTN      Size;
+  EFI_STATUS Status;
+  FileTag = gUnicodeFileTag;
+  Size = sizeof FileTag;
+  Status = ShellInfoObject.NewEfiShellProtocol->WriteFile (FileHandle, &Size,
+                                                  &FileTag);
+  ASSERT (EFI_ERROR (Status) || Size == sizeof FileTag);
+  return Status;
+}
 /**
 …
   BOOLEAN           ErrAppend;
   UINTN             Size;
-  CHAR16            TagBuffer[2];
   SPLIT_LIST        *Split;
   CHAR16            *FirstLocation;
 …
   SystemTableInfo->ConOut         = gST->ConOut;
   SystemTableInfo->ConOutHandle   = gST->ConsoleOutHandle;
   SystemTableInfo->ConErr         = gST->StdErr;
   SystemTableInfo->ConErrHandle   = gST->StandardErrorHandle;
+  SystemTableInfo->ErrOut         = gST->StdErr;
+  SystemTableInfo->ErrOutHandle   = gST->StandardErrorHandle;
   *OldStdIn                       = ShellParameters->StdIn;
   *OldStdOut                      = ShellParameters->StdOut;
 …
   // re-populate the string to support any filenames that were in quotes.
   //
   StrCpy(CommandLineCopy, NewCommandLine);
+  StrnCpy(CommandLineCopy, NewCommandLine, StrLen(NewCommandLine));
   if (FirstLocation != CommandLineCopy + StrLen(CommandLineCopy)
 …
+    }
     if (StdErrVarName  != NULL) {
       if ((StdErrVarName     = FixFileName(StdErrVarName)) == NULL) {
+      if ((StdErrVarName     = FixVarName(StdErrVarName)) == NULL) {
         Status = EFI_INVALID_PARAMETER;
+      }
+    }
     if (StdOutVarName  != NULL) {
       if ((StdOutVarName     = FixFileName(StdOutVarName)) == NULL) {
+      if ((StdOutVarName     = FixVarName(StdOutVarName)) == NULL) {
         Status = EFI_INVALID_PARAMETER;
+      }
+    }
     if (StdInVarName   != NULL) {
       if ((StdInVarName      = FixFileName(StdInVarName)) == NULL) {
+      if ((StdInVarName      = FixVarName(StdInVarName)) == NULL) {
         Status = EFI_INVALID_PARAMETER;
+      }
 …
         Status = ShellOpenFileByName(StdErrFileName, &TempHandle, EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ|EFI_FILE_MODE_CREATE,0);
         if (!ErrAppend && ErrUnicode && !EFI_ERROR(Status)) {
+          //
+          // Write out the gUnicodeFileTag
+          //
+          Size = sizeof(CHAR16);
+          TagBuffer[0] = gUnicodeFileTag;
+          TagBuffer[1] = CHAR_NULL;
+          ShellInfoObject.NewEfiShellProtocol->WriteFile(TempHandle, &Size, TagBuffer);
+          Status = WriteFileTag (TempHandle);
+        }
         if (!ErrUnicode && !EFI_ERROR(Status)) {
 …
         if (!EFI_ERROR(Status)) {
           ShellParameters->StdErr = TempHandle;
           gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle);
+          gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle, gST->StdErr);
+        }
+      }
 …
             //no-op
           } else if (!OutAppend && OutUnicode && !EFI_ERROR(Status)) {
+            //
+            // Write out the gUnicodeFileTag
+            //
+            Size = sizeof(CHAR16);
+            TagBuffer[0] = gUnicodeFileTag;
+            TagBuffer[1] = CHAR_NULL;
+            ShellInfoObject.NewEfiShellProtocol->WriteFile(TempHandle, &Size, TagBuffer);
+            Status = WriteFileTag (TempHandle);
           } else if (OutAppend) {
-            //
-            // Move to end of file
-            //
             Status = ShellInfoObject.NewEfiShellProtocol->GetFileSize(TempHandle, &FileSize);
             if (!EFI_ERROR(Status)) {
+              Status = ShellInfoObject.NewEfiShellProtocol->SetFilePosition(TempHandle, FileSize);
+              //
+              // When appending to a new unicode file, write the file tag.
+              // Otherwise (ie. when appending to a new ASCII file, or an
+              // existent file with any encoding), just seek to the end.
+              //
+              Status = (FileSize == 0 && OutUnicode) ?
+                         WriteFileTag (TempHandle) :
+                         ShellInfoObject.NewEfiShellProtocol->SetFilePosition (
+                                                                TempHandle,
+                                                                FileSize);
+            }
+          }
 …
           if (!EFI_ERROR(Status)) {
             ShellParameters->StdOut = TempHandle;
             gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle);
+            gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle, gST->ConOut);
+          }
+        }
 …
         ASSERT(TempHandle != NULL);
         ShellParameters->StdOut = TempHandle;
         gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle);
+        gST->ConOut = CreateSimpleTextOutOnFile(TempHandle, &gST->ConsoleOutHandle, gST->ConOut);
+      }
 …
         ASSERT(TempHandle != NULL);
         ShellParameters->StdErr = TempHandle;
         gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle);
+        gST->StdErr = CreateSimpleTextOutOnFile(TempHandle, &gST->StandardErrorHandle, gST->StdErr);
+      }
 …
           EFI_FILE_MODE_READ,
 );
+        if (!InUnicode && !EFI_ERROR(Status)) {
+        if (InUnicode) {
+          //
+          // Chop off the 0xFEFF if it's there...
+          //
+          RemoveFileTag(&TempHandle);
+        } else if (!EFI_ERROR(Status)) {
+          //
+          // Create the ASCII->Unicode conversion layer
+          //
           TempHandle = CreateFileInterfaceFile(TempHandle, FALSE);
+        }
 …
   if (gST->ConIn == NULL ||gST->ConOut == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+    Status = EFI_OUT_OF_RESOURCES;
+  }
+  if (Status == EFI_NOT_FOUND) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_REDUNDA_REDIR), ShellInfoObject.HiiHandle);
+  } else if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SHELL_INVALID_REDIR), ShellInfoObject.HiiHandle);
+  }
   return (Status);
+}
 …
     gST->ConsoleOutHandle     = SystemTableInfo->ConOutHandle;
+  }
   if (gST->StdErr != SystemTableInfo->ConErr) {
+  if (gST->StdErr != SystemTableInfo->ErrOut) {
     CloseSimpleTextOutOnFile(gST->StdErr);
     gST->StdErr               = SystemTableInfo->ConErr;
     gST->StandardErrorHandle  = SystemTableInfo->ConErrHandle;
+    gST->StdErr               = SystemTableInfo->ErrOut;
+    gST->StandardErrorHandle  = SystemTableInfo->ErrOutHandle;
+  }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellParametersProtocol.h

-              r48674
+              r58459
   manipulation, and initialization of EFI_SHELL_PARAMETERS_PROTOCOL.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #define _SHELL_PARAMETERS_PROTOCOL_PROVIDER_HEADER_
-#include <Uefi.h>
-#include <Protocol/SimpleFileSystem.h>
-#include <Protocol/EfiShellParameters.h>
-#include <Protocol/LoadedImage.h>
-#include <Protocol/SimpleTextOut.h>
-#include <Protocol/SimpleTextIn.h>
-#include <Guid/ShellVariableGuid.h>
-#include <Library/UefiBootServicesTableLib.h>
-#include <Library/UefiRuntimeServicesTableLib.h>
-#include <Library/MemoryAllocationLib.h>
-#include <Library/UefiLib.h>
-#include <Library/DebugLib.h>
-#include <Library/ShellLib.h>
-#include <Library/FileHandleLib.h>
-#include "ShellEnvVar.h"
-#include "FileHandleWrappers.h"
 #include "Shell.h"
 …
   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL       *ConOut;
   EFI_HANDLE                            ConOutHandle;
   EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL       *ConErr;
   EFI_HANDLE                            ConErrHandle;
+  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL       *ErrOut;
+  EFI_HANDLE                            ErrOutHandle;
 } SYSTEM_TABLE_INFO;
 …
                                 reminaing command line on return
   @param[in, out] TempParameter pointer to string of command line item extracted.
+**/
+VOID
+  @param[in]      Length        Length of (*TempParameter) in bytes
+  @return   EFI_INALID_PARAMETER  A required parameter was NULL or pointed to a NULL or empty string.
+  @return   EFI_NOT_FOUND         A closing " could not be found on the specified string
+**/
+EFI_STATUS
 EFIAPI
 GetNextParameter(
+  CHAR16 **Walker,
+  CHAR16 **TempParameter
+  IN OUT CHAR16   **Walker,
+  IN OUT CHAR16   **TempParameter,
+  IN CONST UINTN  Length
   );

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellProtocol.c

-              r48674
+              r58459
   manipulation, and initialization of EFI_SHELL_PROTOCOL.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "Shell.h"
+#include <Library/FileHandleLib.h>
+#define INIT_NAME_BUFFER_SIZE  128
 /**
 …
+  )
+{
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *DevicePathToText;
   EFI_STATUS                        Status;
   CHAR16                            *Temp;
 …
   Status = EFI_SUCCESS;
   DEBUG_CODE_BEGIN();
+  DevicePathToText = NULL;
+  Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid,
+                               NULL,
+                               (VOID**)&DevicePathToText);
   if (Mapping != NULL) {
     DEBUG((EFI_D_INFO, "Added new map item:\"%S\"\r\n", Mapping));
+  }
+  if (!EFI_ERROR(Status)) {
+    if (DevicePath != NULL) {
+      Temp = DevicePathToText->ConvertDevicePathToText(DevicePath, TRUE, TRUE);
+      DEBUG((EFI_D_INFO, "DevicePath: %S\r\n", Temp));
+      FreePool(Temp);
+    }
+  }
+  Temp = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
+  DEBUG((EFI_D_INFO, "DevicePath: %S\r\n", Temp));
+  FreePool(Temp);
   DEBUG_CODE_END();
   return (Status);
 …
           //
           ASSERT((PathForReturn == NULL && PathSize == 0) || (PathForReturn != NULL));
-          PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, L"\\", 1);
           AlignedNode = AllocateCopyPool (DevicePathNodeLength(FilePath), FilePath);
+          ASSERT (AlignedNode != NULL);
+          // File Path Device Path Nodes 'can optionally add a "\" separator to
+          //  the beginning and/or the end of the Path Name string.'
+          // (UEFI Spec 2.4 section 9.3.6.4).
+          // If necessary, add a "\", but otherwise don't
+          // (This is specified in the above section, and also implied by the
+          //  UEFI Shell spec section 3.7)
+          if ((PathSize != 0)                        &&
+              (PathForReturn != NULL)                &&
+              (PathForReturn[PathSize - 1] != L'\\') &&
+              (AlignedNode->PathName[0]    != L'\\')) {
+            PathForReturn = StrnCatGrow (&PathForReturn, &PathSize, L"\\", 1);
+          }
           PathForReturn = StrnCatGrow(&PathForReturn, &PathSize, AlignedNode->PathName, 0);
           FreePool(AlignedNode);
 …
       return (NULL);
+    }
+    Size = StrSize(Cwd);
+    Size += StrSize(Path);
+    Size = StrSize(Cwd) + StrSize(Path) - sizeof(CHAR16);
     NewPath = AllocateZeroPool(Size);
     if (NewPath == NULL) {
       return (NULL);
+    }
     StrCpy(NewPath, Cwd);
+    StrnCpy(NewPath, Cwd, Size/sizeof(CHAR16)-1);
     if (*Path == L'\\') {
       Path++;
       while (PathRemoveLastItem(NewPath)) ;
+    }
     StrCat(NewPath, Path);
+    StrnCat(NewPath, Path, Size/sizeof(CHAR16) - 1 - StrLen(NewPath));
     DevicePathForReturn = EfiShellGetDevicePathFromFilePath(NewPath);
     FreePool(NewPath);
 …
   EFI_STATUS                        Status;
   EFI_COMPONENT_NAME2_PROTOCOL      *CompName2;
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *DevicePathToText;
   EFI_DEVICE_PATH_PROTOCOL          *DevicePath;
   EFI_HANDLE                        *HandleList;
 …
   CHAR16                            *DeviceNameToReturn;
   CHAR8                             *Lang;
-  CHAR8                             *TempChar;
   UINTN                             ParentControllerCount;
   EFI_HANDLE                        *ParentControllerBuffer;
 …
         continue;
+      }
+      if (Language == NULL) {
+        Lang = AllocateZeroPool(AsciiStrSize(CompName2->SupportedLanguages));
+        if (Lang == NULL) {
+          return (EFI_OUT_OF_RESOURCES);
+        }
+        AsciiStrCpy(Lang, CompName2->SupportedLanguages);
+        TempChar = AsciiStrStr(Lang, ";");
+        if (TempChar != NULL){
+          *TempChar = CHAR_NULL;
+        }
+      } else {
+        Lang = AllocateZeroPool(AsciiStrSize(Language));
+        if (Lang == NULL) {
+          return (EFI_OUT_OF_RESOURCES);
+        }
+        AsciiStrCpy(Lang, Language);
+      }
+      Lang = GetBestLanguageForDriver(CompName2->SupportedLanguages, Language, FALSE);
       Status = CompName2->GetControllerName(CompName2, DeviceHandle, NULL, Lang, &DeviceNameToReturn);
       FreePool(Lang);
 …
             continue;
+          }
+          if (Language == NULL) {
+            Lang = AllocateZeroPool(AsciiStrSize(CompName2->SupportedLanguages));
+            if (Lang == NULL) {
+              return (EFI_OUT_OF_RESOURCES);
+            }
+            AsciiStrCpy(Lang, CompName2->SupportedLanguages);
+            TempChar = AsciiStrStr(Lang, ";");
+            if (TempChar != NULL){
+              *TempChar = CHAR_NULL;
+            }
+          } else {
+            Lang = AllocateZeroPool(AsciiStrSize(Language));
+            if (Lang == NULL) {
+              return (EFI_OUT_OF_RESOURCES);
+            }
+            AsciiStrCpy(Lang, Language);
+          }
+          Lang = GetBestLanguageForDriver(CompName2->SupportedLanguages, Language, FALSE);
           Status = CompName2->GetControllerName(CompName2, ParentControllerBuffer[LoopVar], DeviceHandle, Lang, &DeviceNameToReturn);
           FreePool(Lang);
 …
+  }
   if ((Flags & EFI_DEVICE_NAME_USE_DEVICE_PATH) != 0) {
+    Status = gBS->LocateProtocol(
+      &gEfiDevicePathToTextProtocolGuid,
+    Status = gBS->OpenProtocol(
+      DeviceHandle,
+      &gEfiDevicePathProtocolGuid,
+      (VOID**)&DevicePath,
+      gImageHandle,
       NULL,
+      (VOID**)&DevicePathToText);
+    //
+    // we now have the device path to text protocol
+    //
+      EFI_OPEN_PROTOCOL_GET_PROTOCOL);
     if (!EFI_ERROR(Status)) {
+      Status = gBS->OpenProtocol(
+        DeviceHandle,
+        &gEfiDevicePathProtocolGuid,
+        (VOID**)&DevicePath,
+        gImageHandle,
+        NULL,
+        EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+      if (!EFI_ERROR(Status)) {
+        //
+        // use device path to text on the device path
+        //
+        *BestDeviceName = DevicePathToText->ConvertDevicePathToText(DevicePath, TRUE, TRUE);
+        return (EFI_SUCCESS);
+      }
+      //
+      // use device path to text on the device path
+      //
+      *BestDeviceName = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
+      return (EFI_SUCCESS);
+    }
+  }
 …
   EFI_FILE_PROTOCOL               *Handle1;
   EFI_FILE_PROTOCOL               *Handle2;
-  EFI_DEVICE_PATH_PROTOCOL        *DpCopy;
   FILEPATH_DEVICE_PATH            *AlignedNode;
 …
   Handle2       = NULL;
   Handle        = NULL;
-  DpCopy        = DevicePath;
   ShellHandle   = NULL;
   FilePathNode  = NULL;
 …
+  }
   Status = InternalOpenFileDevicePath(DevicePath, FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, FileAttribs); // 0 = no specific file attributes
+  Status = InternalOpenFileDevicePath(DevicePath, FileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, FileAttribs);
   FreePool(DevicePath);
   return(Status);
+}
+/**
+  Register a GUID and a localized human readable name for it.
+  If Guid is not assigned a name, then assign GuidName to Guid.  This list of GUID
+  names must be used whenever a shell command outputs GUID information.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in] Guid       A pointer to the GUID being registered.
+  @param[in] GuidName   A pointer to the localized name for the GUID being registered.
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_ACCESS_DENIED       Guid already is assigned a name.
+**/
+EFI_STATUS
+EFIAPI
+EfiShellRegisterGuidName(
+  IN CONST EFI_GUID *Guid,
+  IN CONST CHAR16   *GuidName
+  )
+{
+  return (AddNewGuidNameMapping(Guid, GuidName, NULL));
+}
 …
   EFI_STATUS        Status;
+  FileHandle = NULL;
   //
   // get a handle to the file
 …
   internal worker function to load and run an image via device path.
+  @param ParentImageHandle  A handle of the image that is executing the specified
+                            command line.
+  @param DevicePath         device path of the file to execute
+  @param CommandLine        Points to the NULL-terminated UCS-2 encoded string
+                            containing the command line. If NULL then the command-
+                            line will be empty.
+  @param Environment        Points to a NULL-terminated array of environment
+                            variables with the format 'x=y', where x is the
+                            environment variable name and y is the value. If this
+                            is NULL, then the current shell environment is used.
+  @param StatusCode         Points to the status code returned by the command.
+  @param ParentImageHandle      A handle of the image that is executing the specified
+                                command line.
+  @param DevicePath             device path of the file to execute
+  @param CommandLine            Points to the NULL-terminated UCS-2 encoded string
+                                containing the command line. If NULL then the command-
+                                line will be empty.
+  @param Environment            Points to a NULL-terminated array of environment
+                                variables with the format 'x=y', where x is the
+                                environment variable name and y is the value. If this
+                                is NULL, then the current shell environment is used.
+  @param[out] StartImageStatus  Returned status from gBS->StartImage.
   @retval EFI_SUCCESS       The command executed successfully. The  status code
 …
   IN CONST CHAR16                   *CommandLine OPTIONAL,
   IN CONST CHAR16                   **Environment OPTIONAL,
   OUT EFI_STATUS                    *StatusCode OPTIONAL
+  OUT EFI_STATUS                    *StartImageStatus OPTIONAL
+  )
+{
   EFI_STATUS                    Status;
+  EFI_STATUS                    StartStatus;
+  EFI_STATUS                    CleanupStatus;
   EFI_HANDLE                    NewHandle;
   EFI_LOADED_IMAGE_PROTOCOL     *LoadedImage;
   LIST_ENTRY                    OrigEnvs;
   EFI_SHELL_PARAMETERS_PROTOCOL ShellParamsProtocol;
+  CHAR16                        *ImagePath;
+  UINTN                         Index;
+  CHAR16                        *Walker;
+  CHAR16                        *NewCmdLine;
   if (ParentImageHandle == NULL) {
 …
   NewHandle = NULL;
+  NewCmdLine = AllocateCopyPool (StrSize (CommandLine), CommandLine);
+  if (NewCmdLine == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  for (Walker = NewCmdLine; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
+    if (*Walker == L'^' && *(Walker+1) == L'#') {
+      CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
+    }
+  }
   //
 …
   if (!EFI_ERROR(Status)) {
     ASSERT(LoadedImage->LoadOptionsSize == 0);
     if (CommandLine != NULL) {
       LoadedImage->LoadOptionsSize  = (UINT32)StrSize(CommandLine);
       LoadedImage->LoadOptions      = (VOID*)CommandLine;
+    if (NewCmdLine != NULL) {
+      LoadedImage->LoadOptionsSize  = (UINT32)StrSize(NewCmdLine);
+      LoadedImage->LoadOptions      = (VOID*)NewCmdLine;
+    }
 …
     ShellParamsProtocol.StdOut  = ShellInfoObject.NewShellParametersProtocol->StdOut;
     ShellParamsProtocol.StdErr  = ShellInfoObject.NewShellParametersProtocol->StdErr;
     Status = UpdateArgcArgv(&ShellParamsProtocol, CommandLine, NULL, NULL);
+    Status = UpdateArgcArgv(&ShellParamsProtocol, NewCmdLine, NULL, NULL);
     ASSERT_EFI_ERROR(Status);
+    //
+    // Replace Argv[0] with the full path of the binary we're executing:
+    // If the command line was "foo", the binary might be called "foo.efi".
+    // "The first entry in [Argv] is always the full file path of the
+    //  executable" - UEFI Shell Spec section 2.3
+    //
+    ImagePath = EfiShellGetFilePathFromDevicePath (DevicePath);
+    // The image we're executing isn't necessarily in a filesystem - it might
+    // be memory mapped. In this case EfiShellGetFilePathFromDevicePath will
+    // return NULL, and we'll leave Argv[0] as UpdateArgcArgv set it.
+    if (ImagePath != NULL) {
+      if (ShellParamsProtocol.Argv == NULL) {
+        // Command line was empty or null.
+        // (UpdateArgcArgv sets Argv to NULL when CommandLine is "" or NULL)
+        ShellParamsProtocol.Argv = AllocatePool (sizeof (CHAR16 *));
+        if (ShellParamsProtocol.Argv == NULL) {
+          Status = EFI_OUT_OF_RESOURCES;
+          goto UnloadImage;
+        }
+        ShellParamsProtocol.Argc = 1;
+      } else {
+        // Free the string UpdateArgcArgv put in Argv[0];
+        FreePool (ShellParamsProtocol.Argv[0]);
+      }
+      ShellParamsProtocol.Argv[0] = ImagePath;
+    }
     Status = gBS->InstallProtocolInterface(&NewHandle, &gEfiShellParametersProtocolGuid, EFI_NATIVE_INTERFACE, &ShellParamsProtocol);
     ASSERT_EFI_ERROR(Status);
 …
     //
     if (!EFI_ERROR(Status)) {
+      if (StatusCode != NULL) {
+        *StatusCode = gBS->StartImage(NewHandle, NULL, NULL);
+      } else {
+        Status      = gBS->StartImage(NewHandle, NULL, NULL);
+      StartStatus      = gBS->StartImage(
+                          NewHandle,
+,
+                          NULL
+                          );
+      if (StartImageStatus != NULL) {
+        *StartImageStatus = StartStatus;
+      }
+    }
+    //
+    // Cleanup (and dont overwrite errors)
+    //
+    if (EFI_ERROR(Status)) {
+      gBS->UninstallProtocolInterface(NewHandle, &gEfiShellParametersProtocolGuid, &ShellParamsProtocol);
+    } else {
+      Status = gBS->UninstallProtocolInterface(NewHandle, &gEfiShellParametersProtocolGuid, &ShellParamsProtocol);
+      ASSERT_EFI_ERROR(Status);
+    }
+  }
+      CleanupStatus = gBS->UninstallProtocolInterface(
+                            NewHandle,
+                            &gEfiShellParametersProtocolGuid,
+                            &ShellParamsProtocol
+                            );
+      ASSERT_EFI_ERROR(CleanupStatus);
+      goto FreeAlloc;
+    }
+UnloadImage:
+    // Unload image - We should only get here if we didn't call StartImage
+    gBS->UnloadImage (NewHandle);
+FreeAlloc:
+    // Free Argv (Allocated in UpdateArgcArgv)
+    if (ShellParamsProtocol.Argv != NULL) {
+      for (Index = 0; Index < ShellParamsProtocol.Argc; Index++) {
+        if (ShellParamsProtocol.Argv[Index] != NULL) {
+          FreePool (ShellParamsProtocol.Argv[Index]);
+        }
+      }
+      FreePool (ShellParamsProtocol.Argv);
+    }
+  }
+  // Restore environment variables
   if (!IsListEmpty(&OrigEnvs)) {
+    if (EFI_ERROR(Status)) {
+      SetEnvironmentVariableList(&OrigEnvs);
+    } else {
+      Status = SetEnvironmentVariableList(&OrigEnvs);
+    }
+  }
+    CleanupStatus = SetEnvironmentVariableList(&OrigEnvs);
+    ASSERT_EFI_ERROR (CleanupStatus);
+  }
+  FreePool (NewCmdLine);
   return(Status);
 …
   DEBUG_CODE_BEGIN();
   Temp = gDevPathToText->ConvertDevicePathToText(ShellInfoObject.FileDevPath, TRUE, TRUE);
+  Temp = ConvertDevicePathToText(ShellInfoObject.FileDevPath, TRUE, TRUE);
   FreePool(Temp);
   Temp = gDevPathToText->ConvertDevicePathToText(ShellInfoObject.ImageDevPath, TRUE, TRUE);
+  Temp = ConvertDevicePathToText(ShellInfoObject.ImageDevPath, TRUE, TRUE);
   FreePool(Temp);
   Temp = gDevPathToText->ConvertDevicePathToText(DevPath, TRUE, TRUE);
+  Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);
   FreePool(Temp);
   DEBUG_CODE_END();
 …
   Size = 0;
   ASSERT((Temp == NULL && Size == 0) || (Temp != NULL));
   StrnCatGrow(&Temp, &Size, L"Shell.efi ", 0);
+  StrnCatGrow(&Temp, &Size, L"Shell.efi -_exit ", 0);
   StrnCatGrow(&Temp, &Size, CommandLine, 0);
 …
     InternalFreeShellFileInfoNode(ShellFileListItem);
+  }
+  InternalFreeShellFileInfoNode(*FileList);
+  *FileList = NULL;
   return(EFI_SUCCESS);
+}
 …
   EFI_SHELL_FILE_INFO *ShellFileListItem;
   EFI_SHELL_FILE_INFO *ShellFileListItem2;
+  EFI_SHELL_FILE_INFO *TempNode;
   if (FileList == NULL || *FileList == NULL) {
 …
             (CHAR16*)ShellFileListItem2->FullName) == 0
          ){
+        TempNode = (EFI_SHELL_FILE_INFO *)GetPreviousNode(
+                                            &(*FileList)->Link,
+                                            &ShellFileListItem2->Link
+                                            );
         RemoveEntryList(&ShellFileListItem2->Link);
         InternalFreeShellFileInfoNode(ShellFileListItem2);
+        // Set ShellFileListItem2 to PreviousNode so we don't access Freed
+        // memory in GetNextNode in the loop expression above.
+        ShellFileListItem2 = TempNode;
+      }
+    }
 …
   return (EFI_SUCCESS);
+}
+//
+// This is the same structure as the external version, but it has no CONST qualifiers.
+//
+typedef struct {
+  LIST_ENTRY        Link;       ///< Linked list members.
+  EFI_STATUS        Status;     ///< Status of opening the file.  Valid only if Handle != NULL.
+        CHAR16      *FullName;  ///< Fully qualified filename.
+        CHAR16      *FileName;  ///< name of this file.
+  SHELL_FILE_HANDLE Handle;     ///< Handle for interacting with the opened file or NULL if closed.
+  EFI_FILE_INFO     *Info;      ///< Pointer to the FileInfo struct for this file or NULL.
+} EFI_SHELL_FILE_INFO_NO_CONST;
 /**
   Allocates and duplicates a EFI_SHELL_FILE_INFO node.
 …
+  )
+{
+  EFI_SHELL_FILE_INFO *NewNode;
+  EFI_SHELL_FILE_INFO_NO_CONST *NewNode;
+  //
+  // try to confirm that the objects are in sync
+  //
+  ASSERT(sizeof(EFI_SHELL_FILE_INFO_NO_CONST) == sizeof(EFI_SHELL_FILE_INFO));
   NewNode = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
 …
     return (NULL);
+  }
+  NewNode->FullName = AllocateZeroPool(StrSize(Node->FullName));
+  NewNode->FileName = AllocateZeroPool(StrSize(Node->FileName));
+  NewNode->Info     = AllocateZeroPool((UINTN)Node->Info->Size);
+  NewNode->FullName = AllocateCopyPool(StrSize(Node->FullName), Node->FullName);
+  NewNode->FileName = AllocateCopyPool(StrSize(Node->FileName), Node->FileName);
+  NewNode->Info     = AllocateCopyPool((UINTN)Node->Info->Size, Node->Info);
   if ( NewNode->FullName == NULL
     || NewNode->FileName == NULL
     || NewNode->Info == NULL
+   ){
+  ){
+    SHELL_FREE_NON_NULL(NewNode->FullName);
+    SHELL_FREE_NON_NULL(NewNode->FileName);
+    SHELL_FREE_NON_NULL(NewNode->Info);
+    SHELL_FREE_NON_NULL(NewNode);
     return(NULL);
+  }
 …
     Node->Handle = NULL;
+  }
+  StrCpy((CHAR16*)NewNode->FullName, Node->FullName);
+  StrCpy((CHAR16*)NewNode->FileName, Node->FileName);
+  CopyMem(NewNode->Info, Node->Info, (UINTN)Node->Info->Size);
+  return(NewNode);
+  return((EFI_SHELL_FILE_INFO*)NewNode);
+}
 …
   @param[in] BasePath         the Path to prepend onto filename for FullPath
   @param[in] Status           Status member initial value.
-  @param[in] FullName         FullName member initial value.
   @param[in] FileName         FileName member initial value.
   @param[in] Handle           Handle member initial value.
 …
   IN CONST CHAR16 *BasePath,
   IN CONST EFI_STATUS Status,
-  IN CONST CHAR16 *FullName,
   IN CONST CHAR16 *FileName,
   IN CONST SHELL_FILE_HANDLE Handle,
 …
     return (NULL);
+  }
   if (Info != NULL) {
+  if (Info != NULL && Info->Size != 0) {
     ShellFileListItem->Info = AllocateZeroPool((UINTN)Info->Size);
     if (ShellFileListItem->Info == NULL) {
 …
     if (TempString == NULL) {
       FreePool((VOID*)ShellFileListItem->FileName);
       FreePool(ShellFileListItem->Info);
+      SHELL_FREE_NON_NULL(ShellFileListItem->Info);
       FreePool(ShellFileListItem);
       return (NULL);
 …
+    }
+  }
+  TempString = PathCleanUpDirectories(TempString);
   ShellFileListItem->FullName = TempString;
 …
   CHAR16                    *TempSpot;
+  BasePath = NULL;
   Status = FileHandleGetFileName(FileDirHandle, &BasePath);
   if (EFI_ERROR(Status)) {
 …
     TempString        = StrnCatGrow(&TempString, &Size, ShellFileHandleGetPath(FileDirHandle), 0);
     if (TempString == NULL) {
+      SHELL_FREE_NON_NULL(BasePath);
       return (EFI_OUT_OF_RESOURCES);
+    }
 …
     TempString        = StrnCatGrow(&TempString, &Size, BasePath, 0);
     if (TempString == NULL) {
+      SHELL_FREE_NON_NULL(BasePath);
       return (EFI_OUT_OF_RESOURCES);
+    }
+    SHELL_FREE_NON_NULL(BasePath);
     BasePath          = TempString;
+  }
 …
       ; Status = FileHandleFindNextFile(FileDirHandle, FileInfo, &NoFile)
      ){
-    TempString  = NULL;
-    Size        = 0;
     //
     // allocate a new EFI_SHELL_FILE_INFO and populate it...
     //
-    ASSERT((TempString == NULL && Size == 0) || (TempString != NULL));
-    TempString = StrnCatGrow(&TempString, &Size, BasePath, 0);
-    TempString = StrnCatGrow(&TempString, &Size, FileInfo->FileName, 0);
     ShellFileListItem = CreateAndPopulateShellFileInfo(
       BasePath,
+      EFI_SUCCESS, // success since we didnt fail to open it...
+      TempString,
+      EFI_SUCCESS,  // success since we didnt fail to open it...
       FileInfo->FileName,
       NULL, // no handle since not open
+      NULL,         // no handle since not open
       FileInfo);
 …
   SHELL_FREE_NON_NULL(BasePath);
   return(Status);
+}
+/**
+  Get the GUID value from a human readable name.
+  If GuidName is a known GUID name, then update Guid to have the correct value for
+  that GUID.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in]  GuidName   A pointer to the localized name for the GUID being queried.
+  @param[out] Guid       A pointer to the GUID structure to be filled in.
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           GuidName is not a known GUID Name.
+**/
+EFI_STATUS
+EFIAPI
+EfiShellGetGuidFromName(
+  IN  CONST CHAR16   *GuidName,
+  OUT       EFI_GUID *Guid
+  )
+{
+  EFI_GUID    *NewGuid;
+  EFI_STATUS  Status;
+  if (Guid == NULL || GuidName == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+  Status = GetGuidFromStringName(GuidName, NULL, &NewGuid);
+  if (!EFI_ERROR(Status)) {
+    CopyGuid(NewGuid, Guid);
+  }
+  return (Status);
+}
+/**
+  Get the human readable name for a GUID from the value.
+  If Guid is assigned a name, then update *GuidName to point to the name. The callee
+  should not modify the value.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in]  Guid       A pointer to the GUID being queried.
+  @param[out] GuidName   A pointer to a pointer the localized to name for the GUID being requested
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           Guid is not assigned a name.
+**/
+EFI_STATUS
+EFIAPI
+EfiShellGetGuidName(
+  IN  CONST EFI_GUID *Guid,
+  OUT CONST CHAR16   **GuidName
+  )
+{
+  CHAR16   *Name;
+  if (Guid == NULL || GuidName == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+  Name = GetStringNameFromGuid(Guid, NULL);
+  if (Name == NULL || StrLen(Name) == 0) {
+    SHELL_FREE_NON_NULL(Name);
+    return (EFI_NOT_FOUND);
+  }
+  *GuidName = AddBufferToFreeList(Name);
+  return (EFI_SUCCESS);
+}
 …
   EFI_SHELL_FILE_INFO *ShellInfoNode;
   EFI_SHELL_FILE_INFO *NewShellNode;
+  EFI_FILE_INFO       *FileInfo;
   BOOLEAN             Directory;
   CHAR16              *NewFullName;
 …
   if (CurrentFilePattern[0]   == CHAR_NULL
     &&NextFilePatternStart[0] == CHAR_NULL
    ){
     //
     // Add the current parameter FileHandle to the list, then end...
+    ){
+    //
+    // we want the parent or root node (if no parent)
     //
     if (ParentNode == NULL) {
+      Status = EFI_INVALID_PARAMETER;
+      //
+      // We want the root node.  create the node.
+      //
+      FileInfo = FileHandleGetInfo(FileHandle);
+      NewShellNode = CreateAndPopulateShellFileInfo(
+        MapName,
+        EFI_SUCCESS,
+        L"\\",
+        FileHandle,
+        FileInfo
+        );
+      SHELL_FREE_NON_NULL(FileInfo);
     } else {
+      //
+      // Add the current parameter FileHandle to the list, then end...
+      //
       NewShellNode = InternalDuplicateShellFileInfo((EFI_SHELL_FILE_INFO*)ParentNode, TRUE);
+      if (NewShellNode == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+      } else {
+        NewShellNode->Handle = NULL;
+        if (*FileList == NULL) {
+          *FileList = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
+          InitializeListHead(&((*FileList)->Link));
+        }
+        //
+        // Add to the returning to use list
+        //
+        InsertTailList(&(*FileList)->Link, &NewShellNode->Link);
+        Status = EFI_SUCCESS;
+    }
+    if (NewShellNode == NULL) {
+      Status = EFI_OUT_OF_RESOURCES;
+    } else {
+      NewShellNode->Handle = NULL;
+      if (*FileList == NULL) {
+        *FileList = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
+        InitializeListHead(&((*FileList)->Link));
+      }
+      //
+      // Add to the returning to use list
+      //
+      InsertTailList(&(*FileList)->Link, &NewShellNode->Link);
+      Status = EFI_SUCCESS;
+    }
   } else {
 …
               Status = EFI_OUT_OF_RESOURCES;
             } else {
               StrCpy(NewFullName, MapName);
               StrCat(NewFullName, ShellInfoNode->FullName+1);
+              StrnCpy(NewFullName, MapName, Size/sizeof(CHAR16)-1);
+              StrnCat(NewFullName, ShellInfoNode->FullName+1, (Size/sizeof(CHAR16))-StrLen(NewFullName)-1);
               FreePool((VOID*)ShellInfoNode->FullName);
               ShellInfoNode->FullName = NewFullName;
 …
   RootFileHandle = NULL;
   MapName        = NULL;
   PatternCopy = AllocateZeroPool(StrSize(FilePattern));
+  PatternCopy = AllocateCopyPool(StrSize(FilePattern), FilePattern);
   if (PatternCopy == NULL) {
     return (EFI_OUT_OF_RESOURCES);
+  }
-  StrCpy(PatternCopy, FilePattern);
   PatternCopy = PathCleanUpDirectories(PatternCopy);
 …
 /**
+  This function updated with errata.
+  Gets the environment variable and Attributes, or list of environment variables.  Can be
+  used instead of GetEnv().
+  This function returns the current value of the specified environment variable and
+  the Attributes. If no variable name was specified, then all of the known
+  variables will be returned.
+  @param[in] Name               A pointer to the environment variable name. If Name is NULL,
+                                then the function will return all of the defined shell
+                                environment variables. In the case where multiple environment
+                                variables are being returned, each variable will be terminated
+                                by a NULL, and the list will be terminated by a double NULL.
+  @param[out] Attributes        If not NULL, a pointer to the returned attributes bitmask for
+                                the environment variable. In the case where Name is NULL, and
+                                multiple environment variables are being returned, Attributes
+                                is undefined.
+  @retval NULL                  The environment variable doesn't exist.
+  @return                       A non-NULL value points to the variable's value. The returned
+                                pointer does not need to be freed by the caller.
+**/
+CONST CHAR16 *
+EFIAPI
+EfiShellGetEnvEx(
+  IN  CONST CHAR16 *Name,
+  OUT       UINT32 *Attributes OPTIONAL
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *Buffer;
+  UINTN       Size;
+  LIST_ENTRY  List;
+  ENV_VAR_LIST *Node;
+  CHAR16      *CurrentWriteLocation;
+  Size = 0;
+  Buffer = NULL;
+  if (Name == NULL) {
+    //
+    // Get all our environment variables
+    //
+    InitializeListHead(&List);
+    Status = GetEnvironmentVariableList(&List);
+    if (EFI_ERROR(Status)){
+      return (NULL);
+    }
+    //
+    // Build the semi-colon delimited list. (2 passes)
+    //
+    for ( Node = (ENV_VAR_LIST*)GetFirstNode(&List)
+      ; !IsNull(&List, &Node->Link)
+      ; Node = (ENV_VAR_LIST*)GetNextNode(&List, &Node->Link)
+     ){
+      ASSERT(Node->Key != NULL);
+      Size += StrSize(Node->Key);
+    }
+    Size += 2*sizeof(CHAR16);
+    Buffer = AllocateZeroPool(Size);
+    if (Buffer == NULL) {
+      if (!IsListEmpty (&List)) {
+        FreeEnvironmentVariableList(&List);
+      }
+      return (NULL);
+    }
+    CurrentWriteLocation = (CHAR16*)Buffer;
+    for ( Node = (ENV_VAR_LIST*)GetFirstNode(&List)
+      ; !IsNull(&List, &Node->Link)
+      ; Node = (ENV_VAR_LIST*)GetNextNode(&List, &Node->Link)
+     ){
+      ASSERT(Node->Key != NULL);
+      StrnCpy(CurrentWriteLocation, Node->Key,  (Size)/sizeof(CHAR16) - (CurrentWriteLocation - ((CHAR16*)Buffer)) - 1);
+      CurrentWriteLocation += StrLen(CurrentWriteLocation) + 1;
+    }
+    //
+    // Free the list...
+    //
+    if (!IsListEmpty (&List)) {
+      FreeEnvironmentVariableList(&List);
+    }
+  } else {
+    //
+    // We are doing a specific environment variable
+    //
+    //
+    // get the size we need for this EnvVariable
+    //
+    Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name, Attributes, &Size, Buffer);
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      //
+      // Allocate the space and recall the get function
+      //
+      Buffer = AllocateZeroPool(Size);
+      Status = SHELL_GET_ENVIRONMENT_VARIABLE_AND_ATTRIBUTES(Name, Attributes, &Size, Buffer);
+    }
+    //
+    // we didnt get it (might not exist)
+    // free the memory if we allocated any and return NULL
+    //
+    if (EFI_ERROR(Status)) {
+      if (Buffer != NULL) {
+        FreePool(Buffer);
+      }
+      return (NULL);
+    }
+  }
+  //
+  // return the buffer
+  //
+  return (AddBufferToFreeList(Buffer));
+}
+/**
   Gets either a single or list of environment variables.
 …
                                 NULL.
   @return !=NULL                A pointer to the returned string.
+  @retval !=NULL                A pointer to the returned string.
                                 The returned pointer does not need to be freed by the caller.
 …
+  )
+{
+  EFI_STATUS  Status;
+  VOID        *Buffer;
+  UINTN       Size;
+  LIST_ENTRY  List;
+  ENV_VAR_LIST *Node;
+  CHAR16      *CurrentWriteLocation;
+  Size = 0;
+  Buffer = NULL;
+  if (Name == NULL) {
+    //
+    // Get all our environment variables
+    //
+    InitializeListHead(&List);
+    Status = GetEnvironmentVariableList(&List);
+    if (EFI_ERROR(Status)){
+      return (NULL);
+    }
+    //
+    // Build the semi-colon delimited list. (2 passes)
+    //
+    for ( Node = (ENV_VAR_LIST*)GetFirstNode(&List)
+      ; !IsNull(&List, &Node->Link)
+      ; Node = (ENV_VAR_LIST*)GetNextNode(&List, &Node->Link)
+     ){
+      ASSERT(Node->Key != NULL);
+      Size += StrSize(Node->Key);
+    }
+    Size += 2*sizeof(CHAR16);
+    Buffer = AllocateZeroPool(Size);
+    if (Buffer == NULL) {
+      if (!IsListEmpty (&List)) {
+        FreeEnvironmentVariableList(&List);
+      }
+      return (NULL);
+    }
+    CurrentWriteLocation = (CHAR16*)Buffer;
+    for ( Node = (ENV_VAR_LIST*)GetFirstNode(&List)
+      ; !IsNull(&List, &Node->Link)
+      ; Node = (ENV_VAR_LIST*)GetNextNode(&List, &Node->Link)
+     ){
+      ASSERT(Node->Key != NULL);
+      StrCpy(CurrentWriteLocation, Node->Key);
+      CurrentWriteLocation += StrLen(CurrentWriteLocation) + 1;
+    }
+    //
+    // Free the list...
+    //
+    if (!IsListEmpty (&List)) {
+      FreeEnvironmentVariableList(&List);
+    }
+  } else {
+    //
+    // We are doing a specific environment variable
+    //
+    //
+    // get the size we need for this EnvVariable
+    //
+    Status = SHELL_GET_ENVIRONMENT_VARIABLE(Name, &Size, Buffer);
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      //
+      // Allocate the space and recall the get function
+      //
+      Buffer = AllocateZeroPool(Size);
+      ASSERT(Buffer != NULL);
+      Status = SHELL_GET_ENVIRONMENT_VARIABLE(Name, &Size, Buffer);
+    }
+    //
+    // we didnt get it (might not exist)
+    // free the memory if we allocated any and return NULL
+    //
+    if (EFI_ERROR(Status)) {
+      if (Buffer != NULL) {
+        FreePool(Buffer);
+      }
+      return (NULL);
+    }
+  }
+  //
+  // return the buffer
+  //
+  return (AddBufferToFreeList(Buffer));
+  return (EfiShellGetEnvEx(Name, NULL));
+}
 …
+{
   CONST CHAR16  *ManFileName;
+  CHAR16        *FixCommand;
+  EFI_STATUS    Status;
   ASSERT(HelpText != NULL);
+  FixCommand = NULL;
   ManFileName = ShellCommandGetManFileNameHandler(Command);
 …
     return (ProcessManFile(ManFileName, Command, Sections, NULL, HelpText));
   } else {
+    return (ProcessManFile(Command, Command, Sections, NULL, HelpText));
+    if ((StrLen(Command)> 4)
+    && (Command[StrLen(Command)-1] == L'i' || Command[StrLen(Command)-1] == L'I')
+    && (Command[StrLen(Command)-2] == L'f' || Command[StrLen(Command)-2] == L'F')
+    && (Command[StrLen(Command)-3] == L'e' || Command[StrLen(Command)-3] == L'E')
+    && (Command[StrLen(Command)-4] == L'.')
+    ) {
+      FixCommand = AllocateZeroPool(StrSize(Command) - 4 * sizeof (CHAR16));
+      ASSERT(FixCommand != NULL);
+      StrnCpy(FixCommand, Command, StrLen(Command)-4);
+      Status = ProcessManFile(FixCommand, FixCommand, Sections, NULL, HelpText);
+      FreePool(FixCommand);
+      return Status;
+    } else {
+      return (ProcessManFile(Command, Command, Sections, NULL, HelpText));
+    }
+  }
+}
 …
+  )
+{
+  UINT64            MaxStorSize;
+  UINT64            RemStorSize;
+  UINT64            MaxVarSize;
   EFI_STATUS        Status;
   EFI_GUID          Guid;
   CHAR16            *VariableName;
   UINTN             NameSize;
+  UINTN             NameBufferSize;
   CHAR16            *RetVal;
   UINTN             RetSize;
+  CHAR16            *Alias;
+  Status = gRT->QueryVariableInfo(EFI_VARIABLE_NON_VOLATILE|EFI_VARIABLE_BOOTSERVICE_ACCESS, &MaxStorSize, &RemStorSize, &MaxVarSize);
+  ASSERT_EFI_ERROR(Status);
+  VariableName  = AllocateZeroPool((UINTN)MaxVarSize);
+  NameBufferSize = INIT_NAME_BUFFER_SIZE;
+  VariableName  = AllocateZeroPool(NameBufferSize);
   RetSize       = 0;
   RetVal        = NULL;
 …
   while (TRUE) {
     NameSize = (UINTN)MaxVarSize;
+    NameSize = NameBufferSize;
     Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
     if (Status == EFI_NOT_FOUND){
       break;
+    }
+    ASSERT_EFI_ERROR(Status);
+    if (EFI_ERROR(Status)) {
+    } else if (Status == EFI_BUFFER_TOO_SMALL) {
+      NameBufferSize = NameSize > NameBufferSize * 2 ? NameSize : NameBufferSize * 2;
+      SHELL_FREE_NON_NULL(VariableName);
+      VariableName = AllocateZeroPool(NameBufferSize);
+      if (VariableName == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        SHELL_FREE_NON_NULL(RetVal);
+        RetVal = NULL;
+        break;
+      }
+      NameSize = NameBufferSize;
+      Status = gRT->GetNextVariableName(&NameSize, VariableName, &Guid);
+    }
+    if (EFI_ERROR (Status)) {
+      SHELL_FREE_NON_NULL(RetVal);
+      RetVal = NULL;
       break;
+    }
     if (CompareGuid(&Guid, &gShellAliasGuid)){
-      Alias = GetVariable(VariableName, &gShellAliasGuid);
       ASSERT((RetVal == NULL && RetSize == 0) || (RetVal != NULL));
       RetVal = StrnCatGrow(&RetVal, &RetSize, VariableName, 0);
 …
     } // compare guid
   } // while
   FreePool(VariableName);
+  SHELL_FREE_NON_NULL(VariableName);
   return (RetVal);
+}
+/**
+  Convert a null-terminated unicode string, in-place, to all lowercase.
+  Then return it.
+  @param  Str    The null-terminated string to be converted to all lowercase.
+  @return        The null-terminated string converted into all lowercase.
+**/
+CHAR16 *
+ToLower (
+  CHAR16 *Str
+  )
+{
+  UINTN Index;
+  for (Index = 0; Str[Index] != L'\0'; Index++) {
+    if (Str[Index] >= L'A' && Str[Index] <= L'Z') {
+      Str[Index] -= (CHAR16)(L'A' - L'a');
+    }
+  }
+  return Str;
+}
 …
   UINT32      Attribs;
   EFI_STATUS  Status;
+  CHAR16      *AliasLower;
+  // Convert to lowercase to make aliases case-insensitive
   if (Alias != NULL) {
+    AliasLower = AllocateCopyPool (StrSize (Alias), Alias);
+    ASSERT (AliasLower != NULL);
+    ToLower (AliasLower);
     if (Volatile == NULL) {
       return (AddBufferToFreeList(GetVariable((CHAR16*)Alias, &gShellAliasGuid)));
+      return (AddBufferToFreeList(GetVariable(AliasLower, &gShellAliasGuid)));
+    }
     RetSize = 0;
     RetVal = NULL;
     Status = gRT->GetVariable((CHAR16*)Alias, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
+    Status = gRT->GetVariable(AliasLower, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
     if (Status == EFI_BUFFER_TOO_SMALL) {
       RetVal = AllocateZeroPool(RetSize);
       Status = gRT->GetVariable((CHAR16*)Alias, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
+      Status = gRT->GetVariable(AliasLower, &gShellAliasGuid, &Attribs, &RetSize, RetVal);
+    }
     if (EFI_ERROR(Status)) {
 …
+    }
+    FreePool (AliasLower);
     return (AddBufferToFreeList(RetVal));
+  }
 …
+  )
+{
+  EFI_STATUS  Status;
+  CHAR16      *AliasLower;
+  // Convert to lowercase to make aliases case-insensitive
+  if (Alias != NULL) {
+    AliasLower = AllocateCopyPool (StrSize (Alias), Alias);
+    ASSERT (AliasLower != NULL);
+    ToLower (AliasLower);
+  } else {
+    AliasLower = NULL;
+  }
   //
   // We must be trying to remove one if Alias is NULL
 …
     // remove an alias (but passed in COMMAND parameter)
     //
     return (gRT->SetVariable((CHAR16*)Command, &gShellAliasGuid, 0, 0, NULL));
+    Status = (gRT->SetVariable((CHAR16*)Command, &gShellAliasGuid, 0, 0, NULL));
   } else {
     //
 …
     gRT->SetVariable((CHAR16*)Command, &gShellAliasGuid, 0, 0, NULL);
+    return (gRT->SetVariable((CHAR16*)Alias, &gShellAliasGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS|(Volatile?0:EFI_VARIABLE_NON_VOLATILE), StrSize(Command), (VOID*)Command));
+  }
+    Status = (gRT->SetVariable((CHAR16*)Alias, &gShellAliasGuid, EFI_VARIABLE_BOOTSERVICE_ACCESS|(Volatile?0:EFI_VARIABLE_NON_VOLATILE), StrSize(Command), (VOID*)Command));
+  }
+  if (Alias != NULL) {
+    FreePool (AliasLower);
+  }
+  return Status;
+}
 …
   @retval EFI_ACCESS_DENIED     The alias is a built-in alias or already existed and Replace was set to
                                 FALSE.
+  @retval EFI_INVALID_PARAMETER Command is null or the empty string.
 **/
 EFI_STATUS
 …
+  )
+{
-  //
-  // cant set over a built in alias
-  //
   if (ShellCommandIsOnAliasList(Alias==NULL?Command:Alias)) {
+    //
+    // cant set over a built in alias
+    //
     return (EFI_ACCESS_DENIED);
+  }
+  if (Command == NULL || *Command == CHAR_NULL || StrLen(Command) == 0) {
+  } else if (Command == NULL || *Command == CHAR_NULL || StrLen(Command) == 0) {
+    //
+    // Command is null or empty
+    //
     return (EFI_INVALID_PARAMETER);
+  }
+  if (EfiShellGetAlias(Command, NULL) != NULL && !Replace) {
+  } else if (EfiShellGetAlias(Command, NULL) != NULL && !Replace) {
+    //
+    // Alias already exists, Replace not set
+    //
     return (EFI_ACCESS_DENIED);
+  }
   return (InternalSetAlias(Command, Alias, Volatile));
+  } else {
+    return (InternalSetAlias(Command, Alias, Volatile));
+  }
+}
 …
   NULL,
   SHELL_MAJOR_VERSION,
+  SHELL_MINOR_VERSION
+  SHELL_MINOR_VERSION,
+  // New for UEFI Shell 2.1
+  EfiShellRegisterGuidName,
+  EfiShellGetGuidName,
+  EfiShellGetGuidFromName,
+  EfiShellGetEnvEx
 };
 …
+  )
+{
+//  ShellPrintEx(-1,-1,L"  <Notify>  ");
    if ((KeyData->Key.UnicodeChar == L'c' || KeyData->Key.UnicodeChar == 3) &&
       (KeyData->KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED) || KeyData->KeyState.KeyShiftState  == (EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED))
+  if ( ((KeyData->Key.UnicodeChar == L'c') &&
+        (KeyData->KeyState.KeyShiftState == (EFI_SHIFT_STATE_VALID|EFI_LEFT_CONTROL_PRESSED) || KeyData->KeyState.KeyShiftState  == (EFI_SHIFT_STATE_VALID|EFI_RIGHT_CONTROL_PRESSED))) ||
+      (KeyData->Key.UnicodeChar == 3)
       ){
     if (ShellInfoObject.NewEfiShellProtocol->ExecutionBreak == NULL) {
 …
   return (Status);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Application/Shell/ShellProtocol.h

-              r48674
+              r58459
   manipulation, and initialization of EFI_SHELL_PROTOCOL.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #define _SHELL_PROTOCOL_HEADER_
+#include <Uefi.h>
+#include <ShellBase.h>
+#include <Guid/ShellVariableGuid.h>
+#include <Guid/ShellMapGuid.h>
+#include <Guid/ShellAliasGuid.h>
+#include <Protocol/EfiShell.h>
+#include <Protocol/EfiShellParameters.h>
+#include <Protocol/SimpleFileSystem.h>
+#include <Protocol/DevicePathToText.h>
+#include <Protocol/ComponentName2.h>
+#include <Protocol/LoadedImage.h>
+#include <Protocol/UnicodeCollation.h>
+#include <Protocol/DevicePath.h>
+#include <Protocol/SimpleTextInEx.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/BaseLib.h>
+#include <Library/ShellCommandLib.h>
+#include <Library/PrintLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/UefiRuntimeServicesTableLib.h>
+#include <Library/DebugLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/BaseMemoryLib.h>
+#include <Library/UefiLib.h>
+#include <Library/SortLib.h>
+#include <Library/PcdLib.h>
+#include <Library/ShellLib.h>
+#include "FileHandleWrappers.h"
+#include "ShellEnvVar.h"
+#include "ShellManParser.h"
+#include "Shell.h"
 typedef struct {
 …
   internal worker function to run a command via Device Path
   @param ParentImageHandle  A handle of the image that is executing the specified
                             command line.
   @param DevicePath         device path of the file to execute
   @param CommandLine        Points to the NULL-terminated UCS-2 encoded string
                             containing the command line. If NULL then the command-
                             line will be empty.
   @param Environment        Points to a NULL-terminated array of environment
                             variables with the format 'x=y', where x is the
                             environment variable name and y is the value. If this
                             is NULL, then the current shell environment is used.
   @param StatusCode         Points to the status code returned by the command.
+  @param ParentImageHandle      A handle of the image that is executing the specified
+                                command line.
+  @param DevicePath             device path of the file to execute
+  @param CommandLine            Points to the NULL-terminated UCS-2 encoded string
+                                containing the command line. If NULL then the command-
+                                line will be empty.
+  @param Environment            Points to a NULL-terminated array of environment
+                                variables with the format 'x=y', where x is the
+                                environment variable name and y is the value. If this
+                                is NULL, then the current shell environment is used.
+  @param[out] StartImageStatus  Returned status from gBS->StartImage.
   @retval EFI_SUCCESS       The command executed successfully. The  status code
 …
 EFIAPI
 InternalShellExecuteDevicePath(
   IN CONST EFI_HANDLE *ParentImageHandle,
+  IN CONST EFI_HANDLE               *ParentImageHandle,
   IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,
   IN CONST CHAR16 *CommandLine OPTIONAL,
   IN CONST CHAR16 **Environment OPTIONAL,
   OUT EFI_STATUS *StatusCode OPTIONAL
+  IN CONST CHAR16                   *CommandLine OPTIONAL,
+  IN CONST CHAR16                   **Environment OPTIONAL,
+  OUT EFI_STATUS                    *StartImageStatus OPTIONAL
   );
 …
   @param[in] BasePath         the Path to prepend onto filename for FullPath
   @param[in] Status           Status member initial value.
-  @param[in] FullName         FullName member initial value.
   @param[in] FileName         FileName member initial value.
   @param[in] Handle           Handle member initial value.
 …
   IN CONST CHAR16 *BasePath,
   IN CONST EFI_STATUS Status,
-  IN CONST CHAR16 *FullName,
   IN CONST CHAR16 *FileName,
   IN CONST SHELL_FILE_HANDLE Handle,
 …
   @param Name                   A pointer to the environment variable name
   @return !=NULL                The environment variable's value. The returned
+  @retval !=NULL                The environment variable's value. The returned
                                 pointer does not need to be freed by the caller.
   @retval NULL                  The environment variable doesn't exist.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Guid/ShellAliasGuid.h

r48674	r58459
24	24
25	25	#endif
26

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Guid/ShellLibHiiGuid.h

-              r48674
+              r58459
 xf3d301bb, 0xf4a5, 0x45a8, { 0xb0, 0xb7, 0xfa, 0x99, 0x9c, 0x62, 0x37, 0xae } \
+  }
+#define SHELL_BCFG_HII_GUID \
+  { \
+x5f5f605d, 0x1583, 0x4a2d, {0xa6, 0xb2, 0xeb, 0x12, 0xda, 0xb4, 0xa2, 0xb6 } \
+  }
 extern EFI_GUID gHandleParsingHiiGuid;
 …
 extern EFI_GUID gShellLevel3HiiGuid;
 extern EFI_GUID gShellNetwork1HiiGuid;
+extern EFI_GUID gShellBcfgHiiGuid;
 #endif

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Library/HandleParsingLib.h

-              r48674
+              r58459
   Provides interface to advanced shell functionality for parsing both handle and protocol database.
   Copyright (c) 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Function to add a new GUID/Name mapping.
+  This cannot overwrite an existing mapping.
+  @param[in] Guid       The Guid
+  @param[in] TheName    The Guid's name
+  @param[in] Lang       RFC4646 language code list or NULL
+  @retval EFI_SUCCESS           The operation was sucessful
+  @retval EFI_ACCESS_DENIED     There was a duplicate
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
+**/
+EFI_STATUS
+EFIAPI
+AddNewGuidNameMapping(
+  IN CONST EFI_GUID *Guid,
+  IN CONST CHAR16   *TheName,
+  IN CONST CHAR8    *Lang OPTIONAL
+  );
+/**
   Function to get the name of a protocol or struct from it's GUID.
 …
   Function to get the Guid for a protocol or struct based on it's string name.
+  Do not free or modify the returned GUID.
   @param[in] Name           The pointer to the string name.
   @param[in] Lang           The pointer to the language code (string).
   @param[in] Guid           The pointer to the pointer to the Guid.
+  @param[out] Guid          The pointer to the pointer to the Guid.
   @retval EFI_SUCCESS       The operation was successful.
 …
   IN CONST CHAR16 *Name,
   IN CONST CHAR8  *Lang OPTIONAL,
   IN EFI_GUID     **Guid
+  OUT EFI_GUID    **Guid
   );
 …
   IN CONST EFI_HANDLE TheHandle,
   IN CONST CHAR8      *Language
+  );
+/**
+  Get best support language for this driver.
+  First base on the user input language  to search, second base on the current
+  platform used language to search, third get the first language from the
+  support language list. The caller need to free the buffer of the best language.
+  @param[in] SupportedLanguages      The support languages for this driver.
+  @param[in] InputLanguage           The user input language.
+  @param[in] Iso639Language          Whether get language for ISO639.
+  @return                            The best support language for this driver.
+**/
+CHAR8 *
+EFIAPI
+GetBestLanguageForDriver (
+  IN CONST CHAR8  *SupportedLanguages,
+  IN CONST CHAR8  *InputLanguage,
+  IN BOOLEAN      Iso639Language
   );

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Library/ShellCommandLib.h

-              r48674
+              r58459
   This library will not funciton if it is used for UEFI Shell 2.0 Applications.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Protocol/EfiShellParameters.h>
 #include <Protocol/UnicodeCollation.h>
-#include <Protocol/DevicePathToText.h>
 #include <Protocol/SimpleFileSystem.h>
 …
 //
 extern        EFI_UNICODE_COLLATION_PROTOCOL    *gUnicodeCollation;
-extern        EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *gDevPathToText;
 extern        CONST CHAR16*                     SupportLevel[];
 …
 /**
+  Add mappings for any devices without one.  Do not change any existing maps.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellCommandUpdateMapping (
+  VOID
+  );
+/**
   Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Library/ShellLib.h

-              r48674
+              r58459
   Provides interface to shell functionality for shell commands and applications.
   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Function return the number converted from a hex representation of a number.
+  Note: this function cannot be used when (UINTN)(-1), (0xFFFFFFFF) may be a valid
+  result.  Use ShellConvertStringToUint64 instead.
+  @param[in] String   String representation of a number.
+  @return             The unsigned integer result of the conversion.
+  @retval (UINTN)(-1) An error occured.
+**/
+UINTN
+EFIAPI
+ShellHexStrToUintn(
+  IN CONST CHAR16 *String
+  );
+/**
   Safely append with automatic string resizing given length of Destination and
   desired length of copy from Source.
 …
   );
+/**
+  Function to delete a file by name
+  @param[in]       FileName       Pointer to file name to delete.
+  @retval EFI_SUCCESS             the file was deleted sucessfully
+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
+                                  deleted
+  @retval EFI_INVALID_PARAMETER   One of the parameters has an invalid value.
+  @retval EFI_NOT_FOUND           The specified file could not be found on the
+                                  device or the file system could not be found
+                                  on the device.
+  @retval EFI_NO_MEDIA            The device has no medium.
+  @retval EFI_MEDIA_CHANGED       The device has a different medium in it or the
+                                  medium is no longer supported.
+  @retval EFI_DEVICE_ERROR        The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED    The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED     The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED       The file was opened read only.
+  @retval EFI_OUT_OF_RESOURCES    Not enough resources were available to open the
+                                  file.
+  @retval other                   The file failed to open
+**/
+EFI_STATUS
+EFIAPI
+ShellDeleteFileByName(
+  IN CONST CHAR16               *FileName
+  );
+/**
+  Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.
+  @param[in] CommandToGetHelpOn  Pointer to a string containing the command name of help file to be printed.
+  @param[in] SectionToGetHelpOn  Pointer to the section specifier(s).
+  @param[in] PrintCommandText    If TRUE, prints the command followed by the help content, otherwise prints
+                                 the help content only.
+  @retval EFI_DEVICE_ERROR       The help data format was incorrect.
+  @retval EFI_NOT_FOUND          The help data could not be found.
+  @retval EFI_SUCCESS            The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellPrintHelp (
+  IN CONST CHAR16     *CommandToGetHelpOn,
+  IN CONST CHAR16     *SectionToGetHelpOn,
+  IN BOOLEAN          PrintCommandText
+  );
 #endif // __SHELL_LIB__

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Protocol/EfiShell.h

-              r48674
+              r58459
   EFI Shell protocol as defined in the UEFI Shell 2.0 specification including errata.
+  Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Gets the environment variable and Attributes, or list of environment variables.  Can be
+  used instead of GetEnv().
+  This function returns the current value of the specified environment variable and
+  the Attributes. If no variable name was specified, then all of the known
+  variables will be returned.
+  @param[in] Name               A pointer to the environment variable name. If Name is NULL,
+                                then the function will return all of the defined shell
+                                environment variables. In the case where multiple environment
+                                variables are being returned, each variable will be terminated
+                                by a NULL, and the list will be terminated by a double NULL.
+  @param[out] Attributes        If not NULL, a pointer to the returned attributes bitmask for
+                                the environment variable. In the case where Name is NULL, and
+                                multiple environment variables are being returned, Attributes
+                                is undefined.
+  @retval NULL                  The environment variable doesn't exist.
+  @return                       The environment variable's value. The returned pointer does not
+                                need to be freed by the caller.
+**/
+typedef
+CONST CHAR16 *
+(EFIAPI *EFI_SHELL_GET_ENV_EX) (
+  IN  CONST CHAR16 *Name,
+  OUT       UINT32 *Attributes OPTIONAL
+  );
+/**
   Gets the file information from an open file handle.
 …
   IN SHELL_FILE_HANDLE FileHandle,
   OUT UINT64 *Size
+  );
+/**
+  Get the GUID value from a human readable name.
+  If GuidName is a known GUID name, then update Guid to have the correct value for
+  that GUID.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in]  GuidName   A pointer to the localized name for the GUID being queried.
+  @param[out] Guid       A pointer to the GUID structure to be filled in.
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           GuidName is not a known GUID Name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_GUID_FROM_NAME)(
+  IN  CONST CHAR16   *GuidName,
+  OUT       EFI_GUID *Guid
+  );
+/**
+  Get the human readable name for a GUID from the value.
+  If Guid is assigned a name, then update *GuidName to point to the name. The callee
+  should not modify the value.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in]  Guid       A pointer to the GUID being queried.
+  @param[out] GuidName   A pointer to a pointer the localized to name for the GUID being requested
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_NOT_FOUND           Guid is not assigned a name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_GET_GUID_NAME)(
+  IN  CONST EFI_GUID *Guid,
+  OUT CONST CHAR16   **GuidName
   );
 …
 /**
+  Register a GUID and a localized human readable name for it.
+  If Guid is not assigned a name, then assign GuidName to Guid.  This list of GUID
+  names must be used whenever a shell command outputs GUID information.
+  This function is only available when the major and minor versions in the
+  EfiShellProtocol are greater than or equal to 2 and 1, respectively.
+  @param[in] Guid       A pointer to the GUID being registered.
+  @param[in] GuidName   A pointer to the localized name for the GUID being registered.
+  @retval EFI_SUCCESS             The operation was successful.
+  @retval EFI_INVALID_PARAMETER   Guid was NULL.
+  @retval EFI_INVALID_PARAMETER   GuidName was NULL.
+  @retval EFI_ACCESS_DENIED       Guid already is assigned a name.
+**/
+typedef
+EFI_STATUS
+(EFIAPI *EFI_SHELL_REGISTER_GUID_NAME)(
+  IN CONST EFI_GUID *Guid,
+  IN CONST CHAR16   *GuidName
+  );
+/**
   Deletes the duplicate file names files in the given file list.
 …
   );
+//
+// EFI_SHELL_PROTOCOL has been updated since UEFI Shell Spec 2.0
+// Usage of this protocol will require version checking before attempting
+// to use any new members.  There is no need to check the version for
+// members that existed in UEFI Shell Spec 2.0.
+//
+// Update below for any future UEFI Shell spec changes to this protocol.
+//
+// Check EFI_SHELL_PROTOCOL MajorVersion and MinorVersion:
+// if ((2 == gEfiShellProtocol->MajorVersion) &&
+//     (0 == gEfiShellProtocol->MinorVersion)) {
+//   //
+//   // Cannot call:
+//   // RegisterGuidName - UEFI Shell 2.1
+//   // GetGuidName      - UEFI Shell 2.1
+//   // GetGuidFromName  - UEFI Shell 2.1
+//   // GetEnvEx         - UEFI Shell 2.1
+//   //
+// } else {
+//   //
+//   // Can use all members
+//   //
+// }
+//
 typedef struct _EFI_SHELL_PROTOCOL {
   EFI_SHELL_EXECUTE                         Execute;
 …
   UINT32                                    MajorVersion;
   UINT32                                    MinorVersion;
+  // Added for Shell 2.1
+  EFI_SHELL_REGISTER_GUID_NAME              RegisterGuidName;
+  EFI_SHELL_GET_GUID_NAME                   GetGuidName;
+  EFI_SHELL_GET_GUID_FROM_NAME              GetGuidFromName;
+  EFI_SHELL_GET_ENV_EX                      GetEnvEx;
 } EFI_SHELL_PROTOCOL;
 …
 enum ShellVersion {
   SHELL_MAJOR_VERSION = 2,
   SHELL_MINOR_VERSION = 0
+  SHELL_MINOR_VERSION = 1
 };

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/Protocol/EfiShellEnvironment2.h

-              r48674
+              r58459
 /**
   This function determins whether a script file is currently being processed.
+  This function determines whether a script file is currently being processed.
   A script file (.nsh file) can contain a series of commands and this is useful to
 …
 /**
   This function determins if the shell application should break.
+  This function determines if the shell application should break.
   This is used to inform a shell application that a break condition has been
 …
 /**
   This function determins if the caller is running under the root shell.
+  This function determines if the caller is running under the root shell.
   @retval TRUE                  The caller is running under the root shell.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Include/ShellBase.h

r48674	r58459
155	155	}SHELL_STATUS;
156	156
157		#endif //__SHELL_BASE__
158
	157	#endif //__SHELL_BASE_

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/BasePathLib/BasePathLib.c

-              r48674
+              r58459
   Provides interface to path manipulation functions.
   Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/PathLib.h>
 #include <Library/BaseLib.h>
+#include <Protocol/SimpleTextIn.h>
 /**
 …
+  }
+  while ((TempString = StrStr(Path, L"\\\\")) != NULL) {
+    *TempString = CHAR_NULL;
+    TempString  += 1;
+    TempSize = StrSize(TempString);
+    CopyMem(Path+StrLen(Path), TempString, TempSize);
+  }
+  if ((TempString = StrStr(Path, L"\\\\")) != NULL && *(TempString + 1) == CHAR_NULL) {
+    *(TempString) = CHAR_NULL;
+  }
   return (Path);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiFileHandleLib/UefiFileHandleLib.c

-              r48674
+              r58459
   Provides interface to EFI_FILE_HANDLE functionality.
   Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
     // if we got an error free the memory and return NULL
     //
     if (EFI_ERROR(Status)) {
+    if (EFI_ERROR(Status) && (FileInfo != NULL)) {
       FreePool(FileInfo);
       return NULL;
+      FileInfo = NULL;
+    }
+  }
 …
+{
+  //
+  // ASSERT if the FileHandle or FileInfo is NULL
+  //
+  ASSERT (FileHandle != NULL);
+  ASSERT (FileInfo   != NULL);
+  if (FileHandle == NULL || FileInfo == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
+  )
+{
+  //
+  // ASSERT if FileHandle is NULL
+  //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
+  )
+{
   //
   // ASSERT if FileHandle is NULL
   //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the write based on EFI_FILE_PROTOCOL
 …
+{
   EFI_STATUS Status;
+  //
+  // ASSERT if FileHandle is NULL
+  //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the Close based on EFI_FILE_PROTOCOL
 …
+{
   EFI_STATUS Status;
+  //
+  // ASSERT if FileHandle is NULL
+  //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the Delete based on EFI_FILE_PROTOCOL
 …
+  )
+{
   //
   // ASSERT if FileHandle is NULL
   //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the SetPosition based on EFI_FILE_PROTOCOL
 …
+  )
+{
+  if (Position == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
+  //
+  // ASSERT if FileHandle is NULL
+  //
+  ASSERT (FileHandle != NULL);
+  if (Position == NULL || FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the GetPosition based on EFI_FILE_PROTOCOL
 …
+  )
+{
   //
   // ASSERT if FileHandle is NULL
   //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
   // Perform the Flush based on EFI_FILE_PROTOCOL
 …
   function to determine if a given handle is a directory handle
   if DirHandle is NULL then ASSERT()
+  if DirHandle is NULL then return error
   open the file information on the DirHandle and verify that the Attribute
 …
   EFI_FILE_INFO *DirInfo;
+  //
+  // ASSERT if DirHandle is NULL
+  //
+  ASSERT(DirHandle != NULL);
+  if (DirHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
   Status = FileHandleRead (DirHandle, &BufferSize, *Buffer);
   ASSERT(Status != EFI_BUFFER_TOO_SMALL);
   if (EFI_ERROR(Status)) {
+  if (EFI_ERROR(Status) || BufferSize == 0) {
     FreePool(*Buffer);
     *Buffer = NULL;
+    if (BufferSize == 0) {
+      return (EFI_NOT_FOUND);
+    }
     return (Status);
+  }
 …
   UINTN         BufferSize;
+  //
+  // ASSERTs for DirHandle or Buffer or NoFile poitners being NULL
+  //
+  ASSERT (DirHandle != NULL);
+  ASSERT (Buffer    != NULL);
+  ASSERT (NoFile    != NULL);
+  if (DirHandle == NULL || Buffer == NULL || NoFile == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
   Retrieve the size of a file.
   if FileHandle is NULL then ASSERT()
   if Size is NULL then ASSERT()
+  if FileHandle is NULL then return error
+  if Size is NULL then return error
   This function extracts the file size info from the FileHandle's EFI_FILE_INFO
 …
   EFI_FILE_INFO                 *FileInfo;
+  //
+  // ASSERT for FileHandle or Size being NULL
+  //
+  ASSERT (FileHandle != NULL);
+  ASSERT (Size != NULL);
+  if (FileHandle == NULL || Size == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
   Set the size of a file.
   If FileHandle is NULL then ASSERT().
+  If FileHandle is NULL then return error.
   This function changes the file size info from the FileHandle's EFI_FILE_INFO
 …
   EFI_STATUS                    Status;
+  //
+  // ASSERT for FileHandle or Size being NULL
+  //
+  ASSERT (FileHandle != NULL);
+  if (FileHandle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
   //
 …
   Destination.
   if Destination is NULL, then ASSERT()
+  if Destination is NULL, then return error
   if Destination's current length (including NULL terminator) is already more then
   CurrentSize, then ASSERT()
 …
   UINTN CopySize;
+  //
+  // ASSERTs
+  //
+  ASSERT(Destination != NULL);
+  if (Destination == NULL) {
+    return (NULL);
+  }
   //
 …
   if (Handle == NULL
     ||Size   == NULL
+    ||(Buffer==NULL&&*Size!=0)
    ){
     return (EFI_INVALID_PARAMETER);
+  }
+  if (Buffer == NULL) {
+    ASSERT(*Size == 0);
+  } else {
+  if (Buffer != NULL) {
     *Buffer = CHAR_NULL;
+  }
 …
   function to write a line of unicode text to a file.
   if Handle is NULL, ASSERT.
+  if Handle is NULL, return error.
   if Buffer is NULL, do nothing.  (return SUCCESS)
 …
   UINTN      Size;
-  ASSERT(Handle != NULL);
   if (Buffer == NULL) {
     return (EFI_SUCCESS);
+  }
+  if (Handle == NULL) {
+    return (EFI_INVALID_PARAMETER);
+  }
 …
   //
   Buffer = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));
+  ASSERT (Buffer != NULL);
+  if (Buffer == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
   //
 …
   This will NOT work on directories.
   If Handle is NULL, then ASSERT.
+  If Handle is NULL, then return False.
   @param[in] Handle     the file handle
 …
   BOOLEAN       RetVal;
+  //
+  // ASSERT if Handle is NULL
+  //
+  ASSERT(Handle != NULL);
+  if (Handle == NULL) {
+    return (FALSE);
+  }
   FileHandleGetPosition(Handle, &Pos);
   Info = FileHandleGetInfo (Handle);
-  ASSERT(Info != NULL);
-  FileHandleSetPosition(Handle, Pos);
   if (Info == NULL) {
     return (FALSE);
+  }
+  FileHandleSetPosition(Handle, Pos);
   if (Pos == Info->FileSize) {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf

-              r48674
+              r58459
 # Provides interface to shell functionality for shell commands and applications.
+#
 # Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved. <BR>
+#   Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   MODULE_TYPE                    = DXE_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = FileHandleLib|DXE_DRIVER UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = FileHandleLib|DXE_DRIVER UEFI_APPLICATION UEFI_DRIVER DXE_RUNTIME_DRIVER
+#
 …
 [Protocols]
   gEfiSimpleFileSystemProtocolGuid             # ALWAYS_USED
+  gEfiSimpleFileSystemProtocolGuid              ## SOMETIMES_CONSUMES
 [Guids]
   gEfiFileInfoGuid                              # ALWAYS_CONSUMED
+  gEfiFileInfoGuid                              ## SOMETIMES_CONSUMES ## GUID
 [Pcd.common]
   gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize ## SOMETIMES_CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.c

-              r48674
+              r58459
   Provides interface to advanced shell functionality for parsing both handle and protocol database.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiHandleParsingLib.h"
+EFI_HANDLE mHandleParsingHiiHandle;
+#include "IndustryStandard/Acpi10.h"
+EFI_HANDLE        mHandleParsingHiiHandle = NULL;
 HANDLE_INDEX_LIST mHandleList = {{{NULL,NULL},0,0},0};
+GUID_INFO_BLOCK   *GuidList;
+UINTN             GuidListCount;
+/**
+  Function to translate the EFI_MEMORY_TYPE into a string.
+  @param[in] Memory     The memory type.
+  @retval               A string representation of the type allocated from BS Pool.
+**/
+CHAR16*
+EFIAPI
+ConvertMemoryType (
+  IN CONST EFI_MEMORY_TYPE Memory
+  )
+{
+  CHAR16 *RetVal;
+  RetVal = NULL;
+  switch (Memory) {
+  case EfiReservedMemoryType:       StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0);        break;
+  case EfiLoaderCode:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0);                break;
+  case EfiLoaderData:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0);                break;
+  case EfiBootServicesCode:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0);          break;
+  case EfiBootServicesData:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0);          break;
+  case EfiRuntimeServicesCode:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0);       break;
+  case EfiRuntimeServicesData:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0);       break;
+  case EfiConventionalMemory:       StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0);        break;
+  case EfiUnusableMemory:           StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0);            break;
+  case EfiACPIReclaimMemory:        StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0);         break;
+  case EfiACPIMemoryNVS:            StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0);             break;
+  case EfiMemoryMappedIO:           StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0);            break;
+  case EfiMemoryMappedIOPortSpace:  StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0);   break;
+  case EfiPalCode:                  StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0);                   break;
+  case EfiMaxMemoryType:            StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0);             break;
+  default: ASSERT(FALSE);
+  }
+  return (RetVal);
+}
+/**
+  Function to translate the EFI_GRAPHICS_PIXEL_FORMAT into a string.
+  @param[in] Fmt     The format type.
+  @retval               A string representation of the type allocated from BS Pool.
+**/
+CHAR16*
+EFIAPI
+ConvertPixelFormat (
+  IN CONST EFI_GRAPHICS_PIXEL_FORMAT Fmt
+  )
+{
+  CHAR16 *RetVal;
+  RetVal = NULL;
+  switch (Fmt) {
+  case PixelRedGreenBlueReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelRedGreenBlueReserved8BitPerColor", 0);  break;
+  case PixelBlueGreenRedReserved8BitPerColor: StrnCatGrow(&RetVal, NULL, L"PixelBlueGreenRedReserved8BitPerColor", 0);  break;
+  case PixelBitMask:                          StrnCatGrow(&RetVal, NULL, L"PixelBitMask", 0);                           break;
+  case PixelBltOnly:                          StrnCatGrow(&RetVal, NULL, L"PixelBltOnly", 0);                           break;
+  case PixelFormatMax:                        StrnCatGrow(&RetVal, NULL, L"PixelFormatMax", 0);                         break;
+  default: ASSERT(FALSE);
+  }
+  return (RetVal);
+}
 /**
 …
+  )
+{
+  mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);
+  GuidListCount = 0;
+  GuidList      = NULL;
+  //
+  // Do nothing with mHandleParsingHiiHandle.  Initialize HII as needed.
+  //
+  return (EFI_SUCCESS);
+}
+/**
+  Initialization function for HII packages.
+**/
+VOID
+HandleParsingHiiInit (VOID)
+{
   if (mHandleParsingHiiHandle == NULL) {
+    return (EFI_DEVICE_ERROR);
+  }
+  return (EFI_SUCCESS);
+    mHandleParsingHiiHandle = HiiAddPackages (&gHandleParsingHiiGuid, gImageHandle, UefiHandleParsingLibStrings, NULL);
+    ASSERT (mHandleParsingHiiHandle != NULL);
+  }
+}
 …
+  )
+{
+  UINTN                 LoopCount;
+  for (LoopCount = 0; GuidList != NULL && LoopCount < GuidListCount; LoopCount++) {
+    SHELL_FREE_NON_NULL(GuidList[LoopCount].GuidId);
+  }
+  SHELL_FREE_NON_NULL(GuidList);
   if (mHandleParsingHiiHandle != NULL) {
     HiiRemovePackages(mHandleParsingHiiHandle);
 …
+}
+/*
+/**
+  Function to dump information about LoadedImage.
+  This will allocate the return buffer from boot services pool.
+  @param[in] TheHandle      The handle that has LoadedImage installed.
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.
+  @retval A poitner to a string containing the information.
+**/
 CHAR16*
 EFIAPI
 …
+  )
+{
   EFI_LOADED_IMAGE_PROTOCOL         *Image;
+  EFI_LOADED_IMAGE_PROTOCOL         *LoadedImage;
   EFI_STATUS                        Status;
+  EFI_DEVICE_PATH_PROTOCOL          *DevPath;
+  EFI_DEVICE_PATH_PROTOCOL          *DevPathNode;
+  VOID                              *Buffer;
+  UINTN                             BufferSize;
+  UINT32                            AuthenticationStatus;
+  EFI_GUID                          *NameGuid;
+  EFI_FIRMWARE_VOLUME_PROTOCOL      *FV;
+  EFI_FIRMWARE_VOLUME2_PROTOCOL     *FV2;
+  FV          = NULL;
+  FV2         = NULL;
+  Buffer      = NULL;
+  BufferSize  = 0;
+  Status      = HandleProtocol (
+  CHAR16                            *RetVal;
+  CHAR16                            *Temp;
+  CHAR16                            *CodeType;
+  CHAR16                            *DataType;
+  if (!Verbose) {
+    return (CatSPrint(NULL, L"LoadedImage"));
+  }
+  HandleParsingHiiInit();
+  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_LI_DUMP_MAIN), NULL);
+  RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));
+  if (Temp == NULL || RetVal == NULL) {
+    SHELL_FREE_NON_NULL(Temp);
+    SHELL_FREE_NON_NULL(RetVal);
+    return NULL;
+  }
+  Status = gBS->OpenProtocol (
+                TheHandle,
+                &gEfiLoadedImageProtocolGuid,
+                (VOID**)&LoadedImage,
+                gImageHandle,
+                NULL,
+                EFI_OPEN_PROTOCOL_GET_PROTOCOL
+               );
+  if (EFI_ERROR (Status)) {
+    SHELL_FREE_NON_NULL (Temp);
+    SHELL_FREE_NON_NULL (RetVal);
+    return NULL;
+  }
+  DataType = ConvertMemoryType(LoadedImage->ImageDataType);
+  CodeType = ConvertMemoryType(LoadedImage->ImageCodeType);
+  RetVal = CatSPrint(RetVal,
+                      Temp,
+                      LoadedImage->Revision,
+                      LoadedImage->ParentHandle,
+                      LoadedImage->SystemTable,
+                      LoadedImage->DeviceHandle,
+                      LoadedImage->FilePath,
+                      LoadedImage->LoadOptionsSize,
+                      LoadedImage->LoadOptions,
+                      LoadedImage->ImageBase,
+                      LoadedImage->ImageSize,
+                      CodeType,
+                      DataType,
+                      LoadedImage->Unload);
+  SHELL_FREE_NON_NULL(Temp);
+  SHELL_FREE_NON_NULL(CodeType);
+  SHELL_FREE_NON_NULL(DataType);
+  return RetVal;
+}
+/**
+  Function to dump information about GOP.
+  This will allocate the return buffer from boot services pool.
+  @param[in] TheHandle      The handle that has LoadedImage installed.
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.
+  @retval A poitner to a string containing the information.
+**/
+CHAR16*
+EFIAPI
+GraphicsOutputProtocolDumpInformation(
+  IN CONST EFI_HANDLE TheHandle,
+  IN CONST BOOLEAN    Verbose
+  )
+{
+  EFI_GRAPHICS_OUTPUT_PROTOCOL      *GraphicsOutput;
+  EFI_STATUS                        Status;
+  CHAR16                            *RetVal;
+  CHAR16                            *Temp;
+  CHAR16                            *Fmt;
+  if (!Verbose) {
+    return (CatSPrint(NULL, L"GraphicsOutput"));
+  }
+  HandleParsingHiiInit();
+  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_GOP_DUMP_MAIN), NULL);
+  RetVal = AllocateZeroPool (PcdGet16 (PcdShellPrintBufferSize));
+  if (Temp == NULL || RetVal == NULL) {
+    SHELL_FREE_NON_NULL(Temp);
+    SHELL_FREE_NON_NULL(RetVal);
+    return NULL;
+  }
+  Status = gBS->OpenProtocol (
+                TheHandle,
+                &gEfiGraphicsOutputProtocolGuid,
+                (VOID**)&GraphicsOutput,
+                gImageHandle,
+                NULL,
+                EFI_OPEN_PROTOCOL_GET_PROTOCOL
+               );
+  if (EFI_ERROR (Status)) {
+    SHELL_FREE_NON_NULL (Temp);
+    SHELL_FREE_NON_NULL (RetVal);
+    return NULL;
+  }
+  Fmt = ConvertPixelFormat(GraphicsOutput->Mode->Info->PixelFormat);
+  RetVal = CatSPrint(RetVal,
+                      Temp,
+                      GraphicsOutput->Mode->MaxMode,
+                      GraphicsOutput->Mode->Mode,
+                      GraphicsOutput->Mode->FrameBufferBase,
+                      (UINT64)GraphicsOutput->Mode->FrameBufferSize,
+                      (UINT64)GraphicsOutput->Mode->SizeOfInfo,
+                      GraphicsOutput->Mode->Info->Version,
+                      GraphicsOutput->Mode->Info->HorizontalResolution,
+                      GraphicsOutput->Mode->Info->VerticalResolution,
+                      Fmt,
+                      GraphicsOutput->Mode->Info->PixelsPerScanLine,
+                      GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.RedMask,
+                      GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.GreenMask,
+                      GraphicsOutput->Mode->Info->PixelFormat!=PixelBitMask?0:GraphicsOutput->Mode->Info->PixelInformation.BlueMask
+                      );
+  SHELL_FREE_NON_NULL(Temp);
+  SHELL_FREE_NON_NULL(Fmt);
+  return RetVal;
+}
+/**
+  Function to dump information about PciRootBridgeIo.
+  This will allocate the return buffer from boot services pool.
+  @param[in] TheHandle      The handle that has PciRootBridgeIo installed.
+  @param[in] Verbose        TRUE for additional information, FALSE otherwise.
+  @retval A poitner to a string containing the information.
+**/
+CHAR16*
+EFIAPI
+PciRootBridgeIoDumpInformation(
+  IN CONST EFI_HANDLE TheHandle,
+  IN CONST BOOLEAN    Verbose
+  )
+{
+  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL   *PciRootBridgeIo;
+  EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Configuration;
+  UINT64                            Supports;
+  UINT64                            Attributes;
+  CHAR16                            *Temp;
+  CHAR16                            *Temp2;
+  CHAR16                            *RetVal;
+  EFI_STATUS                        Status;
+  RetVal  = NULL;
+  if (!Verbose) {
+    return (CatSPrint(NULL, L"PciRootBridgeIo"));
+  }
+  HandleParsingHiiInit();
+  Status = gBS->HandleProtocol(
     TheHandle,
+    &gEfiLoadedImageProtocolGuid,
+    &Image);
+  ASSERT_EFI_ERROR(Status);
+  DevPath     = UnpackDevicePath (Image->FilePath);
+  if (DevPath == NULL) {
+    &gEfiPciRootBridgeIoProtocolGuid,
+    (VOID**)&PciRootBridgeIo);
+  if (EFI_ERROR(Status)) {
     return NULL;
+  }
+  DevPathNode = DevPath;
+  while (!IsDevicePathEnd (DevPathNode)) {
+    //
+    // Find the Fv File path
+    //
+    NameGuid = GetNameGuidFromFwVolDevicePathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevPathNode);
+    if (NameGuid != NULL) {
+      Status = BS->HandleProtocol (
+                    Image->DeviceHandle,
+                    &gEfiFirmwareVolumeProtocolGuid,
+                    &FV
+                   );
+      if (!EFI_ERROR (Status)) {
+        Status = FV->ReadSection (
+                      FV,
+                      NameGuid,
+                      EFI_SECTION_USER_INTERFACE,
+,
+                      &Buffer,
+                      &BufferSize,
+                      &AuthenticationStatus
+                     );
+        if (!EFI_ERROR (Status)) {
+          break;
+        }
+        Buffer = NULL;
+      } else {
+        Status = BS->HandleProtocol (
+                      Image->DeviceHandle,
+                      &gEfiFirmwareVolume2ProtocolGuid,
+                      &FV2
+                     );
+        if (!EFI_ERROR (Status)) {
+          Status = FV2->ReadSection (
+                          FV2,
+                          NameGuid,
+                          EFI_SECTION_USER_INTERFACE,
+,
+                          &Buffer,
+                          &BufferSize,
+                          &AuthenticationStatus
+                         );
+          if (!EFI_ERROR (Status)) {
+            break;
+          }
+          Buffer = NULL;
+        }
+  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_PH), NULL);
+  ASSERT (Temp != NULL);
+  Temp2 = CatSPrint(L"\r\n", Temp, PciRootBridgeIo->ParentHandle);
+  FreePool(Temp);
+  RetVal = Temp2;
+  Temp2 = NULL;
+  Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SEG), NULL);
+  ASSERT (Temp != NULL);
+  Temp2 = CatSPrint(RetVal, Temp, PciRootBridgeIo->SegmentNumber);
+  FreePool(Temp);
+  FreePool(RetVal);
+  RetVal = Temp2;
+  Temp2 = NULL;
+  Supports   = 0;
+  Attributes = 0;
+  Status = PciRootBridgeIo->GetAttributes (PciRootBridgeIo, &Supports, &Attributes);
+  if (!EFI_ERROR(Status)) {
+    Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_ATT), NULL);
+    ASSERT (Temp != NULL);
+    Temp2 = CatSPrint(RetVal, Temp, Attributes);
+    FreePool(Temp);
+    FreePool(RetVal);
+    RetVal = Temp2;
+    Temp2 = NULL;
+    Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_SUPPORTS), NULL);
+    ASSERT (Temp != NULL);
+    Temp2 = CatSPrint(RetVal, Temp, Supports);
+    FreePool(Temp);
+    FreePool(RetVal);
+    RetVal = Temp2;
+    Temp2 = NULL;
+  }
+  Configuration   = NULL;
+  Status = PciRootBridgeIo->Configuration (PciRootBridgeIo, (VOID **) &Configuration);
+  if (!EFI_ERROR(Status) && Configuration != NULL) {
+    Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_TITLE), NULL);
+    ASSERT (Temp != NULL);
+    Temp2 = CatSPrint(RetVal, Temp, Supports);
+    FreePool(Temp);
+    FreePool(RetVal);
+    RetVal = Temp2;
+    Temp2 = NULL;
+    while (Configuration->Desc == ACPI_ADDRESS_SPACE_DESCRIPTOR) {
+      Temp = NULL;
+      switch (Configuration->ResType) {
+      case ACPI_ADDRESS_SPACE_TYPE_MEM:
+        Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_MEM), NULL);
+        break;
+      case ACPI_ADDRESS_SPACE_TYPE_IO:
+        Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_IO), NULL);
+        break;
+      case ACPI_ADDRESS_SPACE_TYPE_BUS:
+        Temp = HiiGetString(mHandleParsingHiiHandle, STRING_TOKEN(STR_PCIRB_DUMP_BUS), NULL);
+        break;
+      }
+    }
+    //
+    // Next device path node
+    //
+    DevPathNode = NextDevicePathNode (DevPathNode);
+  }
+  FreePool (DevPath);
+  return Buffer;
+}
+*/
+      if (Temp != NULL) {
+        Temp2 = CatSPrint(RetVal, L"%s", Temp);
+        FreePool(Temp);
+        FreePool(RetVal);
+        RetVal = Temp2;
+        Temp2 = NULL;
+      }
+      Temp2 = CatSPrint(RetVal,
+        L"%H%02x    %016lx  %016lx  %02x%N\r\n",
+        Configuration->SpecificFlag,
+        Configuration->AddrRangeMin,
+        Configuration->AddrRangeMax,
+        Configuration->AddrSpaceGranularity
+        );
+      FreePool(RetVal);
+      RetVal = Temp2;
+      Temp2 = NULL;
+      Configuration++;
+    }
+  }
+  return (RetVal);
+}
 /**
 …
     return (NULL);
+  }
+  HandleParsingHiiInit();
   RetVal  = NULL;
 …
       Index == Dev->Mode->Mode ? L'*' : L' ',
       Index,
       !EFI_ERROR(Status)?Col:-1,
       !EFI_ERROR(Status)?Row:-1
+      !EFI_ERROR(Status)?(INTN)Col:-1,
+      !EFI_ERROR(Status)?(INTN)Row:-1
      );
+  }
 …
   CHAR16                            *Temp2;
   EFI_STATUS                        Status;
-  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *DevPathToText;
   Temp = NULL;
   Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID**)&DevPathToText);
+  Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
   if (!EFI_ERROR(Status)) {
+    Status = gBS->OpenProtocol(TheHandle, &gEfiDevicePathProtocolGuid, (VOID**)&DevPath, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+    if (!EFI_ERROR(Status)) {
+      //
+      // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
+      //
+      Temp = DevPathToText->ConvertDevicePathToText(DevPath, TRUE, TRUE);
+      gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);
+    }
+    //
+    // I cannot decide whether to allow shortcuts here (the second BOOLEAN on the next line)
+    //
+    Temp = ConvertDevicePathToText(DevPath, TRUE, TRUE);
+    gBS->CloseProtocol(TheHandle, &gEfiDevicePathProtocolGuid, gImageHandle, NULL);
+  }
   if (!Verbose && Temp != NULL && StrLen(Temp) > 30) {
 …
 #define LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID \
   { \
 x58c518b1, 0x76f3, 0x11d4, 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
+x58c518b1, 0x76f3, 0x11d4, { 0xbc, 0xea, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
 #define LOCAL_EFI_WIN_NT_BUS_DRIVER_IO_PROTOCOL_GUID \
   { \
 x96eb4ad6, 0xa32a, 0x11d4, 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
+x96eb4ad6, 0xa32a, 0x11d4, { 0xbc, 0xfd, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
 #define LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID \
   { \
 xc95a93d, 0xa006, 0x11d4, 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 \
+xc95a93d, 0xa006, 0x11d4, { 0xbc, 0xfa, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 } \
+  }
 STATIC CONST EFI_GUID WinNtThunkProtocolGuid = LOCAL_EFI_WIN_NT_THUNK_PROTOCOL_GUID;
 …
 STATIC CONST EFI_GUID WinNtSerialPortGuid    = LOCAL_EFI_WIN_NT_SERIAL_PORT_GUID;
 STATIC CONST PROTOCOL_INFO_BLOCK mGuidStringListNT[] = {
+STATIC CONST GUID_INFO_BLOCK mGuidStringListNT[] = {
   {STRING_TOKEN(STR_WINNT_THUNK),           (EFI_GUID*)&WinNtThunkProtocolGuid,               NULL},
   {STRING_TOKEN(STR_WINNT_DRIVER_IO),       (EFI_GUID*)&WinNtIoProtocolGuid,                  NULL},
 …
 };
 STATIC CONST PROTOCOL_INFO_BLOCK mGuidStringList[] = {
   {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     NULL},
+STATIC CONST GUID_INFO_BLOCK mGuidStringList[] = {
+  {STRING_TOKEN(STR_LOADED_IMAGE),          &gEfiLoadedImageProtocolGuid,                     LoadedImageProtocolDumpInformation},
   {STRING_TOKEN(STR_DEVICE_PATH),           &gEfiDevicePathProtocolGuid,                      DevicePathProtocolDumpInformation},
   {STRING_TOKEN(STR_IMAGE_PATH),            &gEfiLoadedImageDevicePathProtocolGuid,           DevicePathProtocolDumpInformation},
 …
   {STRING_TOKEN(STR_ABS_POINTER),           &gEfiAbsolutePointerProtocolGuid,                 NULL},
   {STRING_TOKEN(STR_SERIAL_IO),             &gEfiSerialIoProtocolGuid,                        NULL},
   {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  NULL},
+  {STRING_TOKEN(STR_GRAPHICS_OUTPUT),       &gEfiGraphicsOutputProtocolGuid,                  GraphicsOutputProtocolDumpInformation},
   {STRING_TOKEN(STR_EDID_DISCOVERED),       &gEfiEdidDiscoveredProtocolGuid,                  NULL},
   {STRING_TOKEN(STR_EDID_ACTIVE),           &gEfiEdidActiveProtocolGuid,                      NULL},
 …
   {STRING_TOKEN(STR_LOAD_FILE2),            &gEfiLoadFile2ProtocolGuid,                       NULL},
   {STRING_TOKEN(STR_SIMPLE_FILE_SYS),       &gEfiSimpleFileSystemProtocolGuid,                NULL},
-  {STRING_TOKEN(STR_FILE_INFO),             &gEfiFileInfoGuid,                                NULL},
-  {STRING_TOKEN(STR_FILE_SYS_INFO),         &gEfiFileSystemInfoGuid,                          NULL},
   {STRING_TOKEN(STR_TAPE_IO),               &gEfiTapeIoProtocolGuid,                          NULL},
   {STRING_TOKEN(STR_DISK_IO),               &gEfiDiskIoProtocolGuid,                          NULL},
 …
   {STRING_TOKEN(STR_UC),                    &gEfiUnicodeCollationProtocolGuid,                NULL},
   {STRING_TOKEN(STR_UC2),                   &gEfiUnicodeCollation2ProtocolGuid,               NULL},
   {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 NULL},
+  {STRING_TOKEN(STR_PCIRB_IO),              &gEfiPciRootBridgeIoProtocolGuid,                 PciRootBridgeIoDumpInformation},
   {STRING_TOKEN(STR_PCI_IO),                &gEfiPciIoProtocolGuid,                           NULL},
   {STRING_TOKEN(STR_SCSI_PT),               &gEfiScsiPassThruProtocolGuid,                    NULL},
 …
   {STRING_TOKEN(STR_IPV4),                  &gEfiIp4ProtocolGuid,                             NULL},
   {STRING_TOKEN(STR_IPV4_CFG),              &gEfiIp4ConfigProtocolGuid,                       NULL},
-  {STRING_TOKEN(STR_SHELL_PARAMETERS),      &gEfiShellParametersProtocolGuid,                 NULL},
-  {STRING_TOKEN(STR_SHELL),                 &gEfiShellProtocolGuid,                           NULL},
-  {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE),   &gEfiGlobalVariableGuid,                          NULL},
   {STRING_TOKEN(STR_UDPV4_SB),              &gEfiUdp4ServiceBindingProtocolGuid,              NULL},
   {STRING_TOKEN(STR_UDPV4),                 &gEfiUdp4ProtocolGuid,                            NULL},
 …
   {STRING_TOKEN(STR_HII_CONFIG_ACC),        &gEfiHiiConfigAccessProtocolGuid,                 NULL},
   {STRING_TOKEN(STR_HII_FORM_BROWSER2),     &gEfiFormBrowser2ProtocolGuid,                    NULL},
+  {STRING_TOKEN(STR_DRIVER_FAM_OVERRIDE),   &gEfiDriverFamilyOverrideProtocolGuid,            NULL},
+  {STRING_TOKEN(STR_PCD),                   &gPcdProtocolGuid,                                NULL},
+  {STRING_TOKEN(STR_TCG),                   &gEfiTcgProtocolGuid,                             NULL},
+  {STRING_TOKEN(STR_HII_PACKAGE_LIST),      &gEfiHiiPackageListProtocolGuid,                  NULL},
+//
+// the ones under this are deprecated by the current UEFI Spec, but may be found anyways...
+//
   {STRING_TOKEN(STR_SHELL_INTERFACE),       &gEfiShellInterfaceGuid,                          NULL},
   {STRING_TOKEN(STR_SHELL_ENV2),            &gEfiShellEnvironment2Guid,                       NULL},
 …
   {STRING_TOKEN(STR_DRIVER_CONFIG),         &gEfiDriverConfigurationProtocolGuid,             NULL},
   {STRING_TOKEN(STR_DRIVER_CONFIG2),        &gEfiDriverConfiguration2ProtocolGuid,            NULL},
+//
+// the ones under this are GUID identified structs, not protocols
+//
+  {STRING_TOKEN(STR_FILE_INFO),             &gEfiFileInfoGuid,                                NULL},
+  {STRING_TOKEN(STR_FILE_SYS_INFO),         &gEfiFileSystemInfoGuid,                          NULL},
+//
+// the ones under this are misc GUIDS.
+//
+  {STRING_TOKEN(STR_EFI_GLOBAL_VARIABLE),   &gEfiGlobalVariableGuid,                          NULL},
+//
+// UEFI 2.2
+//
+  {STRING_TOKEN(STR_IP6_SB),                &gEfiIp6ServiceBindingProtocolGuid,               NULL},
+  {STRING_TOKEN(STR_IP6),                   &gEfiIp6ProtocolGuid,                             NULL},
+  {STRING_TOKEN(STR_IP6_CONFIG),            &gEfiIp6ConfigProtocolGuid,                       NULL},
+  {STRING_TOKEN(STR_MTFTP6_SB),             &gEfiMtftp6ServiceBindingProtocolGuid,            NULL},
+  {STRING_TOKEN(STR_MTFTP6),                &gEfiMtftp6ProtocolGuid,                          NULL},
+  {STRING_TOKEN(STR_DHCP6_SB),              &gEfiDhcp6ServiceBindingProtocolGuid,             NULL},
+  {STRING_TOKEN(STR_DHCP6),                 &gEfiDhcp6ProtocolGuid,                           NULL},
+  {STRING_TOKEN(STR_UDP6_SB),               &gEfiUdp6ServiceBindingProtocolGuid,              NULL},
+  {STRING_TOKEN(STR_UDP6),                  &gEfiUdp6ProtocolGuid,                            NULL},
+  {STRING_TOKEN(STR_TCP6_SB),               &gEfiTcp6ServiceBindingProtocolGuid,              NULL},
+  {STRING_TOKEN(STR_TCP6),                  &gEfiTcp6ProtocolGuid,                            NULL},
+  {STRING_TOKEN(STR_VLAN_CONFIG),           &gEfiVlanConfigProtocolGuid,                      NULL},
+  {STRING_TOKEN(STR_EAP),                   &gEfiEapProtocolGuid,                             NULL},
+  {STRING_TOKEN(STR_EAP_MGMT),              &gEfiEapManagementProtocolGuid,                   NULL},
+  {STRING_TOKEN(STR_FTP4_SB),               &gEfiFtp4ServiceBindingProtocolGuid,              NULL},
+  {STRING_TOKEN(STR_FTP4),                  &gEfiFtp4ProtocolGuid,                            NULL},
+  {STRING_TOKEN(STR_IP_SEC_CONFIG),         &gEfiIpSecConfigProtocolGuid,                     NULL},
+  {STRING_TOKEN(STR_DH),                    &gEfiDriverHealthProtocolGuid,                    NULL},
+  {STRING_TOKEN(STR_DEF_IMG_LOAD),          &gEfiDeferredImageLoadProtocolGuid,               NULL},
+  {STRING_TOKEN(STR_USER_CRED),             &gEfiUserCredentialProtocolGuid,                  NULL},
+  {STRING_TOKEN(STR_USER_MNGR),             &gEfiUserManagerProtocolGuid,                     NULL},
+  {STRING_TOKEN(STR_ATA_PASS_THRU),         &gEfiAtaPassThruProtocolGuid,                     NULL},
+//
+// UEFI 2.3
+//
+  {STRING_TOKEN(STR_FW_MGMT),               &gEfiFirmwareManagementProtocolGuid,              NULL},
+  {STRING_TOKEN(STR_IP_SEC),                &gEfiIpSecProtocolGuid,                           NULL},
+  {STRING_TOKEN(STR_IP_SEC2),               &gEfiIpSec2ProtocolGuid,                          NULL},
+//
+// UEFI 2.3.1
+//
+  {STRING_TOKEN(STR_KMS),                   &gEfiKmsProtocolGuid,                             NULL},
+  {STRING_TOKEN(STR_BLK_IO2),               &gEfiBlockIo2ProtocolGuid,                        NULL},
+  {STRING_TOKEN(STR_SSC),                   &gEfiStorageSecurityCommandProtocolGuid,          NULL},
+  {STRING_TOKEN(STR_UCRED2),                &gEfiUserCredential2ProtocolGuid,                 NULL},
+//
+// UEFI 2.4
+//
+  {STRING_TOKEN(STR_DISK_IO2),              &gEfiDiskIo2ProtocolGuid,                         NULL},
+  {STRING_TOKEN(STR_ADAPTER_INFO),          &gEfiAdapterInformationProtocolGuid,              NULL},
+//
+// PI Spec ones
+//
+  {STRING_TOKEN(STR_IDE_CONT_INIT),         &gEfiIdeControllerInitProtocolGuid,               NULL},
+//
+// UEFI Shell Spec 2.0
+//
+  {STRING_TOKEN(STR_SHELL_PARAMETERS),      &gEfiShellParametersProtocolGuid,                 NULL},
+  {STRING_TOKEN(STR_SHELL),                 &gEfiShellProtocolGuid,                           NULL},
+//
+// UEFI Shell Spec 2.1
+//
+  {STRING_TOKEN(STR_SHELL_DYNAMIC),         &gEfiShellDynamicCommandProtocolGuid,             NULL},
+//
+// terminator
+//
   {STRING_TOKEN(STR_UNKNOWN_DEVICE),        NULL,                                             NULL},
 };
 …
   @return                       The node.
 **/
 CONST PROTOCOL_INFO_BLOCK *
+CONST GUID_INFO_BLOCK *
 EFIAPI
 InternalShellGetNodeFromGuid(
 …
+  )
+{
+  CONST PROTOCOL_INFO_BLOCK *ListWalker;
+  CONST GUID_INFO_BLOCK *ListWalker;
+  UINTN                 LoopCount;
   ASSERT(Guid != NULL);
+  for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {
+    if (CompareGuid(ListWalker->GuidId, Guid)) {
+      return (ListWalker);
+    }
+  }
   if (PcdGetBool(PcdShellIncludeNtGuids)) {
 …
+    }
+  }
+  return (ListWalker);
+  return (NULL);
+}
+/**
+Function to add a new GUID/Name mapping.
+@param[in] Guid       The Guid
+@param[in] NameID     The STRING id of the HII string to use
+@param[in] DumpFunc   The pointer to the dump function
+@retval EFI_SUCCESS           The operation was sucessful
+@retval EFI_OUT_OF_RESOURCES  A memory allocation failed
+@retval EFI_INVALID_PARAMETER Guid NameId was invalid
+**/
+EFI_STATUS
+EFIAPI
+InsertNewGuidNameMapping(
+  IN CONST EFI_GUID           *Guid,
+  IN CONST EFI_STRING_ID      NameID,
+  IN CONST DUMP_PROTOCOL_INFO DumpFunc OPTIONAL
+  )
+{
+  ASSERT(Guid   != NULL);
+  ASSERT(NameID != 0);
+  GuidList = ReallocatePool(GuidListCount * sizeof(GUID_INFO_BLOCK), GuidListCount+1 * sizeof(GUID_INFO_BLOCK), GuidList);
+  if (GuidList == NULL) {
+    GuidListCount = 0;
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  GuidListCount++;
+  GuidList[GuidListCount - 1].GuidId   = AllocateCopyPool(sizeof(EFI_GUID), Guid);
+  GuidList[GuidListCount - 1].StringId = NameID;
+  GuidList[GuidListCount - 1].DumpInfo = DumpFunc;
+  if (GuidList[GuidListCount - 1].GuidId == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  return (EFI_SUCCESS);
+}
+/**
+  Function to add a new GUID/Name mapping.
+  This cannot overwrite an existing mapping.
+  @param[in] Guid       The Guid
+  @param[in] TheName    The Guid's name
+  @param[in] Lang       RFC4646 language code list or NULL
+  @retval EFI_SUCCESS           The operation was sucessful
+  @retval EFI_ACCESS_DENIED     There was a duplicate
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed
+  @retval EFI_INVALID_PARAMETER Guid or TheName was NULL
+**/
+EFI_STATUS
+EFIAPI
+AddNewGuidNameMapping(
+  IN CONST EFI_GUID *Guid,
+  IN CONST CHAR16   *TheName,
+  IN CONST CHAR8    *Lang OPTIONAL
+  )
+{
+  CONST GUID_INFO_BLOCK *Temp;
+  EFI_STRING_ID         NameID;
+  HandleParsingHiiInit();
+  if (Guid == NULL || TheName == NULL){
+    return (EFI_INVALID_PARAMETER);
+  }
+  if ((Temp = InternalShellGetNodeFromGuid(Guid)) != NULL) {
+    return (EFI_ACCESS_DENIED);
+  }
+  NameID = HiiSetString(mHandleParsingHiiHandle, 0, (CHAR16*)TheName, Lang);
+  if (NameID == 0) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  return (InsertNewGuidNameMapping(Guid, NameID, NULL));
+}
 …
+  )
+{
+  CONST PROTOCOL_INFO_BLOCK *Id;
+  CONST GUID_INFO_BLOCK *Id;
+  HandleParsingHiiInit();
   Id = InternalShellGetNodeFromGuid(Guid);
   return (HiiGetString(mHandleParsingHiiHandle, Id->StringId, Lang));
+  return (HiiGetString(mHandleParsingHiiHandle, Id==NULL?STRING_TOKEN(STR_UNKNOWN_DEVICE):Id->StringId, Lang));
+}
 …
+  )
+{
   CONST PROTOCOL_INFO_BLOCK *Id;
+  CONST GUID_INFO_BLOCK *Id;
   ASSERT(TheHandle  != NULL);
 …
   Function to get the Guid for a protocol or struct based on it's string name.
+  do not modify the returned Guid.
   @param[in] Name           The pointer to the string name.
   @param[in] Lang           The pointer to the language code.
   @param[in] Guid           The pointer to the Guid.
+  @param[out] Guid          The pointer to the Guid.
   @retval EFI_SUCCESS       The operation was sucessful.
 …
   IN CONST CHAR16 *Name,
   IN CONST CHAR8  *Lang OPTIONAL,
   IN EFI_GUID     **Guid
+  )
+{
   CONST PROTOCOL_INFO_BLOCK  *ListWalker;
+  OUT EFI_GUID    **Guid
+  )
+{
+  CONST GUID_INFO_BLOCK  *ListWalker;
   CHAR16                     *String;
+  UINTN                  LoopCount;
+  HandleParsingHiiInit();
   ASSERT(Guid != NULL);
 …
     for (ListWalker = mGuidStringListNT ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
       String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
       if (Name != NULL && String != NULL && StrCmp(Name, String)==0) {
+      if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
         *Guid = ListWalker->GuidId;
+      }
 …
   for (ListWalker = mGuidStringList ; ListWalker != NULL && ListWalker->GuidId != NULL ; ListWalker++) {
     String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
     if (Name != NULL && String != NULL && StrCmp(Name, String)==0) {
+    if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
       *Guid = ListWalker->GuidId;
+    }
 …
+    }
+  }
+  for (LoopCount = 0, ListWalker = GuidList; GuidList != NULL && LoopCount < GuidListCount; LoopCount++, ListWalker++) {
+    String = HiiGetString(mHandleParsingHiiHandle, ListWalker->StringId, Lang);
+    if (Name != NULL && String != NULL && StringNoCaseCompare (&Name, &String) == 0) {
+      *Guid = ListWalker->GuidId;
+    }
+    SHELL_FREE_NON_NULL(String);
+    if (*Guid != NULL) {
+      return (EFI_SUCCESS);
+    }
+  }
   return (EFI_NOT_FOUND);
+}
+/**
+  Get best support language for this driver.
+  First base on the user input language  to search, second base on the current
+  platform used language to search, third get the first language from the
+  support language list. The caller need to free the buffer of the best language.
+  @param[in] SupportedLanguages      The support languages for this driver.
+  @param[in] InputLanguage           The user input language.
+  @param[in] Iso639Language          Whether get language for ISO639.
+  @return                            The best support language for this driver.
+**/
+CHAR8 *
+EFIAPI
+GetBestLanguageForDriver (
+  IN CONST CHAR8  *SupportedLanguages,
+  IN CONST CHAR8  *InputLanguage,
+  IN BOOLEAN      Iso639Language
+  )
+{
+  CHAR8                         *LanguageVariable;
+  CHAR8                         *BestLanguage;
+  LanguageVariable = GetVariable (Iso639Language ? L"Lang" : L"PlatformLang", &gEfiGlobalVariableGuid);
+  BestLanguage = GetBestLanguage(
+                   SupportedLanguages,
+                   Iso639Language,
+                   (InputLanguage != NULL) ? InputLanguage : "",
+                   (LanguageVariable != NULL) ? LanguageVariable : "",
+                   SupportedLanguages,
+                   NULL
+                   );
+  if (LanguageVariable != NULL) {
+    FreePool (LanguageVariable);
+  }
+  return BestLanguage;
+}
 …
   EFI_STATUS                    Status;
   CHAR16                        *RetVal;
+  CHAR8                         *BestLang;
+  BestLang = NULL;
   Status = gBS->OpenProtocol(
 …
     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
   if (!EFI_ERROR(Status)) {
+    Status = CompNameStruct->GetDriverName(CompNameStruct, (CHAR8*)Language, &RetVal);
+    BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
+    Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
+    if (BestLang != NULL) {
+      FreePool (BestLang);
+      BestLang = NULL;
+    }
     if (!EFI_ERROR(Status)) {
       return (RetVal);
 …
     EFI_OPEN_PROTOCOL_GET_PROTOCOL);
   if (!EFI_ERROR(Status)) {
+    Status = CompNameStruct->GetDriverName(CompNameStruct, (CHAR8*)Language, &RetVal);
+    BestLang = GetBestLanguageForDriver (CompNameStruct->SupportedLanguages, Language, FALSE);
+    Status = CompNameStruct->GetDriverName(CompNameStruct, BestLang, &RetVal);
+    if (BestLang != NULL) {
+      FreePool (BestLang);
+    }
     if (!EFI_ERROR(Status)) {
       return (RetVal);
 …
+  )
+{
+  HANDLE_LIST *ListWalker;
+  EFI_STATUS   Status;
+  EFI_GUID     **ProtocolBuffer;
+  UINTN        ProtocolCount;
+  HANDLE_LIST  *ListWalker;
   if (TheHandle == NULL) {
     return 0;
 …
    ){
     if (ListWalker->TheHandle == TheHandle) {
+      //
+      // Verify that TheHandle is still present in the Handle Database
+      //
+      Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
+      if (EFI_ERROR (Status)) {
+        //
+        // TheHandle is not present in the Handle Database, so delete from the handle list
+        //
+        RemoveEntryList (&ListWalker->Link);
+        return 0;
+      }
+      FreePool (ProtocolBuffer);
       return (ListWalker->TheIndex);
+    }
+  }
+  //
+  // Verify that TheHandle is valid handle
+  //
+  Status = gBS->ProtocolsPerHandle(TheHandle, &ProtocolBuffer, &ProtocolCount);
+  if (EFI_ERROR (Status)) {
+    //
+    // TheHandle is not valid, so do not add to handle list
+    //
+    return 0;
+  }
+  FreePool (ProtocolBuffer);
   ListWalker = AllocateZeroPool(sizeof(HANDLE_LIST));
   ASSERT(ListWalker != NULL);
 …
+  )
+{
+  EFI_STATUS   Status;
+  EFI_GUID     **ProtocolBuffer;
+  UINTN        ProtocolCount;
   HANDLE_LIST *ListWalker;
 …
   if (TheIndex >= mHandleList.NextIndex) {
     return (NULL);
+    return NULL;
+  }
 …
     ;  ListWalker = (HANDLE_LIST*)GetNextNode(&mHandleList.List.Link,&ListWalker->Link)
    ){
+    if (ListWalker->TheIndex == TheIndex) {
+    if (ListWalker->TheIndex == TheIndex && ListWalker->TheHandle != NULL) {
+      //
+      // Verify that LinkWalker->TheHandle is valid handle
+      //
+      Status = gBS->ProtocolsPerHandle(ListWalker->TheHandle, &ProtocolBuffer, &ProtocolCount);
+      if (EFI_ERROR (Status)) {
+        //
+        // TheHandle is not valid, so do not add to handle list
+        //
+        ListWalker->TheHandle = NULL;
+      }
       return (ListWalker->TheHandle);
+    }
+  }
   return (NULL);
+  return NULL;
+}
 …
   UINTN                               OpenInfoIndex;
   UINTN                               ChildIndex;
+  INTN                                DriverBindingHandleIndex;
   ASSERT(HandleCount  != NULL);
 …
   ASSERT(*HandleType != NULL);
+  DriverBindingHandleIndex = -1;
+  for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
+    if (DriverBindingHandle != NULL && (*HandleBuffer)[HandleIndex] == DriverBindingHandle) {
+      DriverBindingHandleIndex = (INTN)HandleIndex;
+    }
+  }
   for (HandleIndex = 0; HandleIndex < *HandleCount; HandleIndex++) {
     //
 …
                   &ArrayCount
                  );
+    if (!EFI_ERROR (Status)) {
+      for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
+        //
+        // Set the bit describing what this handle has
+        //
+        if        (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)         ) {
+          (*HandleType)[HandleIndex] |= HR_IMAGE_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)       ) {
+          (*HandleType)[HandleIndex] |= HR_DRIVER_BINDING_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
+          (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {
+          (*HandleType)[HandleIndex] |= HR_DRIVER_CONFIGURATION_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)  ) {
+          (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)   ) {
+          (*HandleType)[HandleIndex] |= HR_DRIVER_DIAGNOSTICS_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)      ) {
+          (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)       ) {
+          (*HandleType)[HandleIndex] |= HR_COMPONENT_NAME_HANDLE;
+        } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {
+          (*HandleType)[HandleIndex] |= HR_DEVICE_HANDLE;
+        } else {
+          DEBUG_CODE_BEGIN();
+          ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);
+          DEBUG_CODE_END();
+        }
+        //
+        // Retrieve the list of agents that have opened each protocol
+        //
+        Status = gBS->OpenProtocolInformation (
+    if (EFI_ERROR (Status)) {
+      continue;
+    }
+    for (ProtocolIndex = 0; ProtocolIndex < ArrayCount; ProtocolIndex++) {
+      //
+      // Set the bit describing what this handle has
+      //
+      if        (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiLoadedImageProtocolGuid)         ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_IMAGE_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverBindingProtocolGuid)       ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_BINDING_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfiguration2ProtocolGuid)) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverConfigurationProtocolGuid) ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_CONFIGURATION_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnostics2ProtocolGuid)  ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDriverDiagnosticsProtocolGuid)   ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DRIVER_DIAGNOSTICS_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentName2ProtocolGuid)      ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiComponentNameProtocolGuid)       ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_COMPONENT_NAME_HANDLE;
+      } else if (CompareGuid (ProtocolGuidArray[ProtocolIndex], &gEfiDevicePathProtocolGuid)          ) {
+        (*HandleType)[HandleIndex] |= (UINTN)HR_DEVICE_HANDLE;
+      } else {
+        DEBUG_CODE_BEGIN();
+        ASSERT((*HandleType)[HandleIndex] == (*HandleType)[HandleIndex]);
+        DEBUG_CODE_END();
+      }
+      //
+      // Retrieve the list of agents that have opened each protocol
+      //
+      Status = gBS->OpenProtocolInformation (
                       (*HandleBuffer)[HandleIndex],
                       ProtocolGuidArray[ProtocolIndex],
 …
                       &OpenInfoCount
                      );
+        if (!EFI_ERROR (Status)) {
+      if (EFI_ERROR (Status)) {
+        continue;
+      }
+      if (ControllerHandle == NULL) {
+        //
+        // ControllerHandle == NULL and DriverBindingHandle != NULL.
+        // Return information on all the controller handles that the driver specified by DriverBindingHandle is managing
+        //
+        for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
+          if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+            (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
+            if (DriverBindingHandleIndex != -1) {
+              (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
+            }
+          }
+          if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle && (OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+            (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
+            if (DriverBindingHandleIndex != -1) {
+              (*HandleType)[DriverBindingHandleIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
+            }
+            for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+              if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
+                (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
+              }
+            }
+          }
+        }
+      }
+      if (DriverBindingHandle == NULL && ControllerHandle != NULL) {
+        if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
+          (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
           for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
+            if (DriverBindingHandle != NULL && OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
+              if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) == EFI_OPEN_PROTOCOL_BY_DRIVER) {
+                (*HandleType)[HandleIndex] |= (HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
+              }
+              if (ControllerHandle != NULL && (*HandleBuffer)[HandleIndex] == ControllerHandle) {
+                if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
+                  for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                    if ((*HandleBuffer)[ChildIndex] == OpenInfo[OpenInfoIndex].ControllerHandle) {
+                      (*HandleType)[ChildIndex] |= (HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
+                    }
+                  }
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+              for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
+                  (*HandleType)[ChildIndex] |= (UINTN)HR_DEVICE_DRIVER;
+                }
+              }
+            }
+            if (DriverBindingHandle == NULL && OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
+              if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) == EFI_OPEN_PROTOCOL_BY_DRIVER) {
+                for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                  if ((*HandleBuffer)[ChildIndex] == OpenInfo[OpenInfoIndex].AgentHandle) {
+                    (*HandleType)[ChildIndex] |= HR_DEVICE_DRIVER;
+                  }
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+              for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
+                  (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
+                }
+              }
+              if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) == EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) {
+                (*HandleType)[HandleIndex] |= HR_PARENT_HANDLE;
+                for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                  if ((*HandleBuffer)[ChildIndex] == OpenInfo[OpenInfoIndex].AgentHandle) {
+                    (*HandleType)[ChildIndex] |= HR_BUS_DRIVER;
+                  }
+                if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
+                  (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
+                }
+              }
+            }
+          }
+          FreePool (OpenInfo);
+        } else {
+          for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+              if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
+                (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
+              }
+            }
+          }
+        }
+      }
+      FreePool (ProtocolGuidArray);
+    }
+  }
+  if (EFI_ERROR(Status)) {
+    if (*HandleType != NULL) {
+      FreePool (*HandleType);
+    }
+    if (*HandleBuffer != NULL) {
+      FreePool (*HandleBuffer);
+    }
+    *HandleCount  = 0;
+    *HandleBuffer = NULL;
+    *HandleType   = NULL;
+  }
+  return Status;
+      if (DriverBindingHandle != NULL && ControllerHandle != NULL) {
+        if (ControllerHandle == (*HandleBuffer)[HandleIndex]) {
+          (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CONTROLLER_HANDLE);
+          for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_DRIVER) != 0) {
+              if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
+                if (DriverBindingHandleIndex != -1) {
+                  (*HandleType)[DriverBindingHandleIndex] |= (UINTN)HR_DEVICE_DRIVER;
+                }
+              }
+            }
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+              if (OpenInfo[OpenInfoIndex].AgentHandle == DriverBindingHandle) {
+                for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                  if (OpenInfo[OpenInfoIndex].ControllerHandle == (*HandleBuffer)[ChildIndex]) {
+                    (*HandleType)[ChildIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_CHILD_HANDLE);
+                  }
+                }
+              }
+              for (ChildIndex = 0; ChildIndex < *HandleCount; ChildIndex++) {
+                if (OpenInfo[OpenInfoIndex].AgentHandle == (*HandleBuffer)[ChildIndex]) {
+                  (*HandleType)[ChildIndex] |= (UINTN)(HR_BUS_DRIVER | HR_DEVICE_DRIVER);
+                }
+              }
+            }
+          }
+        } else {
+          for (OpenInfoIndex = 0; OpenInfoIndex < OpenInfoCount; OpenInfoIndex++) {
+            if ((OpenInfo[OpenInfoIndex].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0) {
+              if (OpenInfo[OpenInfoIndex].ControllerHandle == ControllerHandle) {
+                (*HandleType)[HandleIndex] |= (UINTN)(HR_DEVICE_HANDLE | HR_PARENT_HANDLE);
+              }
+            }
+          }
+        }
+      }
+      FreePool (OpenInfo);
+    }
+    FreePool (ProtocolGuidArray);
+  }
+  return EFI_SUCCESS;
+}
 …
+{
   EFI_STATUS  Status;
 //  UINTN       HandleIndex;
+  UINTN       HandleIndex;
   UINTN       DriverBindingHandleCount;
   EFI_HANDLE  *DriverBindingHandleBuffer;
 …
   EFI_HANDLE  *ChildControllerHandleBuffer;
   UINTN       ChildControllerHandleIndex;
-//  BOOLEAN     Found;
   EFI_HANDLE  *HandleBufferForReturn;
 …
   // Get a buffer big enough for all the controllers.
   //
   HandleBufferForReturn = GetHandleListByProtocol(&gEfiDevicePathProtocolGuid);
+  HandleBufferForReturn = GetHandleListByProtocol(NULL);
   if (HandleBufferForReturn == NULL) {
     FreePool (DriverBindingHandleBuffer);
 …
          ChildControllerHandleIndex++
        ) {
+//      Found = FALSE;
+      HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
+//      for (HandleIndex = 0; HandleBufferForReturn[HandleIndex] != NULL; HandleIndex++) {
+//        if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
+//          Found = TRUE;
+//          break;
+//        }
+//      }
+//      if (Found) {
+//        HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
+//      }
+      for (HandleIndex = 0; HandleIndex < *MatchingHandleCount; HandleIndex++) {
+        if (HandleBufferForReturn[HandleIndex] == ChildControllerHandleBuffer[ChildControllerHandleIndex]) {
+          break;
+        }
+      }
+      if (HandleIndex >= *MatchingHandleCount) {
+        HandleBufferForReturn[(*MatchingHandleCount)++] = ChildControllerHandleBuffer[ChildControllerHandleIndex];
+      }
+    }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.h

-              r48674
+              r58459
   Provides interface to advanced shell functionality for parsing both handle and protocol database.
+  Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 //#include <Protocol/FirmwareVolume.h>
 //#include <Protocol/FirmwareVolume2.h>
+#include <Protocol/DriverFamilyOverride.h>
+#include <Protocol/Pcd.h>
+#include <Protocol/TcgService.h>
+#include <Protocol/HiiPackageList.h>
+#include <Protocol/Ip6.h>
+#include <Protocol/Ip6Config.h>
+#include <Protocol/Mtftp6.h>
+#include <Protocol/Dhcp6.h>
+#include <Protocol/Udp6.h>
+#include <Protocol/Tcp6.h>
+#include <Protocol/VlanConfig.h>
+#include <Protocol/Eap.h>
+#include <Protocol/EapManagement.h>
+#include <Protocol/Ftp4.h>
+#include <Protocol/IpSecConfig.h>
+#include <Protocol/DriverHealth.h>
+#include <Protocol/DeferredImageLoad.h>
+#include <Protocol/UserCredential.h>
+#include <Protocol/UserManager.h>
+#include <Protocol/AtaPassThru.h>
+#include <Protocol/FirmwareManagement.h>
+#include <Protocol/IpSec.h>
+#include <Protocol/Kms.h>
+#include <Protocol/BlockIo2.h>
+#include <Protocol/StorageSecurityCommand.h>
+#include <Protocol/UserCredential2.h>
+#include <Protocol/IdeControllerInit.h>
+#include <Protocol/DiskIo2.h>
+#include <Protocol/AdapterInformation.h>
+#include <Protocol/EfiShellDynamicCommand.h>
 #include <Library/HandleParsingLib.h>
 …
 #include <Library/HiiLib.h>
 #include <Library/ShellLib.h>
+#include <Library/SortLib.h>
 typedef struct {
 …
   );
+typedef struct {
+typedef struct _GUID_INFO_BLOCK{
   EFI_STRING_ID                 StringId;
   EFI_GUID                      *GuidId;
   DUMP_PROTOCOL_INFO            DumpInfo;
 } PROTOCOL_INFO_BLOCK;
+} GUID_INFO_BLOCK;
 #endif

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.inf

-              r48674
+              r58459
 ##  @file
 #  Provides interface to advanced shell functionality for parsing both handle and protocol database.
+#  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.<BR>
+#  Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = HandleParsingLib|UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = HandleParsingLib|UEFI_APPLICATION UEFI_DRIVER DXE_RUNTIME_DRIVER
   CONSTRUCTOR                    = HandleParsingLibConstructor
   DESTRUCTOR                     = HandleParsingLibDestructor
 …
   UefiLib
   HiiLib
+  SortLib
 [Protocols]
   gEfiSimpleFileSystemProtocolGuid              # ALWAYS_CONSUMED
+  gEfiSimpleFileSystemProtocolGuid                        ## CONSUMES
   # shell 2.0
   gEfiShellProtocolGuid                         # SOMETIMES_CONSUMED
   gEfiShellParametersProtocolGuid               # SOMETIMES_CONSUMED
+  gEfiShellProtocolGuid                                   ## SOMETIMES_CONSUMES
+  gEfiShellParametersProtocolGuid                         ## SOMETIMES_CONSUMES
   # 'old' shell
   gEfiShellEnvironment2Guid                     # SOMETIMES_CONSUMED
   gEfiShellInterfaceGuid                        # SOMETIMES_CONSUMED
+  gEfiShellEnvironment2Guid                               ## SOMETIMES_CONSUMES
+  gEfiShellInterfaceGuid                                  ## SOMETIMES_CONSUMES
+  gEfiUnicodeCollation2ProtocolGuid                       # ALWAYS_CONSUMED
+  gEfiDevicePathToTextProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiBusSpecificDriverOverrideProtocolGuid               # ALWAYS_CONSUMED
+  gEfiDevicePathUtilitiesProtocolGuid                     # ALWAYS_CONSUMED
+  gEfiDevicePathFromTextProtocolGuid                      # ALWAYS_CONSUMED
+  gEfiPlatformDriverOverrideProtocolGuid                  # ALWAYS_CONSUMED
+  gEfiSimpleTextInProtocolGuid                            # ALWAYS_CONSUMED
+  gEfiPlatformToDriverConfigurationProtocolGuid           # ALWAYS_CONSUMED
+  gEfiDriverSupportedEfiVersionProtocolGuid               # ALWAYS_CONSUMED
+  gEfiLoadedImageProtocolGuid                             # ALWAYS_CONSUMED
+  gEfiDevicePathProtocolGuid                              # ALWAYS_CONSUMED
+  gEfiLoadedImageDevicePathProtocolGuid                   # ALWAYS_CONSUMED
+  gEfiSimpleTextOutProtocolGuid
+  gEfiSimplePointerProtocolGuid
+  gEfiAbsolutePointerProtocolGuid
+  gEfiSerialIoProtocolGuid
+  gEfiEdidDiscoveredProtocolGuid
+  gEfiEdidActiveProtocolGuid
+  gEfiEdidOverrideProtocolGuid
+  gEfiLoadFileProtocolGuid
+  gEfiLoadFile2ProtocolGuid
+  gEfiTapeIoProtocolGuid
+  gEfiDiskIoProtocolGuid
+  gEfiBlockIoProtocolGuid
+  gEfiUnicodeCollationProtocolGuid
+  gEfiPciRootBridgeIoProtocolGuid
+  gEfiPciIoProtocolGuid
+  gEfiScsiPassThruProtocolGuid
+  gEfiScsiIoProtocolGuid
+  gEfiExtScsiPassThruProtocolGuid
+  gEfiIScsiInitiatorNameProtocolGuid
+  gEfiUsbIoProtocolGuid
+  gEfiUsbHcProtocolGuid
+  gEfiUsb2HcProtocolGuid
+  gEfiDebugSupportProtocolGuid
+  gEfiDebugPortProtocolGuid
+  gEfiDecompressProtocolGuid
+  gEfiAcpiTableProtocolGuid
+  gEfiEbcProtocolGuid
+  gEfiSimpleNetworkProtocolGuid
+  gEfiNetworkInterfaceIdentifierProtocolGuid
+  gEfiNetworkInterfaceIdentifierProtocolGuid_31
+  gEfiPxeBaseCodeProtocolGuid
+  gEfiPxeBaseCodeCallbackProtocolGuid
+  gEfiBisProtocolGuid
+  gEfiManagedNetworkServiceBindingProtocolGuid
+  gEfiManagedNetworkProtocolGuid
+  gEfiArpServiceBindingProtocolGuid
+  gEfiArpProtocolGuid
+  gEfiDhcp4ServiceBindingProtocolGuid
+  gEfiDhcp4ProtocolGuid
+  gEfiTcp4ServiceBindingProtocolGuid
+  gEfiTcp4ProtocolGuid
+  gEfiIp4ServiceBindingProtocolGuid
+  gEfiIp4ProtocolGuid
+  gEfiIp4ConfigProtocolGuid
+  gEfiUdp4ServiceBindingProtocolGuid
+  gEfiUdp4ProtocolGuid
+  gEfiMtftp4ServiceBindingProtocolGuid
+  gEfiMtftp4ProtocolGuid
+  gEfiAuthenticationInfoProtocolGuid
+  gEfiHashServiceBindingProtocolGuid
+  gEfiHashProtocolGuid
+  gEfiHiiFontProtocolGuid
+  gEfiHiiStringProtocolGuid
+  gEfiHiiImageProtocolGuid
+  gEfiHiiConfigRoutingProtocolGuid
+  gEfiHiiConfigAccessProtocolGuid
+  gEfiFormBrowser2ProtocolGuid
+  gEfiDeviceIoProtocolGuid
+  gEfiUgaDrawProtocolGuid
+  gEfiUgaIoProtocolGuid
+  gEfiDriverConfigurationProtocolGuid
+  gEfiDriverConfiguration2ProtocolGuid
+  gEfiSimpleTextInputExProtocolGuid
+  gEfiUnicodeCollation2ProtocolGuid                       ## CONSUMES
+  gEfiDevicePathToTextProtocolGuid                        ## CONSUMES
+  gEfiBusSpecificDriverOverrideProtocolGuid               ## CONSUMES
+  gEfiDevicePathUtilitiesProtocolGuid                     ## CONSUMES
+  gEfiDevicePathFromTextProtocolGuid                      ## CONSUMES
+  gEfiPlatformDriverOverrideProtocolGuid                  ## CONSUMES
+  gEfiSimpleTextInProtocolGuid                            ## CONSUMES
+  gEfiPlatformToDriverConfigurationProtocolGuid           ## CONSUMES
+  gEfiDriverSupportedEfiVersionProtocolGuid               ## CONSUMES
+  gEfiLoadedImageProtocolGuid                             ## CONSUMES
+  gEfiDevicePathProtocolGuid                              ## CONSUMES
+  gEfiLoadedImageDevicePathProtocolGuid                   ## CONSUMES
+  gEfiSimpleTextOutProtocolGuid                           ## UNDEFINED
+  gEfiSimplePointerProtocolGuid                           ## UNDEFINED
+  gEfiAbsolutePointerProtocolGuid                         ## UNDEFINED
+  gEfiSerialIoProtocolGuid                                ## UNDEFINED
+  gEfiEdidDiscoveredProtocolGuid                          ## UNDEFINED
+  gEfiEdidActiveProtocolGuid                              ## UNDEFINED
+  gEfiEdidOverrideProtocolGuid                            ## UNDEFINED
+  gEfiLoadFileProtocolGuid                                ## UNDEFINED
+  gEfiLoadFile2ProtocolGuid                               ## UNDEFINED
+  gEfiTapeIoProtocolGuid                                  ## UNDEFINED
+  gEfiDiskIoProtocolGuid                                  ## UNDEFINED
+  gEfiBlockIoProtocolGuid                                 ## UNDEFINED
+  gEfiUnicodeCollationProtocolGuid                        ## UNDEFINED
+  gEfiPciRootBridgeIoProtocolGuid                         ## UNDEFINED
+  gEfiPciIoProtocolGuid                                   ## UNDEFINED
+  gEfiScsiPassThruProtocolGuid                            ## UNDEFINED
+  gEfiScsiIoProtocolGuid                                  ## UNDEFINED
+  gEfiExtScsiPassThruProtocolGuid                         ## UNDEFINED
+  gEfiIScsiInitiatorNameProtocolGuid                      ## UNDEFINED
+  gEfiUsbIoProtocolGuid                                   ## UNDEFINED
+  gEfiUsbHcProtocolGuid                                   ## UNDEFINED
+  gEfiUsb2HcProtocolGuid                                  ## UNDEFINED
+  gEfiDebugSupportProtocolGuid                            ## UNDEFINED
+  gEfiDebugPortProtocolGuid                               ## UNDEFINED
+  gEfiDecompressProtocolGuid                              ## UNDEFINED
+  gEfiAcpiTableProtocolGuid                               ## UNDEFINED
+  gEfiEbcProtocolGuid                                     ## UNDEFINED
+  gEfiSimpleNetworkProtocolGuid                           ## UNDEFINED
+  gEfiNetworkInterfaceIdentifierProtocolGuid              ## UNDEFINED
+  gEfiNetworkInterfaceIdentifierProtocolGuid_31           ## UNDEFINED
+  gEfiPxeBaseCodeProtocolGuid                             ## UNDEFINED
+  gEfiPxeBaseCodeCallbackProtocolGuid                     ## UNDEFINED
+  gEfiBisProtocolGuid                                     ## UNDEFINED
+  gEfiManagedNetworkServiceBindingProtocolGuid            ## UNDEFINED
+  gEfiManagedNetworkProtocolGuid                          ## UNDEFINED
+  gEfiArpServiceBindingProtocolGuid                       ## UNDEFINED
+  gEfiArpProtocolGuid                                     ## UNDEFINED
+  gEfiDhcp4ServiceBindingProtocolGuid                     ## UNDEFINED
+  gEfiDhcp4ProtocolGuid                                   ## UNDEFINED
+  gEfiTcp4ServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiTcp4ProtocolGuid                                    ## UNDEFINED
+  gEfiIp4ServiceBindingProtocolGuid                       ## UNDEFINED
+  gEfiIp4ProtocolGuid                                     ## UNDEFINED
+  gEfiIp4ConfigProtocolGuid                               ## UNDEFINED
+  gEfiUdp4ServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiUdp4ProtocolGuid                                    ## UNDEFINED
+  gEfiMtftp4ServiceBindingProtocolGuid                    ## UNDEFINED
+  gEfiMtftp4ProtocolGuid                                  ## UNDEFINED
+  gEfiAuthenticationInfoProtocolGuid                      ## UNDEFINED
+  gEfiHashServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiHashProtocolGuid                                    ## UNDEFINED
+  gEfiHiiFontProtocolGuid                                 ## UNDEFINED
+  gEfiHiiStringProtocolGuid                               ## UNDEFINED
+  gEfiHiiImageProtocolGuid                                ## UNDEFINED
+  gEfiHiiConfigRoutingProtocolGuid                        ## UNDEFINED
+  gEfiHiiConfigAccessProtocolGuid                         ## UNDEFINED
+  gEfiFormBrowser2ProtocolGuid                            ## UNDEFINED
+  gEfiDeviceIoProtocolGuid                                ## UNDEFINED
+  gEfiUgaDrawProtocolGuid                                 ## UNDEFINED
+  gEfiUgaIoProtocolGuid                                   ## UNDEFINED
+  gEfiDriverConfigurationProtocolGuid                     ## UNDEFINED
+  gEfiDriverConfiguration2ProtocolGuid                    ## UNDEFINED
+  gEfiSimpleTextInputExProtocolGuid                       ## UNDEFINED
+  gEfiIp6ServiceBindingProtocolGuid                       ## UNDEFINED
+  gEfiIp6ProtocolGuid                                     ## UNDEFINED
+  gEfiIp6ConfigProtocolGuid                               ## UNDEFINED
+  gEfiMtftp6ServiceBindingProtocolGuid                    ## UNDEFINED
+  gEfiMtftp6ProtocolGuid                                  ## UNDEFINED
+  gEfiDhcp6ServiceBindingProtocolGuid                     ## UNDEFINED
+  gEfiDhcp6ProtocolGuid                                   ## UNDEFINED
+  gEfiUdp6ServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiUdp6ProtocolGuid                                    ## UNDEFINED
+  gEfiTcp6ServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiTcp6ProtocolGuid                                    ## UNDEFINED
+  gEfiVlanConfigProtocolGuid                              ## UNDEFINED
+  gEfiEapProtocolGuid                                     ## UNDEFINED
+  gEfiEapManagementProtocolGuid                           ## UNDEFINED
+  gEfiFtp4ServiceBindingProtocolGuid                      ## UNDEFINED
+  gEfiFtp4ProtocolGuid                                    ## UNDEFINED
+  gEfiIpSecConfigProtocolGuid                             ## UNDEFINED
+  gEfiDriverHealthProtocolGuid                            ## UNDEFINED
+  gEfiDeferredImageLoadProtocolGuid                       ## UNDEFINED
+  gEfiUserCredentialProtocolGuid                          ## UNDEFINED
+  gEfiUserManagerProtocolGuid                             ## UNDEFINED
+  gEfiAtaPassThruProtocolGuid                             ## UNDEFINED
+  gEfiFirmwareManagementProtocolGuid                      ## UNDEFINED
+  gEfiIpSecProtocolGuid                                   ## UNDEFINED
+  gEfiIpSec2ProtocolGuid                                  ## UNDEFINED
+  gEfiKmsProtocolGuid                                     ## UNDEFINED
+  gEfiBlockIo2ProtocolGuid                                ## UNDEFINED
+  gEfiStorageSecurityCommandProtocolGuid                  ## UNDEFINED
+  gEfiUserCredential2ProtocolGuid                         ## UNDEFINED
+  gPcdProtocolGuid                                        ## UNDEFINED
+  gEfiTcgProtocolGuid                                     ## UNDEFINED
+  gEfiHiiPackageListProtocolGuid                          ## UNDEFINED
+  gEfiDriverFamilyOverrideProtocolGuid                    ## UNDEFINED
+  gEfiIdeControllerInitProtocolGuid                       ## UNDEFINED
+  gEfiDiskIo2ProtocolGuid                                 ## UNDEFINED
+  gEfiAdapterInformationProtocolGuid                      ## UNDEFINED
+  gEfiShellDynamicCommandProtocolGuid                     ## UNDEFINED
 [Guids]
   gEfiFileInfoGuid                              # ALWAYS_CONSUMED
   gEfiShellEnvironment2ExtGuid                  # ALWAYS_CONSUMED
   gEfiPcAnsiGuid
   gEfiVT100Guid
   gEfiVT100PlusGuid
   gEfiVTUTF8Guid
   gEfiStandardErrorDeviceGuid
   gEfiConsoleInDeviceGuid
   gEfiConsoleOutDeviceGuid
   gEfiFileSystemInfoGuid
   gEfiGlobalVariableGuid
   gEfiPartTypeSystemPartGuid
   gEfiPartTypeLegacyMbrGuid
   gHandleParsingHiiGuid
+  gEfiFileInfoGuid                                        ## CONSUMES ## GUID
+  gEfiShellEnvironment2ExtGuid                            ## CONSUMES ## GUID
+  gEfiPcAnsiGuid                                          ## UNDEFINED
+  gEfiVT100Guid                                           ## UNDEFINED
+  gEfiVT100PlusGuid                                       ## UNDEFINED
+  gEfiVTUTF8Guid                                          ## UNDEFINED
+  gEfiStandardErrorDeviceGuid                             ## UNDEFINED
+  gEfiConsoleInDeviceGuid                                 ## UNDEFINED
+  gEfiConsoleOutDeviceGuid                                ## UNDEFINED
+  gEfiFileSystemInfoGuid                                  ## UNDEFINED
+  gEfiGlobalVariableGuid                                  ## UNDEFINED
+  gEfiPartTypeSystemPartGuid                              ## UNDEFINED
+  gEfiPartTypeLegacyMbrGuid                               ## UNDEFINED
+  gHandleParsingHiiGuid                                   ## UNDEFINED
 [Pcd.common]
   gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize     # ALWAYS_CONSUMED
   gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize       # ALWAYS_CONSUMED
   gEfiShellPkgTokenSpaceGuid.PcdShellIncludeNtGuids        # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize    ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize      ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellIncludeNtGuids       ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCEntryLib/UefiShellCEntryLib.c

-              r48674
+              r58459
   Provides application point extension for "C" style main funciton
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   An application that uses UefiShellCEntryLib must have a ShellAppMain
   function as prototyped in Include/Library/ShellCEntryLib.h.
+  Note that the Shell uses POSITIVE integers for error values, while UEFI
+  uses NEGATIVE values.  If the application is to be used within a script,
+  it needs to return one of the SHELL_STATUS values defined in ShellBase.h.
   @param  ImageHandle  The image handle of the UEFI Application.
 …
+    }
+  }
+  if (ReturnFromMain == 0) {
+    return (EFI_SUCCESS);
+  } else {
+    return (EFI_UNSUPPORTED);
+  }
+  return ReturnFromMain;
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCEntryLib/UefiShellCEntryLib.inf

-              r48674
+              r58459
 #  Provides interface to shell functionality for shell commands and applications.
+#
 #  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
 [Protocols]
   gEfiShellParametersProtocolGuid                         # ALWAYS_CONSUMED
   gEfiShellInterfaceGuid                                  # SOMETIMES_CONSUMED
+  gEfiShellParametersProtocolGuid                         ## CONSUMES
+  gEfiShellInterfaceGuid                                  ## SOMETIMES_CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCommandLib/ConsistMapping.c

-              r48674
+              r58459
   Main file for support of shell consist mapping.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
+  }
   StrCat (Str->Str, AppendStr);
+  StrnCat (Str->Str, AppendStr, StringSize/sizeof(CHAR16) - 1 - StrLen(Str->Str));
   Str->Len = StringSize;
 …
 DEV_PATH_CONSIST_MAPPING_TABLE  DevPathConsistMappingTable[] = {
+  HARDWARE_DEVICE_PATH,
+  HW_PCI_DP,
+  DevPathSerialDefault,
+  DevPathComparePci,
+  ACPI_DEVICE_PATH,
+  ACPI_DP,
+  DevPathSerialAcpi,
+  DevPathCompareAcpi,
+  MESSAGING_DEVICE_PATH,
+  MSG_ATAPI_DP,
+  DevPathSerialAtapi,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_SCSI_DP,
+  DevPathSerialScsi,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_FIBRECHANNEL_DP,
+  DevPathSerialFibre,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_1394_DP,
+  DevPathSerial1394,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_USB_DP,
+  DevPathSerialUsb,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_I2O_DP,
+  DevPathSerialI2O,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_MAC_ADDR_DP,
+  DevPathSerialMacAddr,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_IPv4_DP,
+  DevPathSerialIPv4,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_IPv6_DP,
+  DevPathSerialIPv6,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_INFINIBAND_DP,
+  DevPathSerialInfiniBand,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_UART_DP,
+  DevPathSerialUart,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_VENDOR_DP,
+  DevPathSerialVendor,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_DEVICE_LOGICAL_UNIT_DP,
+  DevPathSerialLun,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_SATA_DP,
+  DevPathSerialSata,
+  DevPathCompareDefault,
+  MESSAGING_DEVICE_PATH,
+  MSG_ISCSI_DP,
+  DevPathSerialIScsi,
+  DevPathCompareDefault,
+  MEDIA_DEVICE_PATH,
+  MEDIA_HARDDRIVE_DP,
+  DevPathSerialHardDrive,
+  DevPathCompareDefault,
+  MEDIA_DEVICE_PATH,
+  MEDIA_CDROM_DP,
+  DevPathSerialCdRom,
+  DevPathCompareDefault,
+  MEDIA_DEVICE_PATH,
+  MEDIA_VENDOR_DP,
+  DevPathSerialVendor,
+  DevPathCompareDefault,
+,
+,
+  NULL,
+  NULL
+  {
+    HARDWARE_DEVICE_PATH,
+    HW_PCI_DP,
+    DevPathSerialDefault,
+    DevPathComparePci
+  },
+  {
+    ACPI_DEVICE_PATH,
+    ACPI_DP,
+    DevPathSerialAcpi,
+    DevPathCompareAcpi
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_ATAPI_DP,
+    DevPathSerialAtapi,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_SCSI_DP,
+    DevPathSerialScsi,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_FIBRECHANNEL_DP,
+    DevPathSerialFibre,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_1394_DP,
+    DevPathSerial1394,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_USB_DP,
+    DevPathSerialUsb,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_I2O_DP,
+    DevPathSerialI2O,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_MAC_ADDR_DP,
+    DevPathSerialMacAddr,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_IPv4_DP,
+    DevPathSerialIPv4,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_IPv6_DP,
+    DevPathSerialIPv6,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_INFINIBAND_DP,
+    DevPathSerialInfiniBand,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_UART_DP,
+    DevPathSerialUart,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_VENDOR_DP,
+    DevPathSerialVendor,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_DEVICE_LOGICAL_UNIT_DP,
+    DevPathSerialLun,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_SATA_DP,
+    DevPathSerialSata,
+    DevPathCompareDefault
+  },
+  {
+    MESSAGING_DEVICE_PATH,
+    MSG_ISCSI_DP,
+    DevPathSerialIScsi,
+    DevPathCompareDefault
+  },
+  {
+    MEDIA_DEVICE_PATH,
+    MEDIA_HARDDRIVE_DP,
+    DevPathSerialHardDrive,
+    DevPathCompareDefault
+  },
+  {
+    MEDIA_DEVICE_PATH,
+    MEDIA_CDROM_DP,
+    DevPathSerialCdRom,
+    DevPathCompareDefault
+  },
+  {
+    MEDIA_DEVICE_PATH,
+    MEDIA_VENDOR_DP,
+    DevPathSerialVendor,
+    DevPathCompareDefault
+  },
+  {
+,
+,
+    NULL,
+    NULL
+  }
 };

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCommandLib/UefiShellCommandLib.c

-              r48674
+              r58459
   Provides interface to shell internal functions for shell commands.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013-2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellCommandLib.h"
-/// The tag for use in identifying UNICODE files.
-/// If the file is UNICODE, the first 16 bits of the file will equal this value.
-enum {
-  gUnicodeFileTag = 0xFEFF
-};
 // STATIC local variables
 …
 // global variables required by library class.
 EFI_UNICODE_COLLATION_PROTOCOL    *gUnicodeCollation            = NULL;
-EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *gDevPathToText               = NULL;
 SHELL_MAP_LIST                    gShellMapList;
 SHELL_MAP_LIST                    *gShellCurDir                 = NULL;
 …
   if (gUnicodeCollation == NULL) {
     Status = gBS->LocateProtocol(&gEfiUnicodeCollation2ProtocolGuid, NULL, (VOID**)&gUnicodeCollation);
-    if (EFI_ERROR(Status)) {
-      return (EFI_DEVICE_ERROR);
+    }
+  }
-  if (gDevPathToText == NULL) {
-    Status = gBS->LocateProtocol(&gEfiDevicePathToTextProtocolGuid, NULL, (VOID**)&gDevPathToText);
     if (EFI_ERROR(Status)) {
       return (EFI_DEVICE_ERROR);
 …
 /**
+  Frees list of file handles.
+  @param[in] List     The list to free.
+**/
+VOID
+EFIAPI
+FreeFileHandleList (
+  IN BUFFER_LIST *List
+  )
+{
+  BUFFER_LIST               *BufferListEntry;
+  if (List == NULL){
+    return;
+  }
+  //
+  // enumerate through the buffer list and free all memory
+  //
+  for ( BufferListEntry = ( BUFFER_LIST *)GetFirstNode(&List->Link)
+      ; !IsListEmpty (&List->Link)
+      ; BufferListEntry = (BUFFER_LIST *)GetFirstNode(&List->Link)
+     ){
+    RemoveEntryList(&BufferListEntry->Link);
+    ASSERT(BufferListEntry->Buffer != NULL);
+    SHELL_FREE_NON_NULL(((SHELL_COMMAND_FILE_HANDLE*)(BufferListEntry->Buffer))->Path);
+    SHELL_FREE_NON_NULL(BufferListEntry->Buffer);
+    SHELL_FREE_NON_NULL(BufferListEntry);
+  }
+}
+/**
   Destructor for the library.  free any resources.
 …
+{
   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
   COMMAND_LIST                      *Node2;
+  ALIAS_LIST                        *Node2;
   SCRIPT_FILE_LIST                  *Node3;
   SHELL_MAP_LIST                    *MapNode;
 …
   //
   // enumerate through the init command list and free all memory
+  // enumerate through the alias list and free all memory
   //
   while (!IsListEmpty (&mAliasList.Link)) {
     Node2 = (COMMAND_LIST *)GetFirstNode(&mAliasList.Link);
+    Node2 = (ALIAS_LIST *)GetFirstNode(&mAliasList.Link);
     RemoveEntryList(&Node2->Link);
     SHELL_FREE_NON_NULL(Node2->CommandString);
+    FreePool(Node2);
+    SHELL_FREE_NON_NULL(Node2->Alias);
+    SHELL_FREE_NON_NULL(Node2);
     DEBUG_CODE(Node2 = NULL;);
+  }
 …
+  }
   if (!IsListEmpty(&mFileHandleList.Link)){
     FreeBufferList(&mFileHandleList);
+    FreeFileHandleList(&mFileHandleList);
+  }
 …
   gUnicodeCollation            = NULL;
-  gDevPathToText               = NULL;
   gShellCurDir                 = NULL;
 …
 /**
+  Checks if a command is already on the list.
+  Find a dynamic command protocol instance given a command name string.
+  @param CommandString  the command name string
+  @return instance      the command protocol instance, if dynamic command instance found
+  @retval NULL          no dynamic command protocol instance found for name
+**/
+CONST EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL *
+EFIAPI
+ShellCommandFindDynamicCommand (
+  IN CONST CHAR16 *CommandString
+  )
+{
+  EFI_STATUS                          Status;
+  EFI_HANDLE                          *CommandHandleList;
+  EFI_HANDLE                          *NextCommand;
+  EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
+  CommandHandleList = GetHandleListByProtocol(&gEfiShellDynamicCommandProtocolGuid);
+  if (CommandHandleList == NULL) {
+    //
+    // not found or out of resources
+    //
+    return NULL;
+  }
+  for (NextCommand = CommandHandleList; *NextCommand != NULL; NextCommand++) {
+    Status = gBS->HandleProtocol(
+      *NextCommand,
+      &gEfiShellDynamicCommandProtocolGuid,
+      (VOID **)&DynamicCommand
+      );
+    if (EFI_ERROR(Status)) {
+      continue;
+    }
+    if (gUnicodeCollation->StriColl(
+          gUnicodeCollation,
+          (CHAR16*)CommandString,
+          (CHAR16*)DynamicCommand->CommandName) == 0
+          ){
+        FreePool(CommandHandleList);
+        return (DynamicCommand);
+    }
+  }
+  FreePool(CommandHandleList);
+  return (NULL);
+}
+/**
+  Checks if a command exists as a dynamic command protocol instance
   @param[in] CommandString        The command string to check for on the list.
 …
 BOOLEAN
 EFIAPI
+ShellCommandIsCommandOnList (
+  IN CONST  CHAR16                      *CommandString
+ShellCommandDynamicCommandExists (
+  IN CONST CHAR16 *CommandString
+  )
+{
+  return (BOOLEAN) ((ShellCommandFindDynamicCommand(CommandString) != NULL));
+}
+/**
+  Checks if a command is already on the internal command list.
+  @param[in] CommandString        The command string to check for on the list.
+**/
+BOOLEAN
+EFIAPI
+ShellCommandIsCommandOnInternalList(
+  IN CONST  CHAR16 *CommandString
+  )
+{
 …
 /**
+  Get the help text for a command.
+  Checks if a command exists, either internally or through the dynamic command protocol.
+  @param[in] CommandString        The command string to check for on the list.
+**/
+BOOLEAN
+EFIAPI
+ShellCommandIsCommandOnList(
+  IN CONST  CHAR16                      *CommandString
+  )
+{
+  if (ShellCommandIsCommandOnInternalList(CommandString)) {
+    return TRUE;
+  }
+  return ShellCommandDynamicCommandExists(CommandString);
+}
+/**
+ Get the help text for a dynamic command.
+  @param[in] CommandString        The command name.
+  @retval NULL  No help text was found.
+  @return       String of help text. Caller required to free.
+**/
+CHAR16*
+EFIAPI
+ShellCommandGetDynamicCommandHelp(
+  IN CONST  CHAR16                      *CommandString
+  )
+{
+  EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
+  DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *)ShellCommandFindDynamicCommand(CommandString);
+  if (DynamicCommand == NULL) {
+    return (NULL);
+  }
+  //
+  // TODO: how to get proper language?
+  //
+  return DynamicCommand->GetHelp(DynamicCommand, "en");
+}
+/**
+  Get the help text for an internal command.
   @param[in] CommandString        The command name.
 …
 CHAR16*
 EFIAPI
 ShellCommandGetCommandHelp (
+ShellCommandGetInternalCommandHelp(
   IN CONST  CHAR16                      *CommandString
+  )
 …
   return (NULL);
+}
+/**
+  Get the help text for a command.
+  @param[in] CommandString        The command name.
+  @retval NULL  No help text was found.
+  @return       String of help text.Caller reuiqred to free.
+**/
+CHAR16*
+EFIAPI
+ShellCommandGetCommandHelp (
+  IN CONST  CHAR16                      *CommandString
+  )
+{
+  CHAR16      *HelpStr;
+  HelpStr = ShellCommandGetInternalCommandHelp(CommandString);
+  if (HelpStr == NULL) {
+    HelpStr = ShellCommandGetDynamicCommandHelp(CommandString);
+  }
+  return HelpStr;
+}
 /**
 …
+{
   SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
+  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Command;
+  SHELL_COMMAND_INTERNAL_LIST_ENTRY *PrevCommand;
+  INTN LexicalMatchValue;
+  //
+  // Initialize local variables.
+  //
+  Command = NULL;
+  PrevCommand = NULL;
+  LexicalMatchValue = 0;
   //
 …
   Node = AllocateZeroPool(sizeof(SHELL_COMMAND_INTERNAL_LIST_ENTRY));
   ASSERT(Node != NULL);
   Node->CommandString = AllocateZeroPool(StrSize(CommandString));
+  Node->CommandString = AllocateCopyPool(StrSize(CommandString), CommandString);
   ASSERT(Node->CommandString != NULL);
-  //
-  // populate the new struct
-  //
-  StrCpy(Node->CommandString, CommandString);
   Node->GetManFileName  = GetManFileName;
 …
   //
+  // add the new struct to the list
+  //
+  InsertTailList (&mCommandList.Link, &Node->Link);
+  // Insert a new entry on top of the list
+  //
+  InsertHeadList (&mCommandList.Link, &Node->Link);
+  //
+  // Move a new registered command to its sorted ordered location in the list
+  //
+  for (Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link),
+        PrevCommand = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetFirstNode (&mCommandList.Link)
+        ; !IsNull (&mCommandList.Link, &Command->Link)
+        ; Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *)GetNextNode (&mCommandList.Link, &Command->Link)) {
+    //
+    // Get Lexical Comparison Value between PrevCommand and Command list entry
+    //
+    LexicalMatchValue = gUnicodeCollation->StriColl (
+                                             gUnicodeCollation,
+                                             PrevCommand->CommandString,
+                                             Command->CommandString
+                                             );
+    //
+    // Swap PrevCommand and Command list entry if PrevCommand list entry
+    // is alphabetically greater than Command list entry
+    //
+    if (LexicalMatchValue > 0){
+      Command = (SHELL_COMMAND_INTERNAL_LIST_ENTRY *) SwapListEntries (&PrevCommand->Link, &Command->Link);
+    } else if (LexicalMatchValue < 0) {
+      //
+      // PrevCommand entry is lexically lower than Command entry
+      //
+      break;
+    }
+  }
   return (RETURN_SUCCESS);
 …
+  )
+{
+  SHELL_COMMAND_INTERNAL_LIST_ENTRY *Node;
+  SHELL_COMMAND_INTERNAL_LIST_ENTRY   *Node;
+  EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
   //
 …
           (CHAR16*)CommandString,
           Node->CommandString) == 0
        ){
+      ){
       if (CanAffectLE != NULL) {
         *CanAffectLE = Node->LastError;
 …
+    }
+  }
+  //
+  // An internal command was not found, try to find a dynamic command
+  //
+  DynamicCommand = (EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *)ShellCommandFindDynamicCommand(CommandString);
+  if (DynamicCommand != NULL) {
+    if (RetVal != NULL) {
+      *RetVal = DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
+    } else {
+      DynamicCommand->Handler(DynamicCommand, gST, gEfiShellParametersProtocol, gEfiShellProtocol);
+    }
+    return (RETURN_SUCCESS);
+  }
   return (RETURN_NOT_FOUND);
+}
 …
+{
   ALIAS_LIST *Node;
+  ALIAS_LIST *CommandAlias;
+  ALIAS_LIST *PrevCommandAlias;
+  INTN       LexicalMatchValue;
   //
 …
   Node = AllocateZeroPool(sizeof(ALIAS_LIST));
   ASSERT(Node != NULL);
   Node->CommandString = AllocateZeroPool(StrSize(Command));
   Node->Alias = AllocateZeroPool(StrSize(Alias));
+  Node->CommandString = AllocateCopyPool(StrSize(Command), Command);
+  Node->Alias = AllocateCopyPool(StrSize(Alias), Alias);
   ASSERT(Node->CommandString != NULL);
   ASSERT(Node->Alias != NULL);
+  //
+  // populate the new struct
+  //
+  StrCpy(Node->CommandString, Command);
+  StrCpy(Node->Alias        , Alias );
+  //
+  // add the new struct to the list
+  //
+  InsertTailList (&mAliasList.Link, &Node->Link);
+  InsertHeadList (&mAliasList.Link, &Node->Link);
+  //
+  // Move a new pre-defined registered alias to its sorted ordered location in the list
+  //
+  for ( CommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link),
+         PrevCommandAlias = (ALIAS_LIST *)GetFirstNode (&mAliasList.Link)
+       ; !IsNull (&mAliasList.Link, &CommandAlias->Link)
+       ; CommandAlias = (ALIAS_LIST *) GetNextNode (&mAliasList.Link, &CommandAlias->Link) ) {
+    //
+    // Get Lexical comparison value between PrevCommandAlias and CommandAlias List Entry
+    //
+    LexicalMatchValue = gUnicodeCollation->StriColl (
+                                             gUnicodeCollation,
+                                             PrevCommandAlias->Alias,
+                                             CommandAlias->Alias
+                                             );
+    //
+    // Swap PrevCommandAlias and CommandAlias list entry if PrevCommandAlias list entry
+    // is alphabetically greater than CommandAlias list entry
+    //
+    if (LexicalMatchValue > 0) {
+      CommandAlias = (ALIAS_LIST *) SwapListEntries (&PrevCommandAlias->Link, &CommandAlias->Link);
+    } else if (LexicalMatchValue < 0) {
+      //
+      // PrevCommandAlias entry is lexically lower than CommandAlias entry
+      //
+      break;
+    }
+  }
   return (RETURN_SUCCESS);
 …
 /**
   Function to determine current state of ECHO.  Echo determins if lines from scripts
+  Function to determine current state of ECHO.  Echo determines if lines from scripts
   and ECHO commands are enabled.
 …
 /**
   Function to set current state of ECHO.  Echo determins if lines from scripts
+  Function to set current state of ECHO.  Echo determines if lines from scripts
   and ECHO commands are enabled.
 …
   } else {
     MapListNode->Flags = Flags;
     MapListNode->MapName = AllocateZeroPool(StrSize(Name));
+    MapListNode->MapName = AllocateCopyPool(StrSize(Name), Name);
     MapListNode->DevicePath = DuplicateDevicePath(DevicePath);
     if ((MapListNode->MapName == NULL) || (MapListNode->DevicePath == NULL)){
       Status = EFI_OUT_OF_RESOURCES;
     } else {
-      StrCpy(MapListNode->MapName, Name);
       InsertTailList(&gShellMapList.Link, &MapListNode->Link);
+    }
 …
 /**
+  Add mappings for any devices without one.  Do not change any existing maps.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellCommandUpdateMapping (
+  VOID
+  )
+{
+  EFI_STATUS                Status;
+  EFI_HANDLE                *HandleList;
+  UINTN                     Count;
+  EFI_DEVICE_PATH_PROTOCOL  **DevicePathList;
+  CHAR16                    *NewDefaultName;
+  CHAR16                    *NewConsistName;
+  EFI_DEVICE_PATH_PROTOCOL  **ConsistMappingTable;
+  HandleList  = NULL;
+  Status      = EFI_SUCCESS;
+  //
+  // remove mappings that represent removed devices.
+  //
+  //
+  // Find each handle with Simple File System
+  //
+  HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
+  if (HandleList != NULL) {
+    //
+    // Do a count of the handles
+    //
+    for (Count = 0 ; HandleList[Count] != NULL ; Count++);
+    //
+    // Get all Device Paths
+    //
+    DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
+    if (DevicePathList == NULL) {
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
+      DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
+    }
+    //
+    // Sort all DevicePaths
+    //
+    PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
+    ShellCommandConsistMappingInitialize(&ConsistMappingTable);
+    //
+    // Assign new Mappings to remainders
+    //
+    for (Count = 0 ; !EFI_ERROR(Status) && HandleList[Count] != NULL && !EFI_ERROR(Status); Count++) {
+      //
+      // Skip ones that already have
+      //
+      if (gEfiShellProtocol->GetMapFromDevicePath(&DevicePathList[Count]) != NULL) {
+        continue;
+      }
+      //
+      // Get default name
+      //
+      NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
+      if (NewDefaultName == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+        break;
+      }
+      //
+      // Call shell protocol SetMap function now...
+      //
+      Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewDefaultName);
+      if (!EFI_ERROR(Status)) {
+        //
+        // Now do consistent name
+        //
+        NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
+        if (NewConsistName != NULL) {
+          Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewConsistName);
+          FreePool(NewConsistName);
+        }
+      }
+      FreePool(NewDefaultName);
+    }
+    ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
+    SHELL_FREE_NON_NULL(HandleList);
+    SHELL_FREE_NON_NULL(DevicePathList);
+    HandleList = NULL;
+  } else {
+    Count = (UINTN)-1;
+  }
+  //
+  // Do it all over again for gEfiBlockIoProtocolGuid
+  //
+  return (Status);
+}
+/**
   Converts a SHELL_FILE_HANDLE to an EFI_FILE_PROTOCOL*.
 …
     NewNode             = AllocateZeroPool(sizeof(BUFFER_LIST));
     if (NewNode == NULL) {
+      SHELL_FREE_NON_NULL(Buffer);
       return (NULL);
+    }
 …
     Buffer->Path        = StrnCatGrow(&Buffer->Path, NULL, Path, 0);
     if (Buffer->Path == NULL) {
+      SHELL_FREE_NON_NULL(NewNode);
+      SHELL_FREE_NON_NULL(Buffer);
       return (NULL);
+    }
 …
      ){
     RemoveEntryList(&BufferListEntry->Link);
-    ASSERT(BufferListEntry->Buffer != NULL);
     if (BufferListEntry->Buffer != NULL) {
       FreePool(BufferListEntry->Buffer);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCommandLib/UefiShellCommandLib.h

-              r48674
+              r58459
   Provides interface to shell internal functions for shell commands.
   Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Protocol/UnicodeCollation.h>
 #include <Protocol/BlockIo.h>
+#include <Protocol/EfiShellDynamicCommand.h>
 #include <Library/DevicePathLib.h>

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellCommandLib/UefiShellCommandLib.inf

-              r48674
+              r58459
 #  Provides interface to shell internal functions for shell commands.
+#
 #  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2006 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = ShellCommandLib|UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = ShellCommandLib|UEFI_APPLICATION UEFI_DRIVER DXE_RUNTIME_DRIVER
   CONSTRUCTOR                    = ShellCommandLibConstructor
   DESTRUCTOR                     = ShellCommandLibDestructor
 …
   ShellLib
   HiiLib
+  HandleParsingLib
 [Protocols]
   gEfiUnicodeCollation2ProtocolGuid                       # ALWAYS_CONSUMED
   gEfiShellProtocolGuid                                   # ALWAYS_CONSUMED
   gEfiShellParametersProtocolGuid                         # ALWAYS_CONSUMED
   gEfiDevicePathToTextProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiUnicodeCollation2ProtocolGuid                       ## CONSUMES
+  gEfiShellProtocolGuid                                   ## CONSUMES
+  gEfiShellParametersProtocolGuid                         ## CONSUMES
+  gEfiShellDynamicCommandProtocolGuid                     ## SOMETIMES_CONSUMES
 [Guids]
   gEfiSasDevicePathGuid                                   # ALWAYS_CONSUMED
+  gEfiSasDevicePathGuid                                   ## CONSUMES ## GUID
 [Pcd.common]
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         ## ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellMapNameLength        ## ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellMapNameLength        ## CONSUMES
+[Depex]
+  gEfiUnicodeCollation2ProtocolGuid

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Comp.c

-              r48674
+              r58459
   Main file for Comp shell Debug1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   CHAR16              *FileName2;
   CONST CHAR16        *TempParam;
+  UINTN               ErrorAddress;
   ErrorCount          = 0;
 …
           ASSERT_EFI_ERROR(Status);
           if (DataFromFile1 != DataFromFile2) {
+            ErrorAddress = LoopVar;
             ADF_File11 = 0;
             ADF_File12 = 0;
 …
             ADF_File22 = 0;
             ADF_File23 = 0;
+            //
+            // Now check the next 3 bytes if possible.  This will make output
+            // cleaner when there are a sequence of differences.
+            //
             if (LoopVar + 1 < Size1) {
               LoopVar++;
 …
+              }
+            }
+            //
+            // Print out based on highest of the 4 bytes that are different.
+            //
             if (ADF_File13 != ADF_File23) {
               ShellPrintHiiEx(
 …
                 ++ErrorCount,
                 FileName1,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile1, ADF_File11, ADF_File12, ADF_File13,
                 DataFromFile1, ADF_File11, ADF_File12, ADF_File13,
                 FileName2,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile2, ADF_File21, ADF_File22, ADF_File23,
                 DataFromFile2, ADF_File21, ADF_File22, ADF_File23
 …
                 ++ErrorCount,
                 FileName1,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile1, ADF_File11, ADF_File12,
                 DataFromFile1, ADF_File11, ADF_File12,
                 FileName2,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile2, ADF_File21, ADF_File22,
                 DataFromFile2, ADF_File21, ADF_File22
 …
                 ++ErrorCount,
                 FileName1,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile1, ADF_File11,
                 DataFromFile1, ADF_File11,
                 FileName2,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile2, ADF_File21,
                 DataFromFile2, ADF_File21
 …
                 ++ErrorCount,
                 FileName1,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile1,
                 DataFromFile1,
                 FileName2,
                 LoopVar,
+                ErrorAddress,
                 DataFromFile2,
                 DataFromFile2

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Compress.c

-              r48674
+              r58459
   are applied to each Block.
   Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/DebugLib.h>
 #include <ShellBase.h>
+#include <Uefi.h>
 //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Dmem.c

-              r48674
+              r58459
   } else {
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMEM_MMIO_HEADER_ROW), gShellDebug1HiiHandle, (UINT64)(UINTN)Address, Size);
     DumpHex(2,0,Size,Buffer);
+    DumpHex(2, (UINTN)Address, Size, Buffer);
+  }
 …
       if (!ShellCommandLineGetFlag(Package, L"-mmio")) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMEM_HEADER_ROW), gShellDebug1HiiHandle, (UINT64)(UINTN)Address, Size);
         DumpHex(2,0,(UINTN)Size,Address);
+        DumpHex(2, (UINTN)Address, (UINTN)Size, Address);
         if (Address == (VOID*)gST) {
           Acpi20TableAddress  = 0;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/DmpStore.c

-              r48674
+              r58459
 /** @file
   Main file for DmpStore shell Debug1 function.
+  Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellDebug1CommandsLib.h"
+STATIC CHAR16   *AttrType[] = {
+  L"invalid",   // 000
+  L"invalid",   // 001
+  L"BS",        // 010
+  L"NV+BS",     // 011
+  L"RT+BS",     // 100
+  L"NV+RT+BS",  // 101
+  L"RT+BS",     // 110
+  L"NV+RT+BS",  // 111
+};
+typedef enum {
+  DmpStoreDisplay,
+  DmpStoreDelete,
+  DmpStoreSave,
+  DmpStoreLoad
+} DMP_STORE_TYPE;
+typedef struct {
+  UINT32     Signature;
+  CHAR16     *Name;
+  EFI_GUID   Guid;
+  UINT32     Attributes;
+  UINT32     DataSize;
+  UINT8      *Data;
+  LIST_ENTRY Link;
+} DMP_STORE_VARIABLE;
+#define DMP_STORE_VARIABLE_SIGNATURE  SIGNATURE_32 ('_', 'd', 's', 's')
 /**
+  Function to display or delete variables.
+  @param[in] VariableName   The variable name of the EFI variable (or NULL).
+  Base on the input attribute value to return the attribute string.
+  @param[in]     Atts           The input attribute value
+  @retval The attribute string info.
+**/
+CHAR16 *
+EFIAPI
+GetAttrType (
+  IN CONST UINT32 Atts
+  )
+{
+  UINTN  BufLen;
+  CHAR16 *RetString;
+  BufLen      = 0;
+  RetString   = NULL;
+  if ((Atts & EFI_VARIABLE_NON_VOLATILE) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+NV", 0);
+  }
+  if ((Atts & EFI_VARIABLE_RUNTIME_ACCESS) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+RT+BS", 0);
+  } else if ((Atts & EFI_VARIABLE_BOOTSERVICE_ACCESS) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+BS", 0);
+  }
+  if ((Atts & EFI_VARIABLE_HARDWARE_ERROR_RECORD) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+HR", 0);
+  }
+  if ((Atts & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+AW", 0);
+  }
+  if ((Atts & EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS) != 0) {
+    StrnCatGrow (&RetString, &BufLen, L"+AT", 0);
+  }
+  if (RetString == NULL) {
+    RetString = StrnCatGrow(&RetString, &BufLen, L"Invalid", 0);
+  }
+  if ((RetString != NULL) && (RetString[0] == L'+')) {
+    CopyMem(RetString, RetString + 1, StrSize(RetString + 1));
+  }
+  return RetString;
+}
+/**
+  Load the variable data from file and set to variable data base.
+  @param[in]  FileHandle     The file to be read.
+  @param[in]  Name           The name of the variables to be loaded.
+  @param[in]  Guid           The guid of the variables to be loaded.
+  @param[out] Found          TRUE when at least one variable was loaded and set.
+  @retval SHELL_DEVICE_ERROR      Cannot access the file.
+  @retval SHELL_VOLUME_CORRUPTED  The file is in bad format.
+  @retval SHELL_OUT_OF_RESOURCES  There is not enough memory to perform the operation.
+  @retval SHELL_SUCCESS           Successfully load and set the variables.
+**/
+SHELL_STATUS
+LoadVariablesFromFile (
+  IN SHELL_FILE_HANDLE FileHandle,
+  IN CONST CHAR16      *Name,
+  IN CONST EFI_GUID    *Guid,
+  OUT BOOLEAN          *Found
+  )
+{
+  EFI_STATUS           Status;
+  SHELL_STATUS         ShellStatus;
+  UINT32               NameSize;
+  UINT32               DataSize;
+  UINTN                BufferSize;
+  UINTN                RemainingSize;
+  UINT64               Position;
+  UINT64               FileSize;
+  LIST_ENTRY           List;
+  DMP_STORE_VARIABLE   *Variable;
+  LIST_ENTRY           *Link;
+  CHAR16               *Attributes;
+  UINT8                *Buffer;
+  UINT32               Crc32;
+  Status = ShellGetFileSize (FileHandle, &FileSize);
+  if (EFI_ERROR (Status)) {
+    return SHELL_DEVICE_ERROR;
+  }
+  ShellStatus = SHELL_SUCCESS;
+  InitializeListHead (&List);
+  Position = 0;
+  while (Position < FileSize) {
+    //
+    // NameSize
+    //
+    BufferSize = sizeof (NameSize);
+    Status = ShellReadFile (FileHandle, &BufferSize, &NameSize);
+    if (EFI_ERROR (Status) || (BufferSize != sizeof (NameSize))) {
+      ShellStatus = SHELL_VOLUME_CORRUPTED;
+      break;
+    }
+    //
+    // DataSize
+    //
+    BufferSize = sizeof (DataSize);
+    Status = ShellReadFile (FileHandle, &BufferSize, &DataSize);
+    if (EFI_ERROR (Status) || (BufferSize != sizeof (DataSize))) {
+      ShellStatus = SHELL_VOLUME_CORRUPTED;
+      break;
+    }
+    //
+    // Name, Guid, Attributes, Data, Crc32
+    //
+    RemainingSize = NameSize + sizeof (EFI_GUID) + sizeof (UINT32) + DataSize + sizeof (Crc32);
+    BufferSize    = sizeof (NameSize) + sizeof (DataSize) + RemainingSize;
+    Buffer        = AllocatePool (BufferSize);
+    if (Buffer == NULL) {
+      ShellStatus = SHELL_OUT_OF_RESOURCES;
+      break;
+    }
+    BufferSize    = RemainingSize;
+    Status = ShellReadFile (FileHandle, &BufferSize, (UINT32 *) Buffer + 2);
+    if (EFI_ERROR (Status) || (BufferSize != RemainingSize)) {
+      ShellStatus = SHELL_VOLUME_CORRUPTED;
+      FreePool (Buffer);
+      break;
+    }
+    //
+    // Check Crc32
+    //
+    * (UINT32 *) Buffer       = NameSize;
+    * ((UINT32 *) Buffer + 1) = DataSize;
+    BufferSize = RemainingSize + sizeof (NameSize) + sizeof (DataSize) - sizeof (Crc32);
+    gBS->CalculateCrc32 (
+           Buffer,
+           BufferSize,
+           &Crc32
+           );
+    if (Crc32 != * (UINT32 *) (Buffer + BufferSize)) {
+      FreePool (Buffer);
+      ShellStatus = SHELL_VOLUME_CORRUPTED;
+      break;
+    }
+    Position += BufferSize + sizeof (Crc32);
+    Variable = AllocateZeroPool (sizeof (*Variable) + NameSize + DataSize);
+    if (Variable == NULL) {
+      FreePool (Buffer);
+      ShellStatus = SHELL_OUT_OF_RESOURCES;
+      break;
+    }
+    Variable->Signature = DMP_STORE_VARIABLE_SIGNATURE;
+    Variable->Name      = (CHAR16 *) (Variable + 1);
+    Variable->DataSize  = DataSize;
+    Variable->Data      = (UINT8 *) Variable->Name + NameSize;
+    CopyMem (Variable->Name,        Buffer + sizeof (NameSize) + sizeof (DataSize),                                                  NameSize);
+    CopyMem (&Variable->Guid,       Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize,                                       sizeof (EFI_GUID));
+    CopyMem (&Variable->Attributes, Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID),                   sizeof (UINT32));
+    CopyMem (Variable->Data,        Buffer + sizeof (NameSize) + sizeof (DataSize) + NameSize + sizeof (EFI_GUID) + sizeof (UINT32), DataSize);
+    InsertTailList (&List, &Variable->Link);
+    FreePool (Buffer);
+  }
+  if ((Position != FileSize) || (ShellStatus != SHELL_SUCCESS)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_BAD_FILE), gShellDebug1HiiHandle);
+    if (Position != FileSize) {
+      ShellStatus = SHELL_VOLUME_CORRUPTED;
+    }
+  }
+  for ( Link = GetFirstNode (&List)
+      ; !IsNull (&List, Link) && (ShellStatus == SHELL_SUCCESS)
+      ; Link = GetNextNode (&List, Link)
+      ) {
+    Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
+    if (((Name == NULL) || gUnicodeCollation->MetaiMatch (gUnicodeCollation, Variable->Name, (CHAR16 *) Name)) &&
+        ((Guid == NULL) || CompareGuid (&Variable->Guid, Guid))
+       ) {
+      Attributes = GetAttrType (Variable->Attributes);
+      ShellPrintHiiEx (
+        -1, -1, NULL, STRING_TOKEN(STR_DMPSTORE_HEADER_LINE), gShellDebug1HiiHandle,
+        Attributes, &Variable->Guid, Variable->Name, Variable->DataSize
+        );
+      SHELL_FREE_NON_NULL(Attributes);
+      *Found = TRUE;
+      Status = gRT->SetVariable (
+                      Variable->Name,
+                      &Variable->Guid,
+                      Variable->Attributes,
+                      Variable->DataSize,
+                      Variable->Data
+                      );
+      if (EFI_ERROR (Status)) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD_GEN_FAIL), gShellDebug1HiiHandle, Variable->Name, Status);
+      }
+    }
+  }
+  for (Link = GetFirstNode (&List); !IsNull (&List, Link); ) {
+    Variable = CR (Link, DMP_STORE_VARIABLE, Link, DMP_STORE_VARIABLE_SIGNATURE);
+    Link = RemoveEntryList (&Variable->Link);
+    FreePool (Variable);
+  }
+  return ShellStatus;
+}
+/**
+  Append one variable to file.
+  @param[in] FileHandle        The file to be appended.
+  @param[in] Name              The variable name.
+  @param[in] Guid              The variable GUID.
+  @param[in] Attributes        The variable attributes.
+  @param[in] DataSize          The variable data size.
+  @param[in] Data              The variable data.
+  @retval EFI_OUT_OF_RESOURCES  There is not enough memory to perform the operation.
+  @retval EFI_SUCCESS           The variable is appended to file successfully.
+  @retval others                Failed to append the variable to file.
+**/
+EFI_STATUS
+AppendSingleVariableToFile (
+  IN SHELL_FILE_HANDLE FileHandle,
+  IN CONST CHAR16      *Name,
+  IN CONST EFI_GUID    *Guid,
+  IN UINT32            Attributes,
+  IN UINT32            DataSize,
+  IN CONST UINT8       *Data
+  )
+{
+  UINT32              NameSize;
+  UINT8               *Buffer;
+  UINT8               *Ptr;
+  UINTN               BufferSize;
+  EFI_STATUS          Status;
+  NameSize   = (UINT32) StrSize (Name);
+  BufferSize = sizeof (NameSize) + sizeof (DataSize)
+             + sizeof (*Guid)
+             + sizeof (Attributes)
+             + NameSize + DataSize
+             + sizeof (UINT32);
+  Buffer = AllocatePool (BufferSize);
+  if (Buffer == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  Ptr = Buffer;
+  //
+  // NameSize and DataSize
+  //
+  * (UINT32 *) Ptr = NameSize;
+  Ptr += sizeof (NameSize);
+  *(UINT32 *) Ptr = DataSize;
+  Ptr += sizeof (DataSize);
+  //
+  // Name
+  //
+  CopyMem (Ptr, Name, NameSize);
+  Ptr += NameSize;
+  //
+  // Guid
+  //
+  CopyMem (Ptr, Guid, sizeof (*Guid));
+  Ptr += sizeof (*Guid);
+  //
+  // Attributes
+  //
+  * (UINT32 *) Ptr = Attributes;
+  Ptr += sizeof (Attributes);
+  //
+  // Data
+  //
+  CopyMem (Ptr, Data, DataSize);
+  Ptr += DataSize;
+  //
+  // Crc32
+  //
+  gBS->CalculateCrc32 (Buffer, (UINTN) (Ptr - Buffer), (UINT32 *) Ptr);
+  Status = ShellWriteFile (FileHandle, &BufferSize, Buffer);
+  FreePool (Buffer);
+  if (!EFI_ERROR (Status) &&
+      (BufferSize != sizeof (NameSize) + sizeof (DataSize) + sizeof (*Guid) + sizeof (Attributes) + NameSize + DataSize)
+    ) {
+    Status = EFI_DEVICE_ERROR;
+  }
+  return Status;
+}
+/**
+  Recursive function to display or delete variables.
+  This function will call itself to create a stack-based list of allt he variables to process,
+  then fromt he last to the first, they will do either printing or deleting.
+  This is necessary since once a delete happens GetNextVariableName() will work.
+  @param[in] Name           The variable name of the EFI variable (or NULL).
   @param[in] Guid           The GUID of the variable set (or NULL).
+  @param[in] Delete         TRUE to delete, FALSE otherwise.
+  @param[in] Type           The operation type.
+  @param[in] FileHandle     The file to operate on (or NULL).
+  @param[in] PrevName       The previous variable name from GetNextVariableName. L"" to start.
+  @param[in] FoundVarGuid   The previous GUID from GetNextVariableName. ignored at start.
+  @param[in] FoundOne       If a VariableName or Guid was specified and one was printed or
+                            deleted, then set this to TRUE, otherwise ignored.
+  @retval SHELL_SUCCESS           The operation was successful.
+  @retval SHELL_OUT_OF_RESOURCES  A memorty allocation failed.
+  @retval SHELL_ABORTED           The abort message was received.
+  @retval SHELL_DEVICE_ERROR      UEFI Variable Services returned an error.
+  @retval SHELL_NOT_FOUND         the Name/Guid pair could not be found.
+**/
+SHELL_STATUS
+EFIAPI
+CascadeProcessVariables (
+  IN CONST CHAR16      *Name        OPTIONAL,
+  IN CONST EFI_GUID    *Guid        OPTIONAL,
+  IN DMP_STORE_TYPE    Type,
+  IN EFI_FILE_PROTOCOL *FileHandle  OPTIONAL,
+  IN CONST CHAR16      * CONST PrevName,
+  IN EFI_GUID          FoundVarGuid,
+  IN BOOLEAN           *FoundOne
+  )
+{
+  EFI_STATUS                Status;
+  CHAR16                    *FoundVarName;
+  UINT8                     *DataBuffer;
+  UINTN                     DataSize;
+  UINT32                    Atts;
+  SHELL_STATUS              ShellStatus;
+  UINTN                     NameSize;
+  CHAR16                    *RetString;
+  if (ShellGetExecutionBreakFlag()) {
+    return (SHELL_ABORTED);
+  }
+  NameSize      = 0;
+  FoundVarName  = NULL;
+  if (PrevName!=NULL) {
+    StrnCatGrow(&FoundVarName, &NameSize, PrevName, 0);
+  } else {
+    FoundVarName = AllocateZeroPool(sizeof(CHAR16));
+  }
+  Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
+  if (Status == EFI_BUFFER_TOO_SMALL) {
+    SHELL_FREE_NON_NULL(FoundVarName);
+    FoundVarName = AllocateZeroPool (NameSize);
+    if (FoundVarName != NULL) {
+      if (PrevName != NULL) {
+        StrnCpy(FoundVarName, PrevName, NameSize/sizeof(CHAR16)-1);
+      }
+      Status = gRT->GetNextVariableName (&NameSize, FoundVarName, &FoundVarGuid);
+    } else {
+      Status = EFI_OUT_OF_RESOURCES;
+    }
+  }
+  //
+  // No more is fine.
+  //
+  if (Status == EFI_NOT_FOUND) {
+    SHELL_FREE_NON_NULL(FoundVarName);
+    return (SHELL_SUCCESS);
+  } else if (EFI_ERROR(Status)) {
+    SHELL_FREE_NON_NULL(FoundVarName);
+    return (SHELL_DEVICE_ERROR);
+  }
+  //
+  // Recurse to the next iteration.  We know "our" variable's name.
+  //
+  ShellStatus = CascadeProcessVariables(Name, Guid, Type, FileHandle, FoundVarName, FoundVarGuid, FoundOne);
+  if (ShellGetExecutionBreakFlag() || (ShellStatus == SHELL_ABORTED)) {
+    SHELL_FREE_NON_NULL(FoundVarName);
+    return (SHELL_ABORTED);
+  }
+  //
+  // No matter what happened we process our own variable
+  // Only continue if Guid and VariableName are each either NULL or a match
+  //
+  if ( ( Name == NULL
+      || gUnicodeCollation->MetaiMatch(gUnicodeCollation, FoundVarName, (CHAR16*) Name) )
+     && ( Guid == NULL
+      || CompareGuid(&FoundVarGuid, Guid) )
+      ) {
+    DataSize      = 0;
+    DataBuffer    = NULL;
+    //
+    // do the print or delete
+    //
+    *FoundOne = TRUE;
+    Status = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      SHELL_FREE_NON_NULL (DataBuffer);
+      DataBuffer = AllocatePool (DataSize);
+      if (DataBuffer == NULL) {
+        Status = EFI_OUT_OF_RESOURCES;
+      } else {
+        Status = gRT->GetVariable (FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
+      }
+    }
+    if ((Type == DmpStoreDisplay) || (Type == DmpStoreSave)) {
+      //
+      // Last error check then print this variable out.
+      //
+      if (!EFI_ERROR(Status) && (DataBuffer != NULL) && (FoundVarName != NULL)) {
+        RetString = GetAttrType(Atts);
+        ShellPrintHiiEx(
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN(STR_DMPSTORE_HEADER_LINE),
+          gShellDebug1HiiHandle,
+          RetString,
+          &FoundVarGuid,
+          FoundVarName,
+          DataSize);
+        if (Type == DmpStoreDisplay) {
+          DumpHex(2, 0, DataSize, DataBuffer);
+        } else {
+          Status = AppendSingleVariableToFile (
+                     FileHandle,
+                     FoundVarName,
+                     &FoundVarGuid,
+                     Atts,
+                     (UINT32) DataSize,
+                     DataBuffer
+                     );
+        }
+        SHELL_FREE_NON_NULL(RetString);
+      }
+    } else if (Type == DmpStoreDelete) {
+      //
+      // We only need name to delete it...
+      //
+      ShellPrintHiiEx (
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN(STR_DMPSTORE_DELETE_LINE),
+        gShellDebug1HiiHandle,
+        &FoundVarGuid,
+        FoundVarName,
+        gRT->SetVariable (FoundVarName, &FoundVarGuid, Atts, 0, NULL)
+        );
+    }
+    SHELL_FREE_NON_NULL(DataBuffer);
+  }
+  SHELL_FREE_NON_NULL(FoundVarName);
+  if (Status == EFI_DEVICE_ERROR) {
+    ShellStatus = SHELL_DEVICE_ERROR;
+  } else if (Status == EFI_SECURITY_VIOLATION) {
+    ShellStatus = SHELL_SECURITY_VIOLATION;
+  } else if (EFI_ERROR(Status)) {
+    ShellStatus = SHELL_NOT_READY;
+  }
+  return (ShellStatus);
+}
+/**
+  Function to display or delete variables.  This will set up and call into the recursive function.
+  @param[in] Name        The variable name of the EFI variable (or NULL).
+  @param[in] Guid        The GUID of the variable set (or NULL).
+  @param[in] Type        The operation type.
+  @param[in] FileHandle  The file to save or load variables.
   @retval SHELL_SUCCESS           The operation was successful.
 …
 EFIAPI
 ProcessVariables (
+  IN CONST CHAR16   *VariableName OPTIONAL,
+  IN CONST EFI_GUID *Guid OPTIONAL,
+  IN BOOLEAN        Delete
+  IN CONST CHAR16      *Name      OPTIONAL,
+  IN CONST EFI_GUID    *Guid      OPTIONAL,
+  IN DMP_STORE_TYPE    Type,
+  IN SHELL_FILE_HANDLE FileHandle OPTIONAL
+  )
+{
-  EFI_STATUS                Status;
-  UINT64                    MaxStorSize;
-  UINT64                    RemStorSize;
-  UINT64                    MaxVarSize;
-  CHAR16                    *FoundVarName;
-  UINTN                     Size;
-  EFI_GUID                  FoundVarGuid;
-  UINT8                     *DataBuffer;
-  UINTN                     DataSize;
-  UINT32                    Atts;
   SHELL_STATUS              ShellStatus;
   BOOLEAN                   Found;
+  Status = gRT->QueryVariableInfo(EFI_VARIABLE_BOOTSERVICE_ACCESS|EFI_VARIABLE_RUNTIME_ACCESS|EFI_VARIABLE_NON_VOLATILE, &MaxStorSize, &RemStorSize, &MaxVarSize);
+  if (EFI_ERROR(Status)) {
+    return (SHELL_DEVICE_ERROR);
+  }
+  EFI_GUID                  FoundVarGuid;
   Found         = FALSE;
   ShellStatus   = SHELL_SUCCESS;
+  Size          = PcdGet16(PcdShellFileOperationSize);
+  FoundVarName  = AllocateZeroPool(Size);
+  if (FoundVarName == NULL) {
+    return (SHELL_OUT_OF_RESOURCES);
+  }
+  FoundVarName[0] = CHAR_NULL;
+  DataSize = (UINTN)MaxVarSize;
+  DataBuffer = AllocateZeroPool(DataSize);
+  if (DataBuffer == NULL) {
+    FreePool(FoundVarName);
+    return (SHELL_OUT_OF_RESOURCES);
+  }
+  for (;;){
+    if (ShellGetExecutionBreakFlag()) {
+      ShellStatus = SHELL_ABORTED;
+      break;
+    }
+    Size      = (UINTN)PcdGet16(PcdShellFileOperationSize);
+    DataSize  = (UINTN)MaxVarSize;
+    Status = gRT->GetNextVariableName(&Size, FoundVarName, &FoundVarGuid);
+    if (Status == EFI_NOT_FOUND) {
+      break;
+    }
+    ASSERT_EFI_ERROR(Status);
+    Status = gRT->GetVariable(FoundVarName, &FoundVarGuid, &Atts, &DataSize, DataBuffer);
+    ASSERT_EFI_ERROR(Status);
+    //
+    // Check if it matches
+    //
+    if (VariableName != NULL) {
+      if (!gUnicodeCollation->MetaiMatch(gUnicodeCollation, FoundVarName, (CHAR16*)VariableName)) {
+        continue;
+      }
+    }
+    if (Guid != NULL) {
+      if (!CompareGuid(&FoundVarGuid, Guid)) {
+        continue;
+      }
+    }
+    //
+    // do the print or delete
+    //
+    Found = TRUE;
+    if (!Delete) {
+      ShellPrintHiiEx(
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN(STR_DMPSTORE_HEADER_LINE),
+        gShellDebug1HiiHandle,
+        AttrType[Atts & 7],
+        &FoundVarGuid,
+        FoundVarName,
+        DataSize);
+      DumpHex(2, 0, DataSize, DataBuffer);
+    } else {
+      ShellPrintHiiEx(
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN(STR_DMPSTORE_DELETE_LINE),
+        gShellDebug1HiiHandle,
+        &FoundVarGuid,
+        FoundVarName);
+      ShellPrintHiiEx(
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN(STR_DMPSTORE_DELETE_DONE),
+        gShellDebug1HiiHandle,
+        gRT->SetVariable(FoundVarName, &FoundVarGuid, Atts, 0, NULL));
+    }
+  }
+  if (FoundVarName != NULL) {
+    FreePool(FoundVarName);
+  }
+  if (DataBuffer != NULL) {
+    FreePool(DataBuffer);
+  }
+  ZeroMem (&FoundVarGuid, sizeof(EFI_GUID));
+  if (Type == DmpStoreLoad) {
+    ShellStatus = LoadVariablesFromFile (FileHandle, Name, Guid, &Found);
+  } else {
+    ShellStatus = CascadeProcessVariables(Name, Guid, Type, FileHandle, NULL, FoundVarGuid, &Found);
+  }
   if (!Found) {
+    if (VariableName != NULL && Guid == NULL) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N), gShellDebug1HiiHandle, VariableName);
+    } else if (VariableName != NULL && Guid != NULL) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_GN), gShellDebug1HiiHandle, Guid, VariableName);
+    } else if (VariableName == NULL && Guid == NULL) {
+    if (ShellStatus == SHELL_OUT_OF_RESOURCES) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_OUT_MEM), gShellDebug1HiiHandle);
+      return (ShellStatus);
+    } else if (Name != NULL && Guid == NULL) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_N), gShellDebug1HiiHandle, Name);
+    } else if (Name != NULL && Guid != NULL) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_GN), gShellDebug1HiiHandle, Guid, Name);
+    } else if (Name == NULL && Guid == NULL) {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND), gShellDebug1HiiHandle);
     } else if (VariableName == NULL && Guid != NULL) {
+    } else if (Name == NULL && Guid != NULL) {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_NO_VAR_FOUND_G), gShellDebug1HiiHandle, Guid);
+    }
     return (SHELL_NOT_FOUND);
+  }
   return (SHELL_SUCCESS);
+  return (ShellStatus);
+}
 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
   {L"-d", TypeFlag},
   {L"-l", TypeFlag},
   {L"-s", TypeFlag},
+  {L"-l", TypeValue},
+  {L"-s", TypeValue},
   {L"-all", TypeFlag},
   {L"-guid", TypeValue},
 …
+  )
+{
+  EFI_STATUS    Status;
+  LIST_ENTRY    *Package;
+  CHAR16        *ProblemParam;
+  SHELL_STATUS  ShellStatus;
+  CONST CHAR16  *Temp;
+  EFI_GUID      *Guid;
+  EFI_GUID      GuidData;
+  CONST CHAR16  *VariableName;
+  EFI_STATUS        Status;
+  LIST_ENTRY        *Package;
+  CHAR16            *ProblemParam;
+  SHELL_STATUS      ShellStatus;
+  CONST CHAR16      *GuidStr;
+  CONST CHAR16      *File;
+  EFI_GUID          *Guid;
+  EFI_GUID          GuidData;
+  CONST CHAR16      *Name;
+  DMP_STORE_TYPE    Type;
+  SHELL_FILE_HANDLE FileHandle;
+  EFI_FILE_INFO     *FileInfo;
   ShellStatus   = SHELL_SUCCESS;
   Package       = NULL;
+  FileHandle    = NULL;
+  File          = NULL;
+  Type          = DmpStoreDisplay;
   Status = ShellCommandLineParse (ParamList, &Package, &ProblemParam, TRUE);
 …
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"-all", L"-guid");
       ShellStatus = SHELL_INVALID_PARAMETER;
+    } else if (ShellCommandLineGetFlag(Package, L"-s") && ShellCommandLineGetFlag(Package, L"-l")) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"-l", L"-s");
+      ShellStatus = SHELL_INVALID_PARAMETER;
     } else if ((ShellCommandLineGetFlag(Package, L"-s") || ShellCommandLineGetFlag(Package, L"-l")) && ShellCommandLineGetFlag(Package, L"-d")) {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_CONFLICT), gShellDebug1HiiHandle, L"-l or -s", L"-d");
       ShellStatus = SHELL_INVALID_PARAMETER;
     } else {
+      //
+      // Determine the GUID to search for based on -all and -guid parameters
+      //
       if (!ShellCommandLineGetFlag(Package, L"-all")) {
         Temp = ShellCommandLineGetValue(Package, L"-guid");
         if (Temp != NULL) {
           Status = ConvertStringToGuid(Temp, &GuidData);
+        GuidStr = ShellCommandLineGetValue(Package, L"-guid");
+        if (GuidStr != NULL) {
+          Status = ConvertStringToGuid(GuidStr, &GuidData);
           if (EFI_ERROR(Status)) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, GuidStr);
             ShellStatus = SHELL_INVALID_PARAMETER;
+          }
 …
           Guid = &gEfiGlobalVariableGuid;
+        }
-        VariableName = ShellCommandLineGetRawValue(Package, 1);
       } else {
+        VariableName  = NULL;
+        Guid          = NULL;
+        Guid  = NULL;
+      }
+      //
+      // Get the Name of the variable to find
+      //
+      Name = ShellCommandLineGetRawValue(Package, 1);
       if (ShellStatus == SHELL_SUCCESS) {
+        if (ShellCommandLineGetFlag(Package, L"-s") || ShellCommandLineGetFlag(Package, L"-l")) {
+          ///@todo fix this after Jordan makes lib...
+          ShellPrintEx(-1, -1, L"Not implemeneted yet.\r\n");
+          ShellStatus = SHELL_UNSUPPORTED;
+        } else {
+          ShellStatus = ProcessVariables (VariableName, Guid, ShellCommandLineGetFlag(Package, L"-d"));
+        if (ShellCommandLineGetFlag(Package, L"-s")) {
+          Type = DmpStoreSave;
+          File = ShellCommandLineGetValue(Package, L"-s");
+          if (File == NULL) {
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"-s");
+            ShellStatus = SHELL_INVALID_PARAMETER;
+          } else {
+            Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
+            if (!EFI_ERROR (Status)) {
+              //
+              // Delete existing file, but do not delete existing directory
+              //
+              FileInfo = ShellGetFileInfo (FileHandle);
+              if (FileInfo == NULL) {
+                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, File);
+                Status = EFI_DEVICE_ERROR;
+              } else {
+                if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
+                  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, File);
+                  Status = EFI_INVALID_PARAMETER;
+                } else {
+                  Status = ShellDeleteFile (&FileHandle);
+                  if (EFI_ERROR (Status)) {
+                    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_DELETE_FAIL), gShellDebug1HiiHandle, File);
+                  }
+                }
+                FreePool (FileInfo);
+              }
+            } else if (Status == EFI_NOT_FOUND) {
+              //
+              // Good when file doesn't exist
+              //
+              Status = EFI_SUCCESS;
+            } else {
+              //
+              // Otherwise it's bad.
+              //
+              ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, File);
+            }
+            if (!EFI_ERROR (Status)) {
+              Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_CREATE | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_READ, 0);
+              if (EFI_ERROR (Status)) {
+                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, File);
+              }
+            }
+            if (EFI_ERROR (Status)) {
+              ShellStatus = SHELL_INVALID_PARAMETER;
+            }
+          }
+        } else if (ShellCommandLineGetFlag(Package, L"-l")) {
+          Type = DmpStoreLoad;
+          File = ShellCommandLineGetValue(Package, L"-l");
+          if (File == NULL) {
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDebug1HiiHandle, L"-l");
+            ShellStatus = SHELL_INVALID_PARAMETER;
+          } else {
+            Status = ShellOpenFileByName (File, &FileHandle, EFI_FILE_MODE_READ, 0);
+            if (EFI_ERROR (Status)) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, File);
+              ShellStatus = SHELL_INVALID_PARAMETER;
+            } else {
+              FileInfo = ShellGetFileInfo (FileHandle);
+              if (FileInfo == NULL) {
+                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellDebug1HiiHandle, File);
+                ShellStatus = SHELL_DEVICE_ERROR;
+              } else {
+                if ((FileInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY) {
+                  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_IS_DIRECTORY), gShellDebug1HiiHandle, File);
+                  ShellStatus = SHELL_INVALID_PARAMETER;
+                }
+                FreePool (FileInfo);
+              }
+            }
+          }
+        } else if (ShellCommandLineGetFlag(Package, L"-d")) {
+          Type = DmpStoreDelete;
+        }
+      }
+      if (ShellStatus == SHELL_SUCCESS) {
+        if (Type == DmpStoreSave) {
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_SAVE), gShellDebug1HiiHandle, File);
+        } else if (Type == DmpStoreLoad) {
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DMPSTORE_LOAD), gShellDebug1HiiHandle, File);
+        }
+        ShellStatus = ProcessVariables (Name, Guid, Type, FileHandle);
+        if ((Type == DmpStoreLoad) || (Type == DmpStoreSave)) {
+          ShellCloseFile (&FileHandle);
+        }
+      }
+    }
+  }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/FileBuffer.c

-              r48674
+              r58459
   Implements filebuffer interface functions.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
       //
       Orig                  = MainEditor.ColorAttributes;
+      New.Colors.Foreground = Orig.Colors.Background;
+      New.Colors.Background = Orig.Colors.Foreground;
+      New.Data              = 0;
+      New.Colors.Foreground = Orig.Colors.Background & 0xF;
+      New.Colors.Background = Orig.Colors.Foreground & 0x7;
       //
 …
       // set the new mouse position
       //
       gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+      gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
       //
 …
   CHAR16  *Buffer;
   UINTN   Limit;
+  CHAR16  PrintLine[200];
+  CHAR16  *PrintLine;
+  CHAR16  *PrintLine2;
+  UINTN   BufLen;
   //
 …
+  }
+  StrnCpy (PrintLine, Buffer, MIN(MIN(Limit,MainEditor.ScreenSize.Column), 200));
+  BufLen = (MainEditor.ScreenSize.Column + 1) * sizeof (CHAR16);
+  PrintLine = AllocatePool (BufLen);
+  ASSERT (PrintLine != NULL);
+  StrnCpy (PrintLine, Buffer, MIN(Limit, MainEditor.ScreenSize.Column));
   for (; Limit < MainEditor.ScreenSize.Column; Limit++) {
     PrintLine[Limit] = L' ';
 …
   PrintLine[MainEditor.ScreenSize.Column] = CHAR_NULL;
+  PrintLine2 = AllocatePool (BufLen * 2);
+  ASSERT (PrintLine2 != NULL);
+  ShellCopySearchAndReplace(PrintLine, PrintLine2, BufLen * 2, L"%", L"^%", FALSE, FALSE);
   ShellPrintEx (
 …
     (INT32)Row - 1,
     L"%s",
     PrintLine
+    PrintLine2
     );
+  FreePool (PrintLine);
+  FreePool (PrintLine2);
   return EFI_SUCCESS;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Edit/MainTextEditor.c

-              r48674
+              r58459
   Implements editor interface functions.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   //        "Nothing to Cut".
   //
+  Line = NULL;
   Status = FileBufferCutLine (&Line);
   if (Status == EFI_NOT_FOUND) {
 …
   &FileBuffer,
+  {
+,
+    {0, 0}
   },
+  {
 …
   // below will call the five components' init function
   //
   Status = MainTitleBarInit (L"UEFI EDIT 2.0");
+  Status = MainTitleBarInit (L"UEFI EDIT");
   if (EFI_ERROR (Status)) {
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_EDIT_LIBEDITOR_TITLEBAR), gShellDebug1HiiHandle);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/EditInputBar.c

-              r48674
+              r58459
   Implements inputbar interface functions.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 typedef struct {
   UINT32  Foreground : 4;
   UINT32  Background : 4;
+  UINT32  Background : 3;
 } INPUT_BAR_COLOR_ATTRIBUTES;
 …
   EFI_STATUS              Status;
   BOOLEAN                 NoDisplay;
-  UINTN                   Limit;
-  UINTN                   mPromptLen;
   UINTN                   EventIndex;
   UINTN                   CursorRow;
 …
   CursorRow             = gST->ConOut->Mode->CursorRow;
   Orig.Data             = gST->ConOut->Mode->Attribute;
+  New.Colors.Foreground = Orig.Colors.Background;
+  New.Colors.Background = Orig.Colors.Foreground;
+  gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+  New.Data              = 0;
+  New.Colors.Foreground = Orig.Colors.Background & 0xF;
+  New.Colors.Background = Orig.Colors.Foreground & 0x7;
+  gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
   //
 …
   gST->ConOut->SetCursorPosition (gST->ConOut, 0, LastRow - 1);
   ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_EDIT_LIBINPUTBAR_MAININPUTBAR), gShellDebug1HiiHandle, mPrompt);
-  //
-  // that's the maximum input length that can be displayed on screen
-  //
-  mPromptLen = StrLen (mPrompt);
-  Limit     = LastColumn - mPromptLen;
   //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/EditStatusBar.c

-              r48674
+              r58459
   Implements statusbar interface functions.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 typedef struct {
   UINT32  Foreground : 4;
   UINT32  Background : 4;
+  UINT32  Background : 3;
 } STATUS_BAR_COLOR_ATTRIBUTES;
 …
   //
   Orig.Data             = gST->ConOut->Mode->Attribute;
+  New.Colors.Foreground = Orig.Colors.Background;
+  New.Colors.Background = Orig.Colors.Foreground;
+  New.Data              = 0;
+  New.Colors.Foreground = Orig.Colors.Background & 0xF;
+  New.Colors.Background = Orig.Colors.Foreground & 0x7;
   gST->ConOut->EnableCursor (gST->ConOut, FALSE);
   gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+  gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
   //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/EditTitleBar.c

-              r48674
+              r58459
   Implements titlebar interface functions.
+  Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   //
   Orig.Data             = gST->ConOut->Mode->Attribute;
+  New.Colors.Foreground = Orig.Colors.Background;
+  New.Colors.Background = Orig.Colors.Foreground;
+  gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+  New.Data              = 0;
+  New.Colors.Foreground = Orig.Colors.Background & 0xF;
+  New.Colors.Background = Orig.Colors.Foreground & 0x7;
+  gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
   //
 …
     case FileTypeUnicode:
       if (FileType == FileTypeAscii){
+        ShellPrintEx (-1,-1, L"     ASCII     ");
+      } else {
         ShellPrintEx (-1,-1, L"     UNICODE   ");
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/EfiDecompress.c

-              r48674
+              r58459
   Main file for EfiDecompress shell Debug1 function.
   Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
             ShellStatus = SHELL_NOT_FOUND;
+          }
-          Status = ShellOpenFileByName(OutFileName, &OutFileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
-          if (EFI_ERROR(Status)) {
-            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 2), Status);
-            ShellStatus = SHELL_NOT_FOUND;
+          }
+        }
 …
           Status = Decompress->GetInfo(Decompress, InBuffer, (UINT32)InSize, &OutSize, &ScratchSize);
+          ASSERT_EFI_ERROR(Status);
+          if (EFI_ERROR(Status) || OutSize == 0) {
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_EFI_DECOMPRESS_NOPE), gShellDebug1HiiHandle, InFileName);
+            ShellStatus = SHELL_NOT_FOUND;
+          } else {
+            Status = ShellOpenFileByName(OutFileName, &OutFileHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
+            if (EFI_ERROR(Status)) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_OPEN_FAIL), gShellDebug1HiiHandle, ShellCommandLineGetRawValue(Package, 2), Status);
+              ShellStatus = SHELL_NOT_FOUND;
+            } else {
+              OutBuffer = AllocateZeroPool(OutSize);
+              ScratchBuffer = AllocateZeroPool(ScratchSize);
+              ASSERT(OutBuffer != NULL);
+              ASSERT(ScratchBuffer != NULL);
+          OutBuffer = AllocateZeroPool(OutSize);
+          ScratchBuffer = AllocateZeroPool(ScratchSize);
+          ASSERT(OutBuffer != NULL);
+          ASSERT(ScratchBuffer != NULL);
+              Status = Decompress->Decompress(Decompress, InBuffer, (UINT32)InSize, OutBuffer, OutSize, ScratchBuffer, ScratchSize);
+              ASSERT_EFI_ERROR(Status);
+          Status = Decompress->Decompress(Decompress, InBuffer, (UINT32)InSize, OutBuffer, OutSize, ScratchBuffer, ScratchSize);
+          ASSERT_EFI_ERROR(Status);
+          if (EFI_ERROR(Status)) {
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_EFI_DECOMPRESS_FAIL), gShellDebug1HiiHandle, Status);
+            ShellStatus = SHELL_DEVICE_ERROR;
+          } else {
+            OutSizeTemp = OutSize;
+            Status = gEfiShellProtocol->WriteFile(OutFileHandle, &OutSizeTemp, OutBuffer);
+            OutSize = (UINT32)OutSizeTemp;
+            if (EFI_ERROR(Status)) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_WRITE_FAIL), gShellDebug1HiiHandle, OutFileName, Status);
+              ShellStatus = SHELL_DEVICE_ERROR;
+            }
+              if (EFI_ERROR(Status)) {
+                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_EFI_DECOMPRESS_FAIL), gShellDebug1HiiHandle, Status);
+                ShellStatus = SHELL_DEVICE_ERROR;
+              } else {
+                OutSizeTemp = OutSize;
+                Status = gEfiShellProtocol->WriteFile(OutFileHandle, &OutSizeTemp, OutBuffer);
+                OutSize = (UINT32)OutSizeTemp;
+                if (EFI_ERROR(Status)) {
+                  ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_FILE_WRITE_FAIL), gShellDebug1HiiHandle, OutFileName, Status);
+                  ShellStatus = SHELL_DEVICE_ERROR;
+                }
+              }
+            }
+          }
+        }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/BufferImage.c

-              r48674
+              r58459
   as well as the event handlers for editing the file
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
     if (BeNewColor) {
       gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+      gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
     } else {
       gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
+      gST->ConOut->SetAttribute (gST->ConOut, Orig.Data & 0x7F);
+    }
 …
+  }
   gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
+  gST->ConOut->SetAttribute (gST->ConOut, Orig.Data & 0x7F);
   while (Index < 0x08) {
     Pos = 10 + (Index * 3);
 …
     if (BeNewColor) {
       gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+      gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
     } else {
       gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
+      gST->ConOut->SetAttribute (gST->ConOut, Orig.Data & 0x7F);
+    }
 …
+  }
   gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
+  gST->ConOut->SetAttribute (gST->ConOut, Orig.Data & 0x7F);
   while (Index < 0x10) {
     Pos = 10 + (Index * 3) + 1;
 …
   // restore the original color
   //
   gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
+  gST->ConOut->SetAttribute (gST->ConOut, Orig.Data & 0x7F);
   //
 …
       //
       Orig                  = HMainEditor.ColorAttributes;
+      New.Colors.Foreground = Orig.Colors.Background;
+      New.Colors.Background = Orig.Colors.Foreground;
+      New.Data              = 0;
+      New.Colors.Foreground = Orig.Colors.Background & 0xF;
+      New.Colors.Background = Orig.Colors.Foreground & 0x7;
       //
 …
         gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
       } else {
         gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+        gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
+      }
       //
 …
             HBufferImage.MousePosition.Column
             )) {
         gST->ConOut->SetAttribute (gST->ConOut, New.Data);
+        gST->ConOut->SetAttribute (gST->ConOut, New.Data & 0x7F);
       } else {
         gST->ConOut->SetAttribute (gST->ConOut, Orig.Data);
 …
   UINTN                   EndRow;
   UINTN                   FStartRow;
-  UINTN                   FEndRow;
   UINTN                   Tmp;
   Orig                  = HMainEditor.ColorAttributes;
+  New.Data              = 0;
   New.Colors.Foreground = Orig.Colors.Background;
   New.Colors.Background = Orig.Colors.Foreground;
 …
       FStartRow = StartRow;
-      FEndRow   = EndRow;
       StartRow  = 2 + StartRow - HBufferImage.LowVisibleRow;
 …
+  )
+{
-  HEFI_EDITOR_LINE  *Line;
   UINTN             FRow;
   UINTN             FCol;
 …
   INTN              Retreat;
-  Line  = HBufferImage.CurrentLine;
   FRow  = HBufferImage.BufferPosition.Row;
   FCol  = HBufferImage.BufferPosition.Column;
 …
   Retreat = -Retreat;
-  //
-  // get correct line
-  //
-  Line = HMoveLine (Retreat);
   FRow -= Gap;
 …
+  )
+{
-  HEFI_EDITOR_LINE  *Line;
   UINTN             FRow;
   UINTN             FCol;
   BOOLEAN           HighBits;
-  Line = HBufferImage.CurrentLine;
   //
 …
   HEFI_EDITOR_LINE  *Line;
   LIST_ENTRY    *Link;
-  UINTN             StartRow;
   UINTN             OldFCol;
 …
   EFI_STATUS        Status;
-  //
-  // get the line that start position is at
-  //
-  StartRow  = Pos / 0x10;
   Size      = HBufferImageGetTotalSize ();
 …
   LIST_ENTRY    *Link;
-  UINTN             StartRow;
   UINTN             OldFCol;
 …
   UINTN             NewPos;
-  //
-  // get the line that start position is at
-  //
-  StartRow  = Pos / 0x10;
   Size      = HBufferImageGetTotalSize ();

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/DiskImage.c

-              r48674
+              r58459
   HEFI_EDITOR_LINE                *Line;
+  UINT64                          ByteOffset;
+  EDIT_FILE_TYPE                  BufferTypeBackup;
+  BufferTypeBackup        = HBufferImage.BufferType;
   HBufferImage.BufferType = FileTypeDiskBuffer;
 …
     return EFI_OUT_OF_RESOURCES;
+  }
-  ByteOffset = MultU64x32 (Offset, BlkIo->Media->BlockSize);
   //
 …
   UINTN                           Bytes;
-  UINT64                          ByteOffset;
-  EDIT_FILE_TYPE                  BufferTypeBackup;
   //
   // if not modified, directly return
 …
+  }
-  BufferTypeBackup        = HBufferImage.BufferType;
   HBufferImage.BufferType = FileTypeDiskBuffer;
 …
     return Status;
+  }
-  ByteOffset = MultU64x32 (Offset, BlkIo->Media->BlockSize);
   //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/HexEdit.c

-              r48674
+              r58459
   SHELL_STATUS            ShellStatus;
   LIST_ENTRY              *Package;
-  CONST CHAR16            *Cwd;
   CHAR16                  *NewName;
-  CHAR16                  *Spot;
   CONST CHAR16            *Name;
   UINTN                   Offset;
   UINTN                   Size;
-  UINT64                  LastOffset;
   EDIT_FILE_TYPE          WhatToDo;
 …
   ShellStatus = SHELL_SUCCESS;
   NewName         = NULL;
-  Cwd         = NULL;
   Buffer      = NULL;
   Name        = NULL;
-  Spot        = NULL;
   Offset      = 0;
   Size        = 0;
-  LastOffset  = 0;
   WhatToDo    = FileTypeNone;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/HexEditorTypes.h

r48674	r58459
61	61	typedef union {
62	62	HEFI_EDITOR_COLOR_ATTRIBUTES Colors;
63		UINT8 Data;
	63	UINTN Data;
64	64	} HEFI_EDITOR_COLOR_UNION;
65	65

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MainHexEditor.c

-              r48674
+              r58459
      - Main Interfaces
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   &HBufferImage,
+  {
+,
+    {0, 0}
   },
+  {
 …
         //
         return EFI_SUCCESS;
-        break;
       case L'c':
 …
+{
   UINTN             Index;
-  HEFI_EDITOR_LINE  *Line;
   LIST_ENTRY    *Link;
   UINT8             *Buffer;
 …
     Link = Link->ForwardLink;
+  }
-  Line    = CR (Link, HEFI_EDITOR_LINE, Link, EFI_EDITOR_LINE_LIST);
   Count   = HMainEditor.SelectEnd - HMainEditor.SelectStart + 1;
 …
   // below will call the five components' init function
   //
   Status = MainTitleBarInit (NULL);
+  Status = MainTitleBarInit (L"UEFI HEXEDIT");
   if (EFI_ERROR (Status)) {
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HEXEDIT_LIBEDITOR_MAINEDITOR_TITLE), gShellDebug1HiiHandle);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/HexEdit/MemImage.c

-              r48674
+              r58459
   HEFI_EDITOR_LINE                *Line;
-  EDIT_FILE_TYPE                  BufferTypeBackup;
-  BufferTypeBackup        = HBufferImage.BufferType;
   HBufferImage.BufferType = FileTypeMemBuffer;
 …
   VOID                            *Buffer;
-  EDIT_FILE_TYPE                  BufferTypeBackup;
   //
   // not modified, so directly return
 …
+  }
-  BufferTypeBackup        = HBufferImage.BufferType;
   HBufferImage.BufferType = FileTypeMemBuffer;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/MemMap.c

-              r48674
+              r58459
   Main file for Mode shell Debug1 function.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  This program and the acModeanying materials
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which acModeanies this distribution.  The full text of the license may be found at
 …
 **/
+//
+// Need full names for Standard-Format Output
+//
 STATIC CONST CHAR16 NameEfiReservedMemoryType[]      = L"Reserved";
 STATIC CONST CHAR16 NameEfiLoaderCode[]              = L"LoaderCode";
 STATIC CONST CHAR16 NameEfiLoaderData[]              = L"LoaderData";
 STATIC CONST CHAR16 NameEfiBootServicesCode[]        = L"BS_Code";
 STATIC CONST CHAR16 NameEfiBootServicesData[]        = L"BS_Data";
 STATIC CONST CHAR16 NameEfiRuntimeServicesCode[]     = L"RT_Code";
 STATIC CONST CHAR16 NameEfiRuntimeServicesData[]     = L"RT_Data";
+STATIC CONST CHAR16 NameEfiBootServicesCode[]        = L"BootServiceCode";
+STATIC CONST CHAR16 NameEfiBootServicesData[]        = L"BootServiceData";
+STATIC CONST CHAR16 NameEfiRuntimeServicesCode[]     = L"RuntimeCode";
+STATIC CONST CHAR16 NameEfiRuntimeServicesData[]     = L"RuntimeData";
 STATIC CONST CHAR16 NameEfiConventionalMemory[]      = L"Available";
+STATIC CONST CHAR16 NameEfiUnusableMemory[]          = L"Unusable";
+STATIC CONST CHAR16 NameEfiACPIReclaimMemory[]       = L"ACPIRec";
+STATIC CONST CHAR16 NameEfiACPIMemoryNVS[]           = L"ACPI_NVS";
+STATIC CONST CHAR16 NameEfiMemoryMappedIO[]          = L"MMIO";
+STATIC CONST CHAR16 NameEfiMemoryMappedIOPortSpace[] = L"MMIOPort";
+STATIC CONST CHAR16 NameEfiPersistentMemory[]        = L"Persistent";
+STATIC CONST CHAR16 NameEfiUnusableMemory[]          = L"UnusableMemory";
+STATIC CONST CHAR16 NameEfiACPIReclaimMemory[]       = L"ACPIReclaimMemory";
+STATIC CONST CHAR16 NameEfiACPIMemoryNVS[]           = L"ACPIMemoryNVS";
+STATIC CONST CHAR16 NameEfiMemoryMappedIO[]          = L"MemoryMappedIO";
+STATIC CONST CHAR16 NameEfiMemoryMappedIOPortSpace[] = L"MemoryMappedIOPortSpace";
 STATIC CONST CHAR16 NameEfiPalCode[]                 = L"PalCode";
+//
+// Need short names for some memory types
+//
+STATIC CONST CHAR16 NameEfiBootServicesCodeShort[]        = L"BS_Code";
+STATIC CONST CHAR16 NameEfiBootServicesDataShort[]        = L"BS_Data";
+STATIC CONST CHAR16 NameEfiRuntimeServicesCodeShort[]     = L"RT_Code";
+STATIC CONST CHAR16 NameEfiRuntimeServicesDataShort[]     = L"RT_Data";
+STATIC CONST CHAR16 NameEfiUnusableMemoryShort[]          = L"Unusable";
+STATIC CONST CHAR16 NameEfiACPIReclaimMemoryShort[]       = L"ACPI_Recl";
+STATIC CONST CHAR16 NameEfiACPIMemoryNVSShort[]           = L"ACPI_NVS";
+STATIC CONST CHAR16 NameEfiMemoryMappedIOShort[]          = L"MMIO";
+STATIC CONST CHAR16 NameEfiMemoryMappedIOPortSpaceShort[] = L"MMIO_Port";
 #include "UefiShellDebug1CommandsLib.h"
 …
   UINT64              AcpiNvsPagesSize;
   UINT64              MmioSpacePagesSize;
+  UINT64              MmioPortPages;
+  UINT64              MmioPortPagesSize;
+  UINT64              UnusableMemoryPages;
+  UINT64              UnusableMemoryPagesSize;
+  UINT64              PalCodePages;
+  UINT64              PalCodePagesSize;
   BOOLEAN             Sfo;
 …
   RTCodePages         = 0;
   AvailPages          = 0;
+  MmioPortPages       = 0;
+  UnusableMemoryPages = 0;
+  PalCodePages        = 0;
   Size                = 0;
   Buffer              = NULL;
 …
       } else {
         ASSERT(Version == EFI_MEMORY_DESCRIPTOR_VERSION);
         Sfo = ShellCommandLineGetFlag(Package, L"-sfo");
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_HEAD), gShellDebug1HiiHandle);
+        if (!Sfo) {
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_HEAD), gShellDebug1HiiHandle);
+        } else {
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellDebug1HiiHandle, L"memmap");
+        }
         for (Walker = (UINT8*)Buffer; Walker < (((UINT8*)Buffer)+Size) && Walker != NULL; Walker += ItemSize){
           switch (((EFI_MEMORY_DESCRIPTOR*)Walker)->Type) {
-            // replaced ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages) with 0000
             case  EfiReservedMemoryType:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiReservedMemoryType, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               ReservedPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
-              TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiLoaderCode:
 …
               break;
             case EfiBootServicesCode:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiBootServicesCode, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiBootServicesCodeShort:NameEfiBootServicesCode, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               BSCodePages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiBootServicesData:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiBootServicesData, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiBootServicesDataShort:NameEfiBootServicesData, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               BSDataPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiRuntimeServicesCode:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiRuntimeServicesCode, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiRuntimeServicesCodeShort:NameEfiRuntimeServicesCode, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               RTCodePages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiRuntimeServicesData:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiRuntimeServicesData, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiRuntimeServicesDataShort:NameEfiRuntimeServicesData, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               RTDataPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
 …
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
+            case EfiPersistentMemory:
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiPersistentMemory, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              AvailPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              break;
             case EfiUnusableMemory:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiUnusableMemory, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiUnusableMemoryShort:NameEfiUnusableMemory, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              UnusableMemoryPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiACPIReclaimMemory:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiACPIReclaimMemory, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiACPIReclaimMemoryShort:NameEfiACPIReclaimMemory, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               AcpiReclaimPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiACPIMemoryNVS:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiACPIMemoryNVS, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiACPIMemoryNVSShort:NameEfiACPIMemoryNVS, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               AcpiNvsPages    += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiMemoryMappedIO:
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiMemoryMappedIO, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiMemoryMappedIOShort:NameEfiMemoryMappedIO, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               MmioSpacePages  += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiMemoryMappedIOPortSpace:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiMemoryMappedIOPortSpace, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, !Sfo?NameEfiMemoryMappedIOPortSpaceShort:NameEfiMemoryMappedIOPortSpace, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
+              MmioPortPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             case EfiPalCode:
               ShellPrintHiiEx(-1, -1, NULL, (EFI_STRING_ID)(!Sfo?STRING_TOKEN (STR_MEMMAP_LIST_ITEM):STRING_TOKEN (STR_MEMMAP_LIST_ITEM_SFO)), gShellDebug1HiiHandle, NameEfiPalCode, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart, ((EFI_MEMORY_DESCRIPTOR*)Walker)->PhysicalStart+MultU64x64(SIZE_4KB,((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages)-1, ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages, ((EFI_MEMORY_DESCRIPTOR*)Walker)->Attribute);
               TotalPages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
+              PalCodePages += ((EFI_MEMORY_DESCRIPTOR*)Walker)->NumberOfPages;
               break;
             default:
 …
         // print the summary
         //
+        ReservedPagesSize               = MultU64x64(SIZE_4KB,ReservedPages);
+        LoadCodePagesSize               = MultU64x64(SIZE_4KB,LoadCodePages);
+        LoadDataPagesSize               = MultU64x64(SIZE_4KB,LoadDataPages);
+        BSCodePagesSize           = MultU64x64(SIZE_4KB,BSCodePages);
+        BSDataPagesSize           = MultU64x64(SIZE_4KB,BSDataPages);
+        RTDataPagesSize           = MultU64x64(SIZE_4KB,RTDataPages);
+        RTCodePagesSize           = MultU64x64(SIZE_4KB,RTCodePages);
+        AvailPagesSize            = MultU64x64(SIZE_4KB,AvailPages);
+        TotalPagesSize            = MultU64x64(SIZE_4KB,TotalPages);
+        AcpiReclaimPagesSize     = MultU64x64(SIZE_4KB,AcpiReclaimPages);
+        AcpiNvsPagesSize         = MultU64x64(SIZE_4KB,AcpiNvsPages);
+        MmioSpacePagesSize       = MultU64x64(SIZE_4KB,MmioSpacePages);
+        ReservedPagesSize       = MultU64x64(SIZE_4KB,ReservedPages);
+        LoadCodePagesSize       = MultU64x64(SIZE_4KB,LoadCodePages);
+        LoadDataPagesSize       = MultU64x64(SIZE_4KB,LoadDataPages);
+        BSCodePagesSize         = MultU64x64(SIZE_4KB,BSCodePages);
+        BSDataPagesSize         = MultU64x64(SIZE_4KB,BSDataPages);
+        RTDataPagesSize         = MultU64x64(SIZE_4KB,RTDataPages);
+        RTCodePagesSize         = MultU64x64(SIZE_4KB,RTCodePages);
+        AvailPagesSize          = MultU64x64(SIZE_4KB,AvailPages);
+        TotalPagesSize          = MultU64x64(SIZE_4KB,TotalPages);
+        AcpiReclaimPagesSize    = MultU64x64(SIZE_4KB,AcpiReclaimPages);
+        AcpiNvsPagesSize        = MultU64x64(SIZE_4KB,AcpiNvsPages);
+        MmioSpacePagesSize      = MultU64x64(SIZE_4KB,MmioSpacePages);
+        MmioPortPagesSize       = MultU64x64(SIZE_4KB,MmioPortPages);
+        PalCodePagesSize        = MultU64x64(SIZE_4KB,PalCodePages);
+        UnusableMemoryPagesSize = MultU64x64(SIZE_4KB,UnusableMemoryPages);
         if (!Sfo) {
           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_SUMM), gShellDebug1HiiHandle,
 …
             AcpiNvsPages, AcpiNvsPagesSize,
             MmioSpacePages, MmioSpacePagesSize,
+            MmioPortPages, MmioPortPagesSize,
+            PalCodePages, PalCodePagesSize,
             AvailPages, AvailPagesSize,
             DivU64x32(MultU64x64(SIZE_4KB,TotalPages), SIZE_1MB), TotalPagesSize
 …
           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MEMMAP_LIST_SUMM_SFO), gShellDebug1HiiHandle,
             TotalPagesSize,
             MultU64x64(SIZE_4KB,ReservedPages),
+            ReservedPagesSize,
             BSCodePagesSize,
             BSDataPagesSize,
 …
             LoadCodePagesSize,
             LoadDataPagesSize,
+            AvailPages, AvailPagesSize
+            AvailPagesSize,
+            MmioSpacePagesSize,
+            MmioPortPagesSize,
+            UnusableMemoryPagesSize,
+            AcpiReclaimPagesSize,
+            AcpiNvsPagesSize,
+            PalCodePagesSize
            );
+        }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Mm.c

-              r48674
+              r58459
   Main file for Mm shell Debug1 function.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   UINTN                           Index;
   UINTN                           Size;
-  CHAR16                          *AddressStr;
 //  CHAR16                          *ValueStr;
   BOOLEAN                         Complete;
 …
   CONST CHAR16                    *Temp;
+  Value         = 0;
   Address       = 0;
   PciEAddress   = 0;
 …
   Size        = 1;
   AccessType  = EfiMemory;
-  AddressStr  = NULL;
 //  ValueStr    = NULL;
   Interactive = TRUE;
 …
+    }
+    if (ShellCommandLineGetFlag (Package, L"-n")) {
+    //
+    // Non interactive for a script file or for the specific parameter
+    //
+    if (gEfiShellProtocol->BatchIsActive() || ShellCommandLineGetFlag (Package, L"-n")) {
       Interactive = FALSE;
+    }
 …
     Temp = ShellCommandLineGetRawValue(Package, 2);
     if (Temp != NULL) {
+      //
+      // Per spec if value is specified, then -n is assumed.
+      //
+      Interactive = FALSE;
       if (!ShellIsHexOrDecimalNumber(Temp, TRUE, FALSE) || EFI_ERROR(ShellConvertStringToUint64(Temp, &Value, TRUE, FALSE))) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
 …
     //
     if (!Interactive) {
+      Buffer = 0;
+      if (AccessType == EFIMemoryMappedIo) {
+        if (!gEfiShellProtocol->BatchIsActive()) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MMIO), gShellDebug1HiiHandle);
+        }
+        IoDev->Mem.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiIo) {
+        if (!gEfiShellProtocol->BatchIsActive()) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_IO), gShellDebug1HiiHandle);
+        }
+        IoDev->Io.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiPciConfig) {
+        if (!gEfiShellProtocol->BatchIsActive()) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCI), gShellDebug1HiiHandle);
+        }
+        IoDev->Pci.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiPciEConfig) {
+        if (!gEfiShellProtocol->BatchIsActive()) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCIE), gShellDebug1HiiHandle);
+        }
+        IoDev->Pci.Read (IoDev, Width, PciEAddress, 1, &Buffer);
+      } else {
+        if (!gEfiShellProtocol->BatchIsActive()) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MEM), gShellDebug1HiiHandle);
+        }
+        ReadMem (Width, Address, 1, &Buffer);
+      }
+      if (!gEfiShellProtocol->BatchIsActive()) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS), gShellDebug1HiiHandle, Address);
+      }
+      if (Size == 1) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, (UINTN)Buffer);
+      } else if (Size == 2) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, (UINTN)Buffer);
+      } else if (Size == 4) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, (UINTN)Buffer);
+      } else if (Size == 8) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF16), gShellDebug1HiiHandle, Buffer);
+      }
+      ShellPrintEx(-1, -1, L"\r\n");
+      ASSERT(ShellStatus == SHELL_SUCCESS);
+      goto Done;
+    }
+    //
+    // interactive mode
+    //
+    Complete = FALSE;
+    do {
+      if (AccessType == EfiIo && Address + Size > 0x10000) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS_RANGE2), gShellDebug1HiiHandle);
+        break;
+      }
       Buffer = 0;
       if (AccessType == EFIMemoryMappedIo) {
 …
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS), gShellDebug1HiiHandle, Address);
       if (Size == 1) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, Buffer);
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, (UINTN)Buffer);
       } else if (Size == 2) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, Buffer);
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, (UINTN)Buffer);
       } else if (Size == 4) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, Buffer);
+      } else if (Size == 8) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF16), gShellDebug1HiiHandle, Buffer);
+      }
+      ShellPrintEx(-1, -1, L"\r\n");
+      ASSERT(ShellStatus == SHELL_SUCCESS);
+      goto Done;
+    }
+    //
+    // interactive mode
+    //
+    Complete = FALSE;
+    do {
+      if (AccessType == EfiIo && Address + Size > 0x10000) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS_RANGE2), gShellDebug1HiiHandle);
+        break;
+      }
+      Buffer = 0;
+      if (AccessType == EFIMemoryMappedIo) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MMIO), gShellDebug1HiiHandle);
+        IoDev->Mem.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiIo) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_IO), gShellDebug1HiiHandle);
+        IoDev->Io.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiPciConfig) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCI), gShellDebug1HiiHandle);
+        IoDev->Pci.Read (IoDev, Width, Address, 1, &Buffer);
+      } else if (AccessType == EfiPciEConfig) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_PCIE), gShellDebug1HiiHandle);
+        IoDev->Pci.Read (IoDev, Width, PciEAddress, 1, &Buffer);
+      } else {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_MEM), gShellDebug1HiiHandle);
+        ReadMem (Width, Address, 1, &Buffer);
+      }
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_ADDRESS), gShellDebug1HiiHandle, Address);
+      if (Size == 1) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF2), gShellDebug1HiiHandle, Buffer);
+      } else if (Size == 2) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF4), gShellDebug1HiiHandle, Buffer);
+      } else if (Size == 4) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, Buffer);
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF8), gShellDebug1HiiHandle, (UINTN)Buffer);
       } else if (Size == 8) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MM_BUF16), gShellDebug1HiiHandle, Buffer);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Mode.c

-              r48674
+              r58459
   Main file for Mode shell Debug1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
   This program and the acModeanying materials
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
+  This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
   which acModeanies this distribution.  The full text of the license may be found at

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Pci.c

-              r48674
+              r58459
   Main file for Pci shell Debug1 function.
+  Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2005 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "Pci.h"
-#define PCI_CLASS_STRING_LIMIT  54
 //
 // Printable strings for Pci class code
 …
 PCI_CLASS_ENTRY PCISubClass_10[];
 PCI_CLASS_ENTRY PCISubClass_11[];
+PCI_CLASS_ENTRY PCISubClass_12[];
+PCI_CLASS_ENTRY PCISubClass_13[];
+PCI_CLASS_ENTRY PCIPIFClass_0100[];
 PCI_CLASS_ENTRY PCIPIFClass_0101[];
+PCI_CLASS_ENTRY PCIPIFClass_0105[];
+PCI_CLASS_ENTRY PCIPIFClass_0106[];
+PCI_CLASS_ENTRY PCIPIFClass_0107[];
+PCI_CLASS_ENTRY PCIPIFClass_0108[];
+PCI_CLASS_ENTRY PCIPIFClass_0109[];
 PCI_CLASS_ENTRY PCIPIFClass_0300[];
 PCI_CLASS_ENTRY PCIPIFClass_0604[];
+PCI_CLASS_ENTRY PCIPIFClass_0609[];
+PCI_CLASS_ENTRY PCIPIFClass_060b[];
 PCI_CLASS_ENTRY PCIPIFClass_0700[];
 PCI_CLASS_ENTRY PCIPIFClass_0701[];
 …
 PCI_CLASS_ENTRY PCIPIFClass_0c00[];
 PCI_CLASS_ENTRY PCIPIFClass_0c03[];
+PCI_CLASS_ENTRY PCIPIFClass_0c07[];
+PCI_CLASS_ENTRY PCIPIFClass_0d01[];
 PCI_CLASS_ENTRY PCIPIFClass_0e00[];
 …
   },
+  {
+x12,
+    L"Processing Accelerators",
+    PCISubClass_12
+  },
+  {
+x13,
+    L"Non-Essential Instrumentation",
+    PCISubClass_13
+  },
+  {
 xff,
     L"Device does not fit in any defined classes",
 …
+  {
 x00,
     L"SCSI controller",
     PCIBlankEntry
+    L"SCSI",
+    PCIPIFClass_0100
   },
+  {
 …
   },
+  {
+x05,
+    L"ATA controller with ADMA interface",
+    PCIPIFClass_0105
+  },
+  {
+x06,
+    L"Serial ATA controller",
+    PCIPIFClass_0106
+  },
+  {
+x07,
+    L"Serial Attached SCSI (SAS) controller ",
+    PCIPIFClass_0107
+  },
+  {
+x08,
+    L"Non-volatile memory subsystem",
+    PCIPIFClass_0108
+  },
+  {
+x09,
+    L"Universal Flash Storage (UFS) controller ",
+    PCIPIFClass_0109
+  },
+  {
 x80,
     L"Other mass storage controller",
 …
   },
+  {
+x05,
+    L"WorldFip controller",
+    PCIBlankEntry
+  },
+  {
+x06,
+    L"PICMG 2.14 Multi Computing",
+    PCIBlankEntry
+  },
+  {
+x07,
+    L"InfiniBand controller",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other network controller",
 …
 x02,
     L"Computer Telephony device",
+    PCIBlankEntry
+  },
+  {
+x03,
+    L"Mixed mode device",
     PCIBlankEntry
   },
 …
   },
+  {
+x09,
+    L"Semi-transparent PCI-to-PCI bridge",
+    PCIPIFClass_0609
+  },
+  {
+x0A,
+    L"InfiniBand-to-PCI host bridge",
+    PCIBlankEntry
+  },
+  {
+x0B,
+    L"Advanced Switching to PCI host bridge",
+    PCIPIFClass_060b
+  },
+  {
 x80,
     L"Other bridge type",
 …
   },
+  {
+x04,
+    L"GPIB (IEEE 488.1/2) controller",
+    PCIBlankEntry
+  },
+  {
+x05,
+    L"Smart Card",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other communication device",
 …
   },
+  {
+x05,
+    L"SD Host controller",
+    PCIBlankEntry
+  },
+  {
+x06,
+    L"IOMMU",
+    PCIBlankEntry
+  },
+  {
+x07,
+    L"Root Complex Event Collector",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other system peripheral",
 …
+  {
 x00,
     L"Firewire(IEEE 1394)",
     PCIPIFClass_0c03
+    L"IEEE 1394",
+    PCIPIFClass_0c00
   },
+  {
 …
 x03,
     L"USB",
     PCIPIFClass_0c00
+    PCIPIFClass_0c03
   },
+  {
 …
   },
+  {
+x06,
+    L"InfiniBand",
+    PCIBlankEntry
+  },
+  {
+x07,
+    L"IPMI",
+    PCIPIFClass_0c07
+  },
+  {
+x08,
+    L"SERCOS Interface Standard (IEC 61491)",
+    PCIBlankEntry
+  },
+  {
+x09,
+    L"CANbus",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other bus type",
 …
+  {
 x01,
     L"Consumer IR controller",
     PCIBlankEntry
+    L"",
+    PCIPIFClass_0d01
   },
+  {
 …
   },
+  {
+x11,
+    L"Bluetooth",
+    PCIBlankEntry
+  },
+  {
+x12,
+    L"Broadband",
+    PCIBlankEntry
+  },
+  {
+x20,
+    L"Ethernet (802.11a - 5 GHz)",
+    PCIBlankEntry
+  },
+  {
+x21,
+    L"Ethernet (802.11b - 2.4 GHz)",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other type of wireless controller",
 …
 PCI_CLASS_ENTRY PCISubClass_0f[] = {
+  {
 x00,
+x01,
     L"TV",
     PCIBlankEntry
   },
+  {
 x01,
+x02,
     L"Audio",
     PCIBlankEntry
   },
+  {
 x02,
+x03,
     L"Voice",
     PCIBlankEntry
   },
+  {
 x03,
+x04,
     L"Data",
+    PCIBlankEntry
+  },
+  {
+x80,
+    L"Other satellite communication controller",
     PCIBlankEntry
   },
 …
   },
+  {
+x01,
+    L"Performance Counters",
+    PCIBlankEntry
+  },
+  {
+x10,
+    L"Communications synchronization plus time and frequency test/measurement ",
+    PCIBlankEntry
+  },
+  {
+x20,
+    L"Management card",
+    PCIBlankEntry
+  },
+  {
 x80,
     L"Other DAQ & SP controllers",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCISubClass_12[] = {
+  {
+x00,
+    L"Processing Accelerator",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCISubClass_13[] = {
+  {
+x00,
+    L"Non-Essential Instrumentation Function",
     PCIBlankEntry
   },
 …
 // Programming Interface entries
 //
+PCI_CLASS_ENTRY PCIPIFClass_0100[] = {
+  {
+x00,
+    L"SCSI controller",
+    PCIBlankEntry
+  },
+  {
+x11,
+    L"SCSI storage device SOP using PQI",
+    PCIBlankEntry
+  },
+  {
+x12,
+    L"SCSI controller SOP using PQI",
+    PCIBlankEntry
+  },
+  {
+x13,
+    L"SCSI storage device and controller SOP using PQI",
+    PCIBlankEntry
+  },
+  {
+x21,
+    L"SCSI storage device SOP using NVMe",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
 PCI_CLASS_ENTRY PCIPIFClass_0101[] = {
+  {
 …
 };
+PCI_CLASS_ENTRY PCIPIFClass_0105[] = {
+  {
+x20,
+    L"Single stepping",
+    PCIBlankEntry
+  },
+  {
+x30,
+    L"Continuous operation",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0106[] = {
+  {
+x00,
+    L"",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"AHCI",
+    PCIBlankEntry
+  },
+  {
+x02,
+    L"Serial Storage Bus",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0107[] = {
+  {
+x00,
+    L"",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"Obsolete",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0108[] = {
+  {
+x00,
+    L"",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"NVMHCI",
+    PCIBlankEntry
+  },
+  {
+x02,
+    L"NVM Express",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0109[] = {
+  {
+x00,
+    L"",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"UFSHCI",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
 PCI_CLASS_ENTRY PCIPIFClass_0300[] = {
+  {
 …
 };
+PCI_CLASS_ENTRY PCIPIFClass_0609[] = {
+  {
+x40,
+    L"Primary PCI bus side facing the system host processor",
+    PCIBlankEntry
+  },
+  {
+x80,
+    L"Secondary PCI bus side facing the system host processor",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_060b[] = {
+  {
+x00,
+    L"Custom",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"ASI-SIG Defined Portal",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
 PCI_CLASS_ENTRY PCIPIFClass_0700[] = {
+  {
 …
+  {
 x00,
     L"Universal Host Controller spec",
+    L"",
     PCIBlankEntry
   },
+  {
 x10,
+    L"Open Host Controller spec",
+    L"Using 1394 OpenHCI spec",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0c03[] = {
+  {
+x00,
+    L"UHCI",
+    PCIBlankEntry
+  },
+  {
+x10,
+    L"OHCI",
+    PCIBlankEntry
+  },
+  {
+x20,
+    L"EHCI",
+    PCIBlankEntry
+  },
+  {
+x30,
+    L"xHCI",
     PCIBlankEntry
   },
 …
 };
+PCI_CLASS_ENTRY PCIPIFClass_0c03[] = {
+  {
+x00,
+    L"",
+PCI_CLASS_ENTRY PCIPIFClass_0c07[] = {
+  {
+x00,
+    L"SMIC",
+    PCIBlankEntry
+  },
+  {
+x01,
+    L"Keyboard Controller Style",
+    PCIBlankEntry
+  },
+  {
+x02,
+    L"Block Transfer",
+    PCIBlankEntry
+  },
+  {
+x00,
+    NULL,
+    /* null string ends the list */NULL
+  }
+};
+PCI_CLASS_ENTRY PCIPIFClass_0d01[] = {
+  {
+x00,
+    L"Consumer IR controller",
     PCIBlankEntry
   },
+  {
 x10,
     L"Using 1394 OpenHCI spec",
+    L"UWB Radio controller",
     PCIBlankEntry
   },
 …
   @param[in] ClassCodePtr   Points to the memory which stores register Class Code in PCI
                  configuation space.
+                            configuration space.
   @param[in] IncludePIF     If the printed string should include the programming I/F part
 **/
 …
   UINT32            ClassCode;
   PCI_CLASS_STRINGS ClassStrings;
-  CHAR16            OutputString[PCI_CLASS_STRING_LIMIT + 1];
   ClassCode = 0;
   ClassCode |= ClassCodePtr[0];
   ClassCode |= (ClassCodePtr[1] << 8);
   ClassCode |= (ClassCodePtr[2] << 16);
+  ClassCode |= (UINT32)ClassCodePtr[0];
+  ClassCode |= (UINT32)(ClassCodePtr[1] << 8);
+  ClassCode |= (UINT32)(ClassCodePtr[2] << 16);
   //
 …
   if (IncludePIF) {
     //
     // Only print base class and sub class name
+    // Print base class, sub class, and programming inferface name
     //
     ShellPrintEx(-1,-1, L"%s - %s - %s",
+    ShellPrintEx (-1, -1, L"%s - %s - %s",
       ClassStrings.BaseClass,
       ClassStrings.SubClass,
 …
   } else {
     //
     // Print base class, sub class, and programming inferface name
+    // Only print base class and sub class name
     //
+    UnicodeSPrint (
+      OutputString,
+      PCI_CLASS_STRING_LIMIT * sizeof (CHAR16),
+      L"%s - %s",
+    ShellPrintEx (-1, -1, L"%s - %s",
       ClassStrings.BaseClass,
       ClassStrings.SubClass
+     );
+    OutputString[PCI_CLASS_STRING_LIMIT] = 0;
+    ShellPrintEx(-1,-1, L"%s", OutputString);
+    );
+  }
+}
 …
   @param[in] Address         Address used to access configuration space of this PCI device.
   @param[in] IoDev           Handle used to access configuration space of PCI device.
+  @param[in] EnhancedDump    The print format for the dump data.
   @retval EFI_SUCCESS     The command completed successfully.
 …
   IN PCI_CONFIG_SPACE                       *ConfigSpace,
   IN UINT64                                 Address,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL        *IoDev
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL        *IoDev,
+  IN CONST UINT16                           EnhancedDump
   );
 …
   Print each capability structure.
+  @param[in] IoDev      The pointer to the deivce.
+  @param[in] Address    The address to start at.
+  @param[in] CapPtr     The offset from the address.
+  @retval EFI_SUCCESS     The operation was successful.
+  @param[in] IoDev            The pointer to the deivce.
+  @param[in] Address          The address to start at.
+  @param[in] CapPtr           The offset from the address.
+  @param[in] EnhancedDump     The print format for the dump data.
+  @retval EFI_SUCCESS         The operation was successful.
 **/
 EFI_STATUS
 …
   IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL         *IoDev,
   IN UINT64                                   Address,
+  IN  UINT8                                   CapPtr
+  IN  UINT8                                   CapPtr,
+  IN CONST UINT16                            EnhancedDump
   );
 …
   Display Pcie device structure.
+  @param[in] IoDev          The pointer to the root pci protocol.
+  @param[in] Address        The Address to start at.
+  @param[in] CapabilityPtr  The offset from the address to start.
+  @param[in] IoDev            The pointer to the root pci protocol.
+  @param[in] Address          The Address to start at.
+  @param[in] CapabilityPtr    The offset from the address to start.
+  @param[in] EnhancedDump     The print format for the dump data.
+  @retval EFI_SUCCESS           The command completed successfully.
+  @retval @retval EFI_SUCCESS   Pci express extend space IO is not suppoted.
 **/
 EFI_STATUS
 …
   IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL         *IoDev,
   IN  UINT64                                  Address,
+  IN  UINT8                                   CapabilityPtr
+  IN  UINT8                                   CapabilityPtr,
+  IN CONST UINT16                            EnhancedDump
   );
 …
 EFI_STATUS
 ExplainPcieCapReg (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieDeviceCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieDeviceControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieDeviceStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieLinkCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieLinkControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieLinkStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieSlotCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieSlotControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieSlotStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieRootControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieRootCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 …
 EFI_STATUS
 ExplainPcieRootStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
   );
 typedef EFI_STATUS (*PCIE_EXPLAIN_FUNCTION) (IN PCIE_CAP_STURCTURE *PciExpressCap);
+typedef EFI_STATUS (*PCIE_EXPLAIN_FUNCTION) (IN PCIE_CAP_STRUCTURE *PciExpressCap);
 typedef enum {
 …
   CHAR16                            *ProblemParam;
   SHELL_STATUS                      ShellStatus;
-  UINTN                             Size;
   CONST CHAR16                      *Temp;
+  UINT64                            RetVal;
+  UINT16                            EnhancedDump;
   ShellStatus         = SHELL_SUCCESS;
   Status              = EFI_SUCCESS;
   Address             = 0;
-  Size                = 0;
   IoDev               = NULL;
   HandleBuf           = NULL;
 …
     Temp = ShellCommandLineGetValue(Package, L"-s");
     if (Temp != NULL) {
+      Segment = (UINT16) ShellStrToUintn (Temp);
+      //
+      // Input converted to hexadecimal number.
+      //
+      if (!EFI_ERROR (ShellConvertStringToUint64 (Temp, &RetVal, TRUE, TRUE))) {
+        Segment = (UINT16) RetVal;
+      } else {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV_HEX), gShellDebug1HiiHandle);
+        ShellStatus = SHELL_INVALID_PARAMETER;
+        goto Done;
+      }
+    }
 …
     Temp = ShellCommandLineGetRawValue(Package, 1);
     if (Temp != NULL) {
+      Bus = (UINT16)ShellStrToUintn(Temp);
+      //
+      // Input converted to hexadecimal number.
+      //
+      if (!EFI_ERROR (ShellConvertStringToUint64 (Temp, &RetVal, TRUE, TRUE))) {
+        Bus = (UINT16) RetVal;
+      } else {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV_HEX), gShellDebug1HiiHandle);
+        ShellStatus = SHELL_INVALID_PARAMETER;
+        goto Done;
+      }
       if (Bus > MAX_BUS_NUMBER) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
 …
     Temp = ShellCommandLineGetRawValue(Package, 2);
     if (Temp != NULL) {
+      Device = (UINT16) ShellStrToUintn(Temp);
+      //
+      // Input converted to hexadecimal number.
+      //
+      if (!EFI_ERROR (ShellConvertStringToUint64 (Temp, &RetVal, TRUE, TRUE))) {
+        Device = (UINT16) RetVal;
+      } else {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV_HEX), gShellDebug1HiiHandle);
+        ShellStatus = SHELL_INVALID_PARAMETER;
+        goto Done;
+      }
       if (Device > MAX_DEVICE_NUMBER){
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
 …
     Temp = ShellCommandLineGetRawValue(Package, 3);
     if (Temp != NULL) {
+      Func = (UINT16) ShellStrToUintn(Temp);
+      //
+      // Input converted to hexadecimal number.
+      //
+      if (!EFI_ERROR (ShellConvertStringToUint64 (Temp, &RetVal, TRUE, TRUE))) {
+        Func = (UINT16) RetVal;
+      } else {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV_HEX), gShellDebug1HiiHandle);
+        ShellStatus = SHELL_INVALID_PARAMETER;
+        goto Done;
+      }
       if (Func > MAX_FUNCTION_NUMBER){
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellDebug1HiiHandle, Temp);
 …
       ShellPrintHiiEx(
         -1, -1, NULL, STRING_TOKEN (STR_PCI_NO_FIND), gShellDebug1HiiHandle,
-        gShellDebug1HiiHandle,
         Segment,
         Bus
 …
     //
     if (ExplainData) {
+      Status = PciExplainData (&ConfigSpace, Address, IoDev);
+      EnhancedDump = 0;
+      if (ShellCommandLineGetFlag(Package, L"-_e")) {
+        EnhancedDump = 0xFFFF;
+        Temp = ShellCommandLineGetValue(Package, L"-_e");
+        if (Temp != NULL) {
+          EnhancedDump = (UINT16) ShellHexStrToUintn (Temp);
+        }
+      }
+      Status = PciExplainData (&ConfigSpace, Address, IoDev, EnhancedDump);
+    }
+  }
 …
   UINTN                             Index;
   EFI_STATUS                        Status;
-  BOOLEAN                           FoundInterface;
   EFI_ACPI_ADDRESS_SPACE_DESCRIPTOR *Descriptors;
   UINT16                            MinBus;
 …
   BOOLEAN                           IsEnd;
-  FoundInterface = FALSE;
   //
   // Go through all handles, until the one meets the criteria is found
 …
       if (MinBus <= Bus && MaxBus >= Bus) {
+        FoundInterface = TRUE;
+        break;
+        return EFI_SUCCESS;
+      }
+    }
+  }
+  if (FoundInterface) {
+    return EFI_SUCCESS;
+  } else {
+    return EFI_INVALID_PARAMETER;
+  }
+  return EFI_NOT_FOUND;
+}
 …
   @param[in] Address         Address used to access configuration space of this PCI device.
   @param[in] IoDev           Handle used to access configuration space of PCI device.
+  @param[in] EnhancedDump    The print format for the dump data.
   @retval EFI_SUCCESS     The command completed successfully.
 …
   IN PCI_CONFIG_SPACE                       *ConfigSpace,
   IN UINT64                                 Address,
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL        *IoDev
+  IN EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL        *IoDev,
+  IN CONST UINT16                           EnhancedDump
+  )
+{
 …
   Common = &(ConfigSpace->Common);
   Print (L"\n");
+  ShellPrintEx (-1, -1, L"\r\n");
   //
 …
   // Print register Revision ID
   //
   ShellPrintEx(-1, -1, L"/r/n");
+  ShellPrintEx(-1, -1, L"\r\n");
   ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_PCI_LINE_RID), gShellDebug1HiiHandle,
     INDEX_OF (&(Common->RevisionId)),
 …
   ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_CLASS), gShellDebug1HiiHandle);
   PciPrintClassCode ((UINT8 *) Common->ClassCode, TRUE);
   Print (L"\n");
+  ShellPrintEx (-1, -1, L"\r\n");
   if (ShellGetExecutionBreakFlag()) {
 …
   //
   if ((Common->Status) & EFI_PCI_STATUS_CAPABILITY) {
     PciExplainCapabilityStruct (IoDev, Address, CapPtr);
+    PciExplainCapabilityStruct (IoDev, Address, CapPtr, EnhancedDump);
+  }
 …
       BarExist = TRUE;
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_START_TYPE), gShellDebug1HiiHandle);
       Print (L"  --------------------------------------------------------------------------");
+      ShellPrintEx (-1, -1, L"  --------------------------------------------------------------------------");
+    }
 …
   } else {
     Print (L"\n  --------------------------------------------------------------------------");
+    ShellPrintEx (-1, -1, L"\r\n  --------------------------------------------------------------------------");
+  }
 …
       BarExist = TRUE;
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_START_TYPE_2), gShellDebug1HiiHandle);
       Print (L"  --------------------------------------------------------------------------");
+      ShellPrintEx (-1, -1, L"  --------------------------------------------------------------------------");
+    }
 …
     ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_NONE), gShellDebug1HiiHandle);
   } else {
     Print (L"\n  --------------------------------------------------------------------------");
+    ShellPrintEx (-1, -1, L"\r\n  --------------------------------------------------------------------------");
+  }
 …
    );
   Print (L"               ------------------------------------------------------\n");
+  ShellPrintEx (-1, -1, L"               ------------------------------------------------------\r\n");
   ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_BRIDGE), gShellDebug1HiiHandle, Bridge->PrimaryBus);
 …
   //
   ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RESOURCE_TYPE), gShellDebug1HiiHandle);
   Print (L"----------------------------------------------------------------------\n");
+  ShellPrintEx (-1, -1, L"----------------------------------------------------------------------\r\n");
   //
 …
       Bar64 = 0x0;
       CopyMem (&Bar64, Bar, sizeof (UINT64));
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_ONE_VAR_2), gShellDebug1HiiHandle, RShiftU64 ((Bar64 & 0xfffffffffffffff0ULL), 32));
+      ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_ONE_VAR_2), gShellDebug1HiiHandle, (UINT32) RShiftU64 ((Bar64 & 0xfffffffffffffff0ULL), 32));
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_ONE_VAR_3), gShellDebug1HiiHandle, (UINT32) (Bar64 & 0xfffffffffffffff0ULL));
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_MEM), gShellDebug1HiiHandle);
 …
     IsMem = FALSE;
     ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_ONE_VAR_4), gShellDebug1HiiHandle, *Bar & 0xfffffffc);
     Print (L"I/O                               ");
+    ShellPrintEx (-1, -1, L"I/O                               ");
+  }
 …
     } else {
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RSHIFT), gShellDebug1HiiHandle, RShiftU64 (NewBar64, 32));
+      ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RSHIFT), gShellDebug1HiiHandle, (UINT32) RShiftU64 (NewBar64, 32));
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RSHIFT), gShellDebug1HiiHandle, (UINT32) NewBar64);
       Print (L"  ");
+      ShellPrintEx (-1, -1, L"  ");
       ShellPrintHiiEx(-1, -1, NULL,
         STRING_TOKEN (STR_PCI2_RSHIFT),
         gShellDebug1HiiHandle,
         RShiftU64 ((NewBar64 + (Bar64 & 0xfffffffffffffff0ULL) - 1), 32)
+        (UINT32) RShiftU64 ((NewBar64 + (Bar64 & 0xfffffffffffffff0ULL) - 1), 32)
        );
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RSHIFT), gShellDebug1HiiHandle, (UINT32) (NewBar64 + (Bar64 & 0xfffffffffffffff0ULL) - 1));
 …
    );
   Print (L"               ------------------------------------------------------\n");
+  ShellPrintEx (-1, -1, L"               ------------------------------------------------------\r\n");
   ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_CARDBUS), gShellDebug1HiiHandle, CardBus->PciBusNumber);
 …
   //
   ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_PCI2_RESOURCE_TYPE_2), gShellDebug1HiiHandle);
   Print (L"----------------------------------------------------------------------\n");
+  ShellPrintEx (-1, -1, L"----------------------------------------------------------------------\r\n");
   ShellPrintHiiEx(-1, -1, NULL,
 …
   Print each capability structure.
+  @param[in] IoDev      The pointer to the deivce.
+  @param[in] Address    The address to start at.
+  @param[in] CapPtr     The offset from the address.
+  @param[in] IoDev            The pointer to the deivce.
+  @param[in] Address          The address to start at.
+  @param[in] CapPtr           The offset from the address.
+  @param[in] EnhancedDump     The print format for the dump data.
   @retval EFI_SUCCESS     The operation was successful.
 …
   IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL         *IoDev,
   IN UINT64                                   Address,
+  IN  UINT8                                   CapPtr
+  IN  UINT8                                   CapPtr,
+  IN CONST UINT16                            EnhancedDump
+  )
+{
 …
     //
     if (EFI_PCI_CAPABILITY_ID_PCIEXP == CapabilityID) {
       PciExplainPciExpress (IoDev, Address, CapabilityPtr);
+      PciExplainPciExpress (IoDev, Address, CapabilityPtr, EnhancedDump);
       return EFI_SUCCESS;
+    }
 …
 EFI_STATUS
 ExplainPcieCapReg (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieCapReg = PciExpressCap->PcieCapReg;
   Print (
     L"  Capability Version(3:0):          %E0x%04x%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Capability Version(3:0):          %E0x%04x%N\r\n",
     PCIE_CAP_VERSION (PcieCapReg)
    );
 …
     DevicePortType = L"Unknown Type";
+  }
   Print (
     L"  Device/PortType(7:4):             %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Device/PortType(7:4):             %E%s%N\r\n",
     DevicePortType
    );
 …
   if (PCIE_CAP_DEVICEPORT_TYPE (PcieCapReg) == PCIE_ROOT_COMPLEX_ROOT_PORT ||
       PCIE_CAP_DEVICEPORT_TYPE (PcieCapReg) == PCIE_SWITCH_DOWNSTREAM_PORT) {
     Print (
       L"  Slot Implemented(8):              %E%d%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Slot Implemented(8):              %E%d%N\r\n",
       PCIE_CAP_SLOT_IMPLEMENTED (PcieCapReg)
      );
+  }
   Print (
     L"  Interrupt Message Number(13:9):   %E0x%05x%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Interrupt Message Number(13:9):   %E0x%05x%N\r\n",
     PCIE_CAP_INT_MSG_NUM (PcieCapReg)
    );
 …
 EFI_STATUS
 ExplainPcieDeviceCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieDeviceCap  = PciExpressCap->PcieDeviceCap;
   DevicePortType = (UINT8) PCIE_CAP_DEVICEPORT_TYPE (PcieCapReg);
   Print (L"  Max_Payload_Size Supported(2:0):          ");
+  ShellPrintEx (-1, -1, L"  Max_Payload_Size Supported(2:0):          ");
   if (PCIE_CAP_MAX_PAYLOAD (PcieDeviceCap) < 6) {
     Print (L"%E%d bytes%N\n", 1 << (PCIE_CAP_MAX_PAYLOAD (PcieDeviceCap) + 7));
+    ShellPrintEx (-1, -1, L"%E%d bytes%N\r\n", 1 << (PCIE_CAP_MAX_PAYLOAD (PcieDeviceCap) + 7));
   } else {
     Print (L"%EUnknown%N\n");
+  }
   Print (
     L"  Phantom Functions Supported(4:3):         %E%d%N\n",
+    ShellPrintEx (-1, -1, L"%EUnknown%N\r\n");
+  }
+  ShellPrintEx (-1, -1,
+    L"  Phantom Functions Supported(4:3):         %E%d%N\r\n",
     PCIE_CAP_PHANTOM_FUNC (PcieDeviceCap)
    );
   Print (
     L"  Extended Tag Field Supported(5):          %E%d-bit Tag field supported%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Extended Tag Field Supported(5):          %E%d-bit Tag field supported%N\r\n",
     PCIE_CAP_EXTENDED_TAG (PcieDeviceCap) ? 8 : 5
    );
 …
     L0sLatency = (UINT8) PCIE_CAP_L0SLATENCY (PcieDeviceCap);
     L1Latency  = (UINT8) PCIE_CAP_L1LATENCY (PcieDeviceCap);
     Print (L"  Endpoint L0s Acceptable Latency(8:6):     ");
+    ShellPrintEx (-1, -1, L"  Endpoint L0s Acceptable Latency(8:6):     ");
     if (L0sLatency < 4) {
       Print (L"%EMaximum of %d ns%N\n", 1 << (L0sLatency + 6));
+      ShellPrintEx (-1, -1, L"%EMaximum of %d ns%N\r\n", 1 << (L0sLatency + 6));
     } else {
       if (L0sLatency < 7) {
         Print (L"%EMaximum of %d us%N\n", 1 << (L0sLatency - 3));
+        ShellPrintEx (-1, -1, L"%EMaximum of %d us%N\r\n", 1 << (L0sLatency - 3));
       } else {
         Print (L"%ENo limit%N\n");
+        ShellPrintEx (-1, -1, L"%ENo limit%N\r\n");
+      }
+    }
     Print (L"  Endpoint L1 Acceptable Latency(11:9):     ");
+    ShellPrintEx (-1, -1, L"  Endpoint L1 Acceptable Latency(11:9):     ");
     if (L1Latency < 7) {
       Print (L"%EMaximum of %d us%N\n", 1 << (L1Latency + 1));
+      ShellPrintEx (-1, -1, L"%EMaximum of %d us%N\r\n", 1 << (L1Latency + 1));
     } else {
       Print (L"%ENo limit%N\n");
+      ShellPrintEx (-1, -1, L"%ENo limit%N\r\n");
+    }
+  }
   Print (
     L"  Role-based Error Reporting(15):           %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Role-based Error Reporting(15):           %E%d%N\r\n",
     PCIE_CAP_ERR_REPORTING (PcieDeviceCap)
    );
 …
   //
   if (DevicePortType == PCIE_SWITCH_UPSTREAM_PORT) {
     Print (
       L"  Captured Slot Power Limit Value(25:18):   %E0x%02x%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Captured Slot Power Limit Value(25:18):   %E0x%02x%N\r\n",
       PCIE_CAP_SLOT_POWER_VALUE (PcieDeviceCap)
      );
     Print (
       L"  Captured Slot Power Limit Scale(27:26):   %E%s%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Captured Slot Power Limit Scale(27:26):   %E%s%N\r\n",
       SlotPwrLmtScaleTable[PCIE_CAP_SLOT_POWER_SCALE (PcieDeviceCap)]
      );
 …
   //
   if (IS_PCIE_ENDPOINT (DevicePortType)) {
     Print (
       L"  Function Level Reset Capability(28):      %E%d%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Function Level Reset Capability(28):      %E%d%N\r\n",
       PCIE_CAP_FUNC_LEVEL_RESET (PcieDeviceCap)
      );
 …
 EFI_STATUS
 ExplainPcieDeviceControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieCapReg        = PciExpressCap->PcieCapReg;
   PcieDeviceControl = PciExpressCap->DeviceControl;
   Print (
     L"  Correctable Error Reporting Enable(0):    %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Correctable Error Reporting Enable(0):    %E%d%N\r\n",
     PCIE_CAP_COR_ERR_REPORTING_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Non-Fatal Error Reporting Enable(1):      %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Non-Fatal Error Reporting Enable(1):      %E%d%N\r\n",
     PCIE_CAP_NONFAT_ERR_REPORTING_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Fatal Error Reporting Enable(2):          %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Fatal Error Reporting Enable(2):          %E%d%N\r\n",
     PCIE_CAP_FATAL_ERR_REPORTING_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Unsupported Request Reporting Enable(3):  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Unsupported Request Reporting Enable(3):  %E%d%N\r\n",
     PCIE_CAP_UNSUP_REQ_REPORTING_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Enable Relaxed Ordering(4):               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Enable Relaxed Ordering(4):               %E%d%N\r\n",
     PCIE_CAP_RELAXED_ORDERING_ENABLE (PcieDeviceControl)
    );
   Print (L"  Max_Payload_Size(7:5):                    ");
+  ShellPrintEx (-1, -1, L"  Max_Payload_Size(7:5):                    ");
   if (PCIE_CAP_MAX_PAYLOAD_SIZE (PcieDeviceControl) < 6) {
     Print (L"%E%d bytes%N\n", 1 << (PCIE_CAP_MAX_PAYLOAD_SIZE (PcieDeviceControl) + 7));
+    ShellPrintEx (-1, -1, L"%E%d bytes%N\r\n", 1 << (PCIE_CAP_MAX_PAYLOAD_SIZE (PcieDeviceControl) + 7));
   } else {
     Print (L"%EUnknown%N\n");
+  }
   Print (
     L"  Extended Tag Field Enable(8):             %E%d%N\n",
+    ShellPrintEx (-1, -1, L"%EUnknown%N\r\n");
+  }
+  ShellPrintEx (-1, -1,
+    L"  Extended Tag Field Enable(8):             %E%d%N\r\n",
     PCIE_CAP_EXTENDED_TAG_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Phantom Functions Enable(9):              %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Phantom Functions Enable(9):              %E%d%N\r\n",
     PCIE_CAP_PHANTOM_FUNC_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Auxiliary (AUX) Power PM Enable(10):      %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Auxiliary (AUX) Power PM Enable(10):      %E%d%N\r\n",
     PCIE_CAP_AUX_PM_ENABLE (PcieDeviceControl)
    );
   Print (
     L"  Enable No Snoop(11):                      %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Enable No Snoop(11):                      %E%d%N\r\n",
     PCIE_CAP_NO_SNOOP_ENABLE (PcieDeviceControl)
    );
   Print (L"  Max_Read_Request_Size(14:12):             ");
+  ShellPrintEx (-1, -1, L"  Max_Read_Request_Size(14:12):             ");
   if (PCIE_CAP_MAX_READ_REQ_SIZE (PcieDeviceControl) < 6) {
     Print (L"%E%d bytes%N\n", 1 << (PCIE_CAP_MAX_READ_REQ_SIZE (PcieDeviceControl) + 7));
+    ShellPrintEx (-1, -1, L"%E%d bytes%N\r\n", 1 << (PCIE_CAP_MAX_READ_REQ_SIZE (PcieDeviceControl) + 7));
   } else {
     Print (L"%EUnknown%N\n");
+    ShellPrintEx (-1, -1, L"%EUnknown%N\r\n");
+  }
   //
 …
   //
   if (PCIE_CAP_DEVICEPORT_TYPE (PcieCapReg) == PCIE_PCIE_TO_PCIX_BRIDGE) {
     Print (
       L"  Bridge Configuration Retry Enable(15):  %E%d%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Bridge Configuration Retry Enable(15):  %E%d%N\r\n",
       PCIE_CAP_BRG_CONF_RETRY (PcieDeviceControl)
      );
 …
 EFI_STATUS
 ExplainPcieDeviceStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieDeviceStatus = PciExpressCap->DeviceStatus;
   Print (
     L"  Correctable Error Detected(0):            %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Correctable Error Detected(0):            %E%d%N\r\n",
     PCIE_CAP_COR_ERR_DETECTED (PcieDeviceStatus)
    );
   Print (
     L"  Non-Fatal Error Detected(1):              %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Non-Fatal Error Detected(1):              %E%d%N\r\n",
     PCIE_CAP_NONFAT_ERR_DETECTED (PcieDeviceStatus)
    );
   Print (
     L"  Fatal Error Detected(2):                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Fatal Error Detected(2):                  %E%d%N\r\n",
     PCIE_CAP_FATAL_ERR_DETECTED (PcieDeviceStatus)
    );
   Print (
     L"  Unsupported Request Detected(3):          %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Unsupported Request Detected(3):          %E%d%N\r\n",
     PCIE_CAP_UNSUP_REQ_DETECTED (PcieDeviceStatus)
    );
   Print (
     L"  AUX Power Detected(4):                    %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  AUX Power Detected(4):                    %E%d%N\r\n",
     PCIE_CAP_AUX_POWER_DETECTED (PcieDeviceStatus)
    );
   Print (
     L"  Transactions Pending(5):                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Transactions Pending(5):                  %E%d%N\r\n",
     PCIE_CAP_TRANSACTION_PENDING (PcieDeviceStatus)
    );
 …
 EFI_STATUS
 ExplainPcieLinkCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
   UINT32 PcieLinkCap;
   CHAR16 *SupLinkSpeeds;
+  CHAR16 *MaxLinkSpeed;
   CHAR16 *AspmValue;
   PcieLinkCap = PciExpressCap->LinkCap;
   switch (PCIE_CAP_SUP_LINK_SPEEDS (PcieLinkCap)) {
+  switch (PCIE_CAP_MAX_LINK_SPEED (PcieLinkCap)) {
     case 1:
       SupLinkSpeeds = L"2.5 GT/s";
+      MaxLinkSpeed = L"2.5 GT/s";
       break;
     case 2:
+      SupLinkSpeeds = L"5.0 GT/s and 2.5 GT/s";
+      MaxLinkSpeed = L"5.0 GT/s";
+      break;
+    case 3:
+      MaxLinkSpeed = L"8.0 GT/s";
       break;
     default:
       SupLinkSpeeds = L"Unknown";
+      MaxLinkSpeed = L"Unknown";
       break;
+  }
   Print (
     L"  Supported Link Speeds(3:0):                         %E%s supported%N\n",
     SupLinkSpeeds
    );
   Print (
     L"  Maximum Link Width(9:4):                            %Ex%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Maximum Link Speed(3:0):                            %E%s%N\r\n",
+    MaxLinkSpeed
+   );
+  ShellPrintEx (-1, -1,
+    L"  Maximum Link Width(9:4):                            %Ex%d%N\r\n",
     PCIE_CAP_MAX_LINK_WIDTH (PcieLinkCap)
    );
   switch (PCIE_CAP_ASPM_SUPPORT (PcieLinkCap)) {
+    case 0:
+      AspmValue = L"Not";
+      break;
     case 1:
+      AspmValue = L"L0s Entry";
+      AspmValue = L"L0s";
+      break;
+    case 2:
+      AspmValue = L"L1";
       break;
     case 3:
 …
       break;
+  }
   Print (
     L"  Active State Power Management Support(11:10):       %E%s Supported%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Active State Power Management Support(11:10):       %E%s Supported%N\r\n",
     AspmValue
    );
   Print (
     L"  L0s Exit Latency(14:12):                            %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  L0s Exit Latency(14:12):                            %E%s%N\r\n",
     L0sLatencyStrTable[PCIE_CAP_L0S_LATENCY (PcieLinkCap)]
    );
   Print (
     L"  L1 Exit Latency(17:15):                             %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  L1 Exit Latency(17:15):                             %E%s%N\r\n",
     L1LatencyStrTable[PCIE_CAP_L0S_LATENCY (PcieLinkCap)]
    );
   Print (
     L"  Clock Power Management(18):                         %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Clock Power Management(18):                         %E%d%N\r\n",
     PCIE_CAP_CLOCK_PM (PcieLinkCap)
    );
   Print (
     L"  Surprise Down Error Reporting Capable(19):          %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Surprise Down Error Reporting Capable(19):          %E%d%N\r\n",
     PCIE_CAP_SUP_DOWN_ERR_REPORTING (PcieLinkCap)
    );
   Print (
     L"  Data Link Layer Link Active Reporting Capable(20):  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Data Link Layer Link Active Reporting Capable(20):  %E%d%N\r\n",
     PCIE_CAP_LINK_ACTIVE_REPORTING (PcieLinkCap)
    );
   Print (
     L"  Link Bandwidth Notification Capability(21):         %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Bandwidth Notification Capability(21):         %E%d%N\r\n",
     PCIE_CAP_LINK_BWD_NOTIF_CAP (PcieLinkCap)
    );
   Print (
     L"  Port Number(31:24):                                 %E0x%02x%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Port Number(31:24):                                 %E0x%02x%N\r\n",
     PCIE_CAP_PORT_NUMBER (PcieLinkCap)
    );
 …
 EFI_STATUS
 ExplainPcieLinkControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieLinkControl = PciExpressCap->LinkControl;
   DevicePortType  = (UINT8) PCIE_CAP_DEVICEPORT_TYPE (PciExpressCap->PcieCapReg);
   Print (
     L"  Active State Power Management Control(1:0):         %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Active State Power Management Control(1:0):         %E%s%N\r\n",
     ASPMCtrlStrTable[PCIE_CAP_ASPM_CONTROL (PcieLinkControl)]
    );
 …
   //
   if (!IS_PCIE_SWITCH(DevicePortType)) {
     Print (
       L"  Read Completion Boundary (RCB)(3):                  %E%d byte%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Read Completion Boundary (RCB)(3):                  %E%d byte%N\r\n",
 << (PCIE_CAP_RCB (PcieLinkControl) + 6)
      );
 …
       DevicePortType != PCIE_SWITCH_UPSTREAM_PORT &&
       DevicePortType != PCIE_PCIE_TO_PCIX_BRIDGE) {
     Print (
       L"  Link Disable(4):                                    %E%d%N\n",
+    ShellPrintEx (-1, -1,
+      L"  Link Disable(4):                                    %E%d%N\r\n",
       PCIE_CAP_LINK_DISABLE (PcieLinkControl)
      );
+  }
   Print (
     L"  Common Clock Configuration(6):                      %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Common Clock Configuration(6):                      %E%d%N\r\n",
     PCIE_CAP_COMMON_CLK_CONF (PcieLinkControl)
    );
   Print (
     L"  Extended Synch(7):                                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Extended Synch(7):                                  %E%d%N\r\n",
     PCIE_CAP_EXT_SYNC (PcieLinkControl)
    );
   Print (
     L"  Enable Clock Power Management(8):                   %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Enable Clock Power Management(8):                   %E%d%N\r\n",
     PCIE_CAP_CLK_PWR_MNG (PcieLinkControl)
    );
   Print (
     L"  Hardware Autonomous Width Disable(9):               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Hardware Autonomous Width Disable(9):               %E%d%N\r\n",
     PCIE_CAP_HW_AUTO_WIDTH_DISABLE (PcieLinkControl)
    );
   Print (
     L"  Link Bandwidth Management Interrupt Enable(10):     %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Bandwidth Management Interrupt Enable(10):     %E%d%N\r\n",
     PCIE_CAP_LINK_BDW_MNG_INT_EN (PcieLinkControl)
    );
   Print (
     L"  Link Autonomous Bandwidth Interrupt Enable(11):     %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Autonomous Bandwidth Interrupt Enable(11):     %E%d%N\r\n",
     PCIE_CAP_LINK_AUTO_BDW_INT_EN (PcieLinkControl)
    );
 …
 EFI_STATUS
 ExplainPcieLinkStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
   UINT16 PcieLinkStatus;
   CHAR16 *SupLinkSpeeds;
+  CHAR16 *CurLinkSpeed;
   PcieLinkStatus = PciExpressCap->LinkStatus;
   switch (PCIE_CAP_CUR_LINK_SPEED (PcieLinkStatus)) {
     case 1:
       SupLinkSpeeds = L"2.5 GT/s";
+      CurLinkSpeed = L"2.5 GT/s";
       break;
     case 2:
+      SupLinkSpeeds = L"5.0 GT/s";
+      CurLinkSpeed = L"5.0 GT/s";
+      break;
+    case 3:
+      CurLinkSpeed = L"8.0 GT/s";
       break;
     default:
       SupLinkSpeeds = L"Reserved";
+      CurLinkSpeed = L"Reserved";
       break;
+  }
   Print (
     L"  Current Link Speed(3:0):                            %E%s%N\n",
     SupLinkSpeeds
    );
   Print (
     L"  Negotiated Link Width(9:4):                         %Ex%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Current Link Speed(3:0):                            %E%s%N\r\n",
+    CurLinkSpeed
+   );
+  ShellPrintEx (-1, -1,
+    L"  Negotiated Link Width(9:4):                         %Ex%d%N\r\n",
     PCIE_CAP_NEGO_LINK_WIDTH (PcieLinkStatus)
    );
   Print (
     L"  Link Training(11):                                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Training(11):                                  %E%d%N\r\n",
     PCIE_CAP_LINK_TRAINING (PcieLinkStatus)
    );
   Print (
     L"  Slot Clock Configuration(12):                       %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Slot Clock Configuration(12):                       %E%d%N\r\n",
     PCIE_CAP_SLOT_CLK_CONF (PcieLinkStatus)
    );
   Print (
     L"  Data Link Layer Link Active(13):                    %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Data Link Layer Link Active(13):                    %E%d%N\r\n",
     PCIE_CAP_DATA_LINK_ACTIVE (PcieLinkStatus)
    );
   Print (
     L"  Link Bandwidth Management Status(14):               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Bandwidth Management Status(14):               %E%d%N\r\n",
     PCIE_CAP_LINK_BDW_MNG_STAT (PcieLinkStatus)
    );
   Print (
     L"  Link Autonomous Bandwidth Status(15):               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Link Autonomous Bandwidth Status(15):               %E%d%N\r\n",
     PCIE_CAP_LINK_AUTO_BDW_STAT (PcieLinkStatus)
    );
 …
 EFI_STATUS
 ExplainPcieSlotCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieSlotCap = PciExpressCap->SlotCap;
   Print (
     L"  Attention Button Present(0):                        %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Attention Button Present(0):                        %E%d%N\r\n",
     PCIE_CAP_ATT_BUT_PRESENT (PcieSlotCap)
    );
   Print (
     L"  Power Controller Present(1):                        %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Power Controller Present(1):                        %E%d%N\r\n",
     PCIE_CAP_PWR_CTRLLER_PRESENT (PcieSlotCap)
    );
   Print (
     L"  MRL Sensor Present(2):                              %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  MRL Sensor Present(2):                              %E%d%N\r\n",
     PCIE_CAP_MRL_SENSOR_PRESENT (PcieSlotCap)
    );
   Print (
     L"  Attention Indicator Present(3):                     %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Attention Indicator Present(3):                     %E%d%N\r\n",
     PCIE_CAP_ATT_IND_PRESENT (PcieSlotCap)
    );
   Print (
     L"  Power Indicator Present(4):                         %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Power Indicator Present(4):                         %E%d%N\r\n",
     PCIE_CAP_PWD_IND_PRESENT (PcieSlotCap)
    );
   Print (
     L"  Hot-Plug Surprise(5):                               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Hot-Plug Surprise(5):                               %E%d%N\r\n",
     PCIE_CAP_HOTPLUG_SUPPRISE (PcieSlotCap)
    );
   Print (
     L"  Hot-Plug Capable(6):                                %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Hot-Plug Capable(6):                                %E%d%N\r\n",
     PCIE_CAP_HOTPLUG_CAPABLE (PcieSlotCap)
    );
   Print (
     L"  Slot Power Limit Value(14:7):                       %E0x%02x%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Slot Power Limit Value(14:7):                       %E0x%02x%N\r\n",
     PCIE_CAP_SLOT_PWR_LIMIT_VALUE (PcieSlotCap)
    );
   Print (
     L"  Slot Power Limit Scale(16:15):                      %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Slot Power Limit Scale(16:15):                      %E%s%N\r\n",
     SlotPwrLmtScaleTable[PCIE_CAP_SLOT_PWR_LIMIT_SCALE (PcieSlotCap)]
    );
   Print (
     L"  Electromechanical Interlock Present(17):            %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Electromechanical Interlock Present(17):            %E%d%N\r\n",
     PCIE_CAP_ELEC_INTERLOCK_PRESENT (PcieSlotCap)
    );
   Print (
     L"  No Command Completed Support(18):                   %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  No Command Completed Support(18):                   %E%d%N\r\n",
     PCIE_CAP_NO_COMM_COMPLETED_SUP (PcieSlotCap)
    );
   Print (
     L"  Physical Slot Number(31:19):                        %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Physical Slot Number(31:19):                        %E%d%N\r\n",
     PCIE_CAP_PHY_SLOT_NUM (PcieSlotCap)
    );
 …
 EFI_STATUS
 ExplainPcieSlotControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieSlotControl = PciExpressCap->SlotControl;
   Print (
     L"  Attention Button Pressed Enable(0):                 %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Attention Button Pressed Enable(0):                 %E%d%N\r\n",
     PCIE_CAP_ATT_BUT_ENABLE (PcieSlotControl)
    );
   Print (
     L"  Power Fault Detected Enable(1):                     %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Power Fault Detected Enable(1):                     %E%d%N\r\n",
     PCIE_CAP_PWR_FLT_DETECT_ENABLE (PcieSlotControl)
    );
   Print (
     L"  MRL Sensor Changed Enable(2):                       %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  MRL Sensor Changed Enable(2):                       %E%d%N\r\n",
     PCIE_CAP_MRL_SENSOR_CHANGE_ENABLE (PcieSlotControl)
    );
   Print (
     L"  Presence Detect Changed Enable(3):                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Presence Detect Changed Enable(3):                  %E%d%N\r\n",
     PCIE_CAP_PRES_DETECT_CHANGE_ENABLE (PcieSlotControl)
    );
   Print (
     L"  Command Completed Interrupt Enable(4):              %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Command Completed Interrupt Enable(4):              %E%d%N\r\n",
     PCIE_CAP_COMM_CMPL_INT_ENABLE (PcieSlotControl)
    );
   Print (
     L"  Hot-Plug Interrupt Enable(5):                       %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Hot-Plug Interrupt Enable(5):                       %E%d%N\r\n",
     PCIE_CAP_HOTPLUG_INT_ENABLE (PcieSlotControl)
    );
   Print (
     L"  Attention Indicator Control(7:6):                   %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Attention Indicator Control(7:6):                   %E%s%N\r\n",
     IndicatorTable[PCIE_CAP_ATT_IND_CTRL (PcieSlotControl)]
    );
   Print (
     L"  Power Indicator Control(9:8):                       %E%s%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Power Indicator Control(9:8):                       %E%s%N\r\n",
     IndicatorTable[PCIE_CAP_PWR_IND_CTRL (PcieSlotControl)]
    );
   Print (L"  Power Controller Control(10):                       %EPower ");
+  ShellPrintEx (-1, -1, L"  Power Controller Control(10):                       %EPower ");
   if (PCIE_CAP_PWR_CTRLLER_CTRL (PcieSlotControl)) {
     Print (L"Off%N\n");
+    ShellPrintEx (-1, -1, L"Off%N\r\n");
   } else {
     Print (L"On%N\n");
+  }
   Print (
     L"  Electromechanical Interlock Control(11):            %E%d%N\n",
+    ShellPrintEx (-1, -1, L"On%N\r\n");
+  }
+  ShellPrintEx (-1, -1,
+    L"  Electromechanical Interlock Control(11):            %E%d%N\r\n",
     PCIE_CAP_ELEC_INTERLOCK_CTRL (PcieSlotControl)
    );
   Print (
     L"  Data Link Layer State Changed Enable(12):           %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Data Link Layer State Changed Enable(12):           %E%d%N\r\n",
     PCIE_CAP_DLINK_STAT_CHANGE_ENABLE (PcieSlotControl)
    );
 …
 EFI_STATUS
 ExplainPcieSlotStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieSlotStatus = PciExpressCap->SlotStatus;
   Print (
     L"  Attention Button Pressed(0):           %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Attention Button Pressed(0):           %E%d%N\r\n",
     PCIE_CAP_ATT_BUT_PRESSED (PcieSlotStatus)
    );
   Print (
     L"  Power Fault Detected(1):               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Power Fault Detected(1):               %E%d%N\r\n",
     PCIE_CAP_PWR_FLT_DETECTED (PcieSlotStatus)
    );
   Print (
     L"  MRL Sensor Changed(2):                 %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  MRL Sensor Changed(2):                 %E%d%N\r\n",
     PCIE_CAP_MRL_SENSOR_CHANGED (PcieSlotStatus)
    );
   Print (
     L"  Presence Detect Changed(3):            %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Presence Detect Changed(3):            %E%d%N\r\n",
     PCIE_CAP_PRES_DETECT_CHANGED (PcieSlotStatus)
    );
   Print (
     L"  Command Completed(4):                  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  Command Completed(4):                  %E%d%N\r\n",
     PCIE_CAP_COMM_COMPLETED (PcieSlotStatus)
    );
   Print (L"  MRL Sensor State(5):                   %EMRL ");
+  ShellPrintEx (-1, -1, L"  MRL Sensor State(5):                   %EMRL ");
   if (PCIE_CAP_MRL_SENSOR_STATE (PcieSlotStatus)) {
     Print (L" Opened%N\n");
+    ShellPrintEx (-1, -1, L" Opened%N\r\n");
   } else {
     Print (L" Closed%N\n");
+  }
   Print (L"  Presence Detect State(6):              ");
+    ShellPrintEx (-1, -1, L" Closed%N\r\n");
+  }
+  ShellPrintEx (-1, -1, L"  Presence Detect State(6):              ");
   if (PCIE_CAP_PRES_DETECT_STATE (PcieSlotStatus)) {
     Print (L"%ECard Present in slot%N\n");
+    ShellPrintEx (-1, -1, L"%ECard Present in slot%N\r\n");
   } else {
     Print (L"%ESlot Empty%N\n");
+  }
   Print (L"  Electromechanical Interlock Status(7): %EElectromechanical Interlock ");
+    ShellPrintEx (-1, -1, L"%ESlot Empty%N\r\n");
+  }
+  ShellPrintEx (-1, -1, L"  Electromechanical Interlock Status(7): %EElectromechanical Interlock ");
   if (PCIE_CAP_ELEC_INTERLOCK_STATE (PcieSlotStatus)) {
     Print (L"Engaged%N\n");
+    ShellPrintEx (-1, -1, L"Engaged%N\r\n");
   } else {
     Print (L"Disengaged%N\n");
+  }
   Print (
     L"  Data Link Layer State Changed(8):      %E%d%N\n",
+    ShellPrintEx (-1, -1, L"Disengaged%N\r\n");
+  }
+  ShellPrintEx (-1, -1,
+    L"  Data Link Layer State Changed(8):      %E%d%N\r\n",
     PCIE_CAP_DLINK_STAT_CHANGED (PcieSlotStatus)
    );
 …
 EFI_STATUS
 ExplainPcieRootControl (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieRootControl = PciExpressCap->RootControl;
   Print (
     L"  System Error on Correctable Error Enable(0):  %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  System Error on Correctable Error Enable(0):  %E%d%N\r\n",
     PCIE_CAP_SYSERR_ON_CORERR_EN (PcieRootControl)
    );
   Print (
     L"  System Error on Non-Fatal Error Enable(1):    %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  System Error on Non-Fatal Error Enable(1):    %E%d%N\r\n",
     PCIE_CAP_SYSERR_ON_NONFATERR_EN (PcieRootControl)
    );
   Print (
     L"  System Error on Fatal Error Enable(2):        %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  System Error on Fatal Error Enable(2):        %E%d%N\r\n",
     PCIE_CAP_SYSERR_ON_FATERR_EN (PcieRootControl)
    );
   Print (
     L"  PME Interrupt Enable(3):                      %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  PME Interrupt Enable(3):                      %E%d%N\r\n",
     PCIE_CAP_PME_INT_ENABLE (PcieRootControl)
    );
   Print (
     L"  CRS Software Visibility Enable(4):            %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  CRS Software Visibility Enable(4):            %E%d%N\r\n",
     PCIE_CAP_CRS_SW_VIS_ENABLE (PcieRootControl)
    );
 …
 EFI_STATUS
 ExplainPcieRootCap (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieRootCap = PciExpressCap->RsvdP;
   Print (
     L"  CRS Software Visibility(0):                   %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  CRS Software Visibility(0):                   %E%d%N\r\n",
     PCIE_CAP_CRS_SW_VIS (PcieRootCap)
    );
 …
 EFI_STATUS
 ExplainPcieRootStatus (
   IN PCIE_CAP_STURCTURE *PciExpressCap
+  IN PCIE_CAP_STRUCTURE *PciExpressCap
+  )
+{
 …
   PcieRootStatus = PciExpressCap->RootStatus;
   Print (
     L"  PME Requester ID(15:0):                       %E0x%04x%N\n",
+  ShellPrintEx (-1, -1,
+    L"  PME Requester ID(15:0):                       %E0x%04x%N\r\n",
     PCIE_CAP_PME_REQ_ID (PcieRootStatus)
    );
   Print (
     L"  PME Status(16):                               %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  PME Status(16):                               %E%d%N\r\n",
     PCIE_CAP_PME_STATUS (PcieRootStatus)
    );
   Print (
     L"  PME Pending(17):                              %E%d%N\n",
+  ShellPrintEx (-1, -1,
+    L"  PME Pending(17):                              %E%d%N\r\n",
     PCIE_CAP_PME_PENDING (PcieRootStatus)
    );
   return EFI_SUCCESS;
+}
+/**
+  Function to interpret and print out the link control structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityLinkControl (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_INTERNAL_LINK_CONTROL *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_INTERNAL_LINK_CONTROL*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_LINK_CONTROL),
+    gShellDebug1HiiHandle,
+    Header->RootComplexLinkCapabilities,
+    Header->RootComplexLinkControl,
+    Header->RootComplexLinkStatus
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_INTERNAL_LINK_CONTROL),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the power budgeting structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityPowerBudgeting (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_POWER_BUDGETING *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_POWER_BUDGETING*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_POWER),
+    gShellDebug1HiiHandle,
+    Header->DataSelect,
+    Header->Data,
+    Header->PowerBudgetCapability
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_POWER_BUDGETING),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the ACS structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityAcs (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_ACS_EXTENDED  *Header;
+  UINT16                                                VectorSize;
+  UINT16                                                LoopCounter;
+  Header      = (PCI_EXPRESS_EXTENDED_CAPABILITIES_ACS_EXTENDED*)HeaderAddress;
+  VectorSize  = 0;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_ACS),
+    gShellDebug1HiiHandle,
+    Header->AcsCapability,
+    Header->AcsControl
+    );
+  if (PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_GET_EGRES_CONTROL(Header)) {
+    VectorSize = PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_GET_EGRES_VECTOR_SIZE(Header);
+    if (VectorSize == 0) {
+      VectorSize = 256;
+    }
+    for (LoopCounter = 0 ; LoopCounter * 8 < VectorSize ; LoopCounter++) {
+      ShellPrintHiiEx(
+        -1, -1, NULL,
+        STRING_TOKEN (STR_PCI_EXT_CAP_ACS2),
+        gShellDebug1HiiHandle,
+        LoopCounter + 1,
+        Header->EgressControlVectorArray[LoopCounter]
+        );
+    }
+  }
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_ACS_EXTENDED) + (VectorSize / 8) - 1,
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the latency tolerance reporting structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityLatencyToleranceReporting (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_LATENCE_TOLERANCE_REPORTING *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_LATENCE_TOLERANCE_REPORTING*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_LAT),
+    gShellDebug1HiiHandle,
+    Header->MaxSnoopLatency,
+    Header->MaxNoSnoopLatency
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_LATENCE_TOLERANCE_REPORTING),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the serial number structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilitySerialNumber (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_SERIAL_NUMBER *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_SERIAL_NUMBER*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_SN),
+    gShellDebug1HiiHandle,
+    Header->SerialNumber
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_SERIAL_NUMBER),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the RCRB structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityRcrb (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_RCRB_HEADER *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_RCRB_HEADER*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_RCRB),
+    gShellDebug1HiiHandle,
+    Header->VendorId,
+    Header->DeviceId,
+    Header->RcrbCapabilities,
+    Header->RcrbControl
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_RCRB_HEADER),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the vendor specific structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityVendorSpecific (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_VENDOR_SPECIFIC *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_VENDOR_SPECIFIC*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_VEN),
+    gShellDebug1HiiHandle,
+    Header->VendorSpecificHeader
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    PCI_EXPRESS_EXTENDED_CAPABILITY_VENDOR_SPECIFIC_GET_SIZE(Header),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the Event Collector Endpoint Association structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityECEA (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_ECEA),
+    gShellDebug1HiiHandle,
+    Header->AssociationBitmap
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the ARI structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityAri (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_ARI_CAPABILITY *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_ARI_CAPABILITY*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_ARI),
+    gShellDebug1HiiHandle,
+    Header->AriCapability,
+    Header->AriControl
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_ARI_CAPABILITY),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the DPA structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityDynamicPowerAllocation (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_DYNAMIC_POWER_ALLOCATION *Header;
+  UINT8                                                            LinkCount;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_DYNAMIC_POWER_ALLOCATION*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_DPA),
+    gShellDebug1HiiHandle,
+    Header->DpaCapability,
+    Header->DpaLatencyIndicator,
+    Header->DpaStatus,
+    Header->DpaControl
+    );
+  for (LinkCount = 0 ; LinkCount < PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_GET_SUBSTATE_MAX(Header) + 1 ; LinkCount++) {
+    ShellPrintHiiEx(
+      -1, -1, NULL,
+      STRING_TOKEN (STR_PCI_EXT_CAP_DPA2),
+      gShellDebug1HiiHandle,
+      LinkCount+1,
+      Header->DpaPowerAllocationArray[LinkCount]
+      );
+  }
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_DYNAMIC_POWER_ALLOCATION) - 1 + PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_GET_SUBSTATE_MAX(Header),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the link declaration structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityLinkDeclaration (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_LINK_DECLARATION  *Header;
+  UINT8                                                     LinkCount;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_LINK_DECLARATION*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_LINK_DECLAR),
+    gShellDebug1HiiHandle,
+    Header->ElementSelfDescription
+    );
+  for (LinkCount = 0 ; LinkCount < PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_GET_LINK_COUNT(Header) ; LinkCount++) {
+    ShellPrintHiiEx(
+      -1, -1, NULL,
+      STRING_TOKEN (STR_PCI_EXT_CAP_LINK_DECLAR2),
+      gShellDebug1HiiHandle,
+      LinkCount+1,
+      Header->LinkEntry[LinkCount]
+      );
+  }
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_LINK_DECLARATION) + (PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_GET_LINK_COUNT(Header)-1)*sizeof(UINT32),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the Advanced Error Reporting structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityAer (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_ADVANCED_ERROR_REPORTING *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_ADVANCED_ERROR_REPORTING*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_AER),
+    gShellDebug1HiiHandle,
+    Header->UncorrectableErrorStatus,
+    Header->UncorrectableErrorMask,
+    Header->UncorrectableErrorSeverity,
+    Header->CorrectableErrorStatus,
+    Header->CorrectableErrorMask,
+    Header->AdvancedErrorCapabilitiesAndControl,
+    Header->HeaderLog,
+    Header->RootErrorCommand,
+    Header->RootErrorStatus,
+    Header->ErrorSourceIdentification,
+    Header->CorrectableErrorSourceIdentification,
+    Header->TlpPrefixLog[0],
+    Header->TlpPrefixLog[1],
+    Header->TlpPrefixLog[2],
+    Header->TlpPrefixLog[3]
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_ADVANCED_ERROR_REPORTING),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the multicast structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+  @param[in] PciExpressCapPtr     The address of the PCIe capabilities structure.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityMulticast (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress,
+  IN CONST PCIE_CAP_STRUCTURE *PciExpressCapPtr
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_MULTICAST *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_MULTICAST*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_MULTICAST),
+    gShellDebug1HiiHandle,
+    Header->MultiCastCapability,
+    Header->MulticastControl,
+    Header->McBaseAddress,
+    Header->McReceiveAddress,
+    Header->McBlockAll,
+    Header->McBlockUntranslated,
+    Header->McOverlayBar
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_MULTICAST),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the virtual channel and multi virtual channel structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityVirtualChannel (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_CAPABILITY  *Header;
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_VC          *CapabilityItem;
+  UINT32                                                              ItemCount;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_CAPABILITY*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_VC_BASE),
+    gShellDebug1HiiHandle,
+    Header->ExtendedVcCount,
+    Header->PortVcCapability1,
+    Header->PortVcCapability2,
+    Header->VcArbTableOffset,
+    Header->PortVcControl,
+    Header->PortVcStatus
+    );
+  for (ItemCount = 0 ; ItemCount < Header->ExtendedVcCount ; ItemCount++) {
+    CapabilityItem = &Header->Capability[ItemCount];
+    ShellPrintHiiEx(
+      -1, -1, NULL,
+      STRING_TOKEN (STR_PCI_EXT_CAP_VC_ITEM),
+      gShellDebug1HiiHandle,
+      ItemCount+1,
+      CapabilityItem->VcResourceCapability,
+      CapabilityItem->PortArbTableOffset,
+      CapabilityItem->VcResourceControl,
+      CapabilityItem->VcResourceStatus
+      );
+  }
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_VC) + (Header->ExtendedVcCount - 1) * sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_VIRTUAL_CHANNEL_CAPABILITY),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the resizeable bar structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityResizeableBar (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR        *Header;
+  UINT32                                                       ItemCount;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR*)HeaderAddress;
+  for (ItemCount = 0 ; ItemCount < (UINT32)GET_NUMBER_RESIZABLE_BARS(Header) ; ItemCount++) {
+    ShellPrintHiiEx(
+      -1, -1, NULL,
+      STRING_TOKEN (STR_PCI_EXT_CAP_RESIZE_BAR),
+      gShellDebug1HiiHandle,
+      ItemCount+1,
+      Header->Capability[ItemCount].ResizableBarCapability,
+      Header->Capability[ItemCount].ResizableBarControl
+      );
+  }
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    (UINT32)GET_NUMBER_RESIZABLE_BARS(Header) * sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_RESIZABLE_BAR_ENTRY),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the TPH structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilityTph (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_TPH *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_TPH*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_TPH),
+    gShellDebug1HiiHandle,
+    Header->TphRequesterCapability,
+    Header->TphRequesterControl
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)Header->TphStTable - (UINT8*)HeadersBaseAddress),
+    GET_TPH_TABLE_SIZE(Header),
+    (VOID *)Header->TphStTable
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_TPH) + GET_TPH_TABLE_SIZE(Header) - sizeof(UINT16),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Function to interpret and print out the secondary PCIe capability structure
+  @param[in] HeaderAddress        The Address of this capability header.
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+  @param[in] PciExpressCapPtr     The address of the PCIe capabilities structure.
+**/
+EFI_STATUS
+EFIAPI
+PrintInterpretedExtendedCompatibilitySecondary (
+  IN CONST PCI_EXP_EXT_HDR *HeaderAddress,
+  IN CONST PCI_EXP_EXT_HDR *HeadersBaseAddress,
+  IN CONST PCIE_CAP_STRUCTURE *PciExpressCapPtr
+  )
+{
+  CONST PCI_EXPRESS_EXTENDED_CAPABILITIES_SECONDARY_PCIE *Header;
+  Header = (PCI_EXPRESS_EXTENDED_CAPABILITIES_SECONDARY_PCIE*)HeaderAddress;
+  ShellPrintHiiEx(
+    -1, -1, NULL,
+    STRING_TOKEN (STR_PCI_EXT_CAP_SECONDARY),
+    gShellDebug1HiiHandle,
+    Header->LinkControl3,
+    Header->LaneErrorStatus
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)Header->EqualizationControl - (UINT8*)HeadersBaseAddress),
+    PCIE_CAP_MAX_LINK_WIDTH(PciExpressCapPtr->LinkCap),
+    (VOID *)Header->EqualizationControl
+    );
+  DumpHex (
+,
+    EFI_PCIE_CAPABILITY_BASE_OFFSET + ((UINT8*)HeaderAddress - (UINT8*)HeadersBaseAddress),
+    sizeof(PCI_EXPRESS_EXTENDED_CAPABILITIES_TPH) - sizeof(Header->EqualizationControl) + PCIE_CAP_MAX_LINK_WIDTH(PciExpressCapPtr->LinkCap),
+    (VOID *) (HeaderAddress)
+    );
+  return (EFI_SUCCESS);
+}
+/**
+  Display Pcie extended capability details
+  @param[in] HeadersBaseAddress   The address of all the extended capability headers.
+  @param[in] HeaderAddress        The address of this capability header.
+  @param[in] PciExpressCapPtr     The address of the PCIe capabilities structure.
+**/
+EFI_STATUS
+EFIAPI
+PrintPciExtendedCapabilityDetails(
+  IN CONST PCI_EXP_EXT_HDR    *HeadersBaseAddress,
+  IN CONST PCI_EXP_EXT_HDR    *HeaderAddress,
+  IN CONST PCIE_CAP_STRUCTURE *PciExpressCapPtr
+  )
+{
+  switch (HeaderAddress->CapabilityId){
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_ADVANCED_ERROR_REPORTING_ID:
+      return PrintInterpretedExtendedCompatibilityAer(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_CONTROL_ID:
+      return PrintInterpretedExtendedCompatibilityLinkControl(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_LINK_DECLARATION_ID:
+      return PrintInterpretedExtendedCompatibilityLinkDeclaration(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_SERIAL_NUMBER_ID:
+      return PrintInterpretedExtendedCompatibilitySerialNumber(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_POWER_BUDGETING_ID:
+      return PrintInterpretedExtendedCompatibilityPowerBudgeting(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_ACS_EXTENDED_ID:
+      return PrintInterpretedExtendedCompatibilityAcs(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_LATENCE_TOLERANCE_REPORTING_ID:
+      return PrintInterpretedExtendedCompatibilityLatencyToleranceReporting(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_ARI_CAPABILITY_ID:
+      return PrintInterpretedExtendedCompatibilityAri(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_RCRB_HEADER_ID:
+      return PrintInterpretedExtendedCompatibilityRcrb(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_VENDOR_SPECIFIC_ID:
+      return PrintInterpretedExtendedCompatibilityVendorSpecific(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_DYNAMIC_POWER_ALLOCATION_ID:
+      return PrintInterpretedExtendedCompatibilityDynamicPowerAllocation(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_EVENT_COLLECTOR_ENDPOINT_ASSOCIATION_ID:
+      return PrintInterpretedExtendedCompatibilityECEA(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_VIRTUAL_CHANNEL_ID:
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_MULTI_FUNCTION_VIRTUAL_CHANNEL_ID:
+      return PrintInterpretedExtendedCompatibilityVirtualChannel(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_MULTICAST_ID:
+      //
+      // should only be present if PCIE_CAP_DEVICEPORT_TYPE(PciExpressCapPtr->PcieCapReg) == 0100b, 0101b, or 0110b
+      //
+      return PrintInterpretedExtendedCompatibilityMulticast(HeaderAddress, HeadersBaseAddress, PciExpressCapPtr);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_RESIZABLE_BAR_ID:
+      return PrintInterpretedExtendedCompatibilityResizeableBar(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_TPH_ID:
+      return PrintInterpretedExtendedCompatibilityTph(HeaderAddress, HeadersBaseAddress);
+    case PCI_EXPRESS_EXTENDED_CAPABILITY_SECONDARY_PCIE_ID:
+      return PrintInterpretedExtendedCompatibilitySecondary(HeaderAddress, HeadersBaseAddress, PciExpressCapPtr);
+    default:
+      ShellPrintEx (-1, -1,
+        L"Unknown PCIe extended capability ID (%04xh).  No interpretation available.\r\n",
+        HeaderAddress->CapabilityId
+        );
+      return EFI_SUCCESS;
+  };
+}
 …
   @param[in] Address        The Address to start at.
   @param[in] CapabilityPtr  The offset from the address to start.
+  @param[in] EnhancedDump   The print format for the dump data.
 **/
 EFI_STATUS
 …
   IN  EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL         *IoDev,
   IN  UINT64                                  Address,
+  IN  UINT8                                   CapabilityPtr
+  IN  UINT8                                   CapabilityPtr,
+  IN CONST UINT16                            EnhancedDump
+  )
+{
   PCIE_CAP_STURCTURE  PciExpressCap;
+  PCIE_CAP_STRUCTURE  PciExpressCap;
   EFI_STATUS          Status;
   UINT64              CapRegAddress;
 …
   UINT8               *RegAddr;
   UINTN               RegValue;
+  PCI_EXP_EXT_HDR     *ExtHdr;
   CapRegAddress = Address + CapabilityPtr;
 …
   DevicePortType = (UINT8) PCIE_CAP_DEVICEPORT_TYPE (PciExpressCap.PcieCapReg);
   Print (L"\nPci Express device capability structure:\n");
+  ShellPrintEx (-1, -1, L"\r\nPci Express device capability structure:\r\n");
   for (Index = 0; PcieExplainList[Index].Type < PcieExplainTypeMax; Index++) {
 …
   Func          = (UINT8) (RShiftU64 (Address, 8));
   Pciex_Address = CALC_EFI_PCIEX_ADDRESS (Bus, Dev, Func, 0x100);
   ExtendRegSize = 0x1000 - 0x100;
+  Pciex_Address = CALC_EFI_PCIEX_ADDRESS (Bus, Dev, Func, EFI_PCIE_CAPABILITY_BASE_OFFSET);
+  ExtendRegSize = 0x1000 - EFI_PCIE_CAPABILITY_BASE_OFFSET;
   ExRegBuffer   = (UINT8 *) AllocateZeroPool (ExtendRegSize);
 …
   //
   // PciRootBridgeIo protocol should support pci express extend space IO
   // (Begins at offset 0x100)
+  // (Begins at offset EFI_PCIE_CAPABILITY_BASE_OFFSET)
   //
   Status = IoDev->Pci.Read (
 …
                         (VOID *) (ExRegBuffer)
                        );
   if (EFI_ERROR (Status)) {
     FreePool ((VOID *) ExRegBuffer);
+  if (EFI_ERROR (Status) || ExRegBuffer == NULL) {
+    SHELL_FREE_NON_NULL(ExRegBuffer);
     return EFI_UNSUPPORTED;
+  }
+  //
+  // Start outputing PciEx extend space( 0xFF-0xFFF)
+  //
+  Print (L"\n%HStart dumping PCIex extended configuration space (0x100 - 0xFFF).%N\n\n");
+  if (ExRegBuffer != NULL) {
+  if (EnhancedDump == 0) {
+    //
+    // Print the PciEx extend space in raw bytes ( 0xFF-0xFFF)
+    //
+    ShellPrintEx (-1, -1, L"\r\n%HStart dumping PCIex extended configuration space (0x100 - 0xFFF).%N\r\n\r\n");
     DumpHex (
 ,
 x100,
+      EFI_PCIE_CAPABILITY_BASE_OFFSET,
       ExtendRegSize,
       (VOID *) (ExRegBuffer)
+     );
+    FreePool ((VOID *) ExRegBuffer);
+  }
+      );
+  } else {
+    ExtHdr = (PCI_EXP_EXT_HDR*)ExRegBuffer;
+    while (ExtHdr->CapabilityId != 0 && ExtHdr->CapabilityVersion != 0) {
+      //
+      // Process this item
+      //
+      if (EnhancedDump == 0xFFFF || EnhancedDump == ExtHdr->CapabilityId) {
+        //
+        // Print this item
+        //
+        PrintPciExtendedCapabilityDetails((PCI_EXP_EXT_HDR*)ExRegBuffer, ExtHdr, &PciExpressCap);
+      }
+      //
+      // Advance to the next item if it exists
+      //
+      if (ExtHdr->NextCapabilityOffset != 0) {
+        ExtHdr = (PCI_EXP_EXT_HDR*)((UINT8*)ExRegBuffer + ExtHdr->NextCapabilityOffset);
+      } else {
+        break;
+      }
+    }
+  }
+  SHELL_FREE_NON_NULL(ExRegBuffer);
 Done:

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/Pci.h

-              r48674
+              r58459
   Header file for Pci shell Debug1 function.
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
   Copyright (c) 2005 - 2010, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
 // Link Capabilities Register
 //
 #define PCIE_CAP_SUP_LINK_SPEEDS(PcieLinkCap) \
+#define PCIE_CAP_MAX_LINK_SPEED(PcieLinkCap) \
     ((PcieLinkCap) & 0x0f)
 #define PCIE_CAP_MAX_LINK_WIDTH(PcieLinkCap) \
 …
   UINT16  SlotControl;
   UINT16  SlotStatus;
+  UINT16  RootControl;
   UINT16  RsvdP;
-  UINT16  RootControl;
   UINT32  RootStatus;
 } PCIE_CAP_STURCTURE;
+} PCIE_CAP_STRUCTURE;
 #pragma pack()

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SetVar.c

-              r48674
+              r58459
   Main file for SetVar shell Debug1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   UINTN               LoopVar;
   EFI_DEVICE_PATH_PROTOCOL           *DevPath;
-  EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *DevPathFromText;
   ShellStatus         = SHELL_SUCCESS;
 …
+        }
         if (ShellCommandLineGetFlag(Package, L"-rt")) {
+          Attributes |= EFI_VARIABLE_RUNTIME_ACCESS;
+          Attributes |= EFI_VARIABLE_RUNTIME_ACCESS |
+                        EFI_VARIABLE_BOOTSERVICE_ACCESS;
+        }
         if (ShellCommandLineGetFlag(Package, L"-nv")) {
 …
             Buffer = AllocateZeroPool(Size);
             Status = gRT->GetVariable((CHAR16*)VariableName, &Guid, &Attributes2, &Size, Buffer);
+            FreePool(Buffer);
+            if (Buffer != NULL) {
+              FreePool(Buffer);
+            }
             Attributes = Attributes2;
+          }
 …
           Data++;
           Data++;
+          Status = gBS->LocateProtocol(&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID**)&DevPathFromText);
+          ASSERT_EFI_ERROR(Status);
+          DevPath = DevPathFromText->ConvertTextToDevicePath(Data);
+          DevPath = ConvertTextToDevicePath(Data);
           if (DevPath == NULL) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SETVAR_ERROR_DPFT), gShellDebug1HiiHandle, Status);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/LibSmbiosView.c

-              r48674
+              r58459
   API for SMBIOS table.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "../UefiShellDebug1CommandsLib.h"
 #include <Guid/SmBios.h>
-#include "LibSmbios.h"
 #include "LibSmbiosView.h"
 #include "SmbiosView.h"
 STATIC UINT8                    mInit         = 0;
 STATIC SMBIOS_STRUCTURE_TABLE   *mSmbiosTable = NULL;
+STATIC SMBIOS_TABLE_ENTRY_POINT *mSmbiosTable = NULL;
 STATIC SMBIOS_STRUCTURE_POINTER m_SmbiosStruct;
 STATIC SMBIOS_STRUCTURE_POINTER *mSmbiosStruct = &m_SmbiosStruct;
 …
 VOID
 LibSmbiosGetEPS (
   OUT SMBIOS_STRUCTURE_TABLE **EntryPointStructure
+  OUT SMBIOS_TABLE_ENTRY_POINT **EntryPointStructure
+  )
+{
 …
 /**
+    Get SMBIOS structure given the Handle,copy data to the Buffer,
+  Return SMBIOS string for the given string number.
+  @param[in] Smbios         Pointer to SMBIOS structure.
+  @param[in] StringNumber   String number to return. -1 is used to skip all strings and
+                            point to the next SMBIOS structure.
+  @return Pointer to string, or pointer to next SMBIOS strcuture if StringNumber == -1
+**/
+CHAR8*
+LibGetSmbiosString (
+  IN  SMBIOS_STRUCTURE_POINTER    *Smbios,
+  IN  UINT16                      StringNumber
+  )
+{
+  UINT16  Index;
+  CHAR8   *String;
+  ASSERT (Smbios != NULL);
+  //
+  // Skip over formatted section
+  //
+  String = (CHAR8 *) (Smbios->Raw + Smbios->Hdr->Length);
+  //
+  // Look through unformated section
+  //
+  for (Index = 1; Index <= StringNumber; Index++) {
+    if (StringNumber == Index) {
+      return String;
+    }
+    //
+    // Skip string
+    //
+    for (; *String != 0; String++);
+    String++;
+    if (*String == 0) {
+      //
+      // If double NULL then we are done.
+      //  Return pointer to next structure in Smbios.
+      //  if you pass in a -1 you will always get here
+      //
+      Smbios->Raw = (UINT8 *)++String;
+      return NULL;
+    }
+  }
+  return NULL;
+}
+/**
+    Get SMBIOS structure for the given Handle,
     Handle is changed to the next handle or 0xFFFF when the end is
     reached or the handle is not found.
 …
     @param[in, out] Handle     0xFFFF: get the first structure
                                Others: get a structure according to this value.
+    @param[in, out] Buffer     The pointer to the caller's memory buffer.
+    @param[out] Length         Length of return buffer in bytes.
+    @retval DMI_SUCCESS   Buffer contains the required structure data
+                          Handle is updated with next structure handle or
+    @param[out] Buffer         The pointer to the pointer to the structure.
+    @param[out] Length         Length of the structure.
+    @retval DMI_SUCCESS   Handle is updated with next structure handle or
 xFFFF(end-of-list).
+    @retval DMI_INVALID_HANDLE  Buffer not contain the requiring structure data.
+                                Handle is updated with next structure handle or
+    @retval DMI_INVALID_HANDLE  Handle is updated with first structure handle or
 xFFFF(end-of-list).
 **/
 …
 LibGetSmbiosStructure (
   IN  OUT UINT16  *Handle,
   IN  OUT UINT8   *Buffer,
+  OUT UINT8       **Buffer,
   OUT UINT16      *Length
+  )
 …
   UINT8                     *Raw;
   if (*Handle == INVALIDE_HANDLE) {
+  if (*Handle == INVALID_HANDLE) {
     *Handle = mSmbiosStruct->Hdr->Handle;
     return DMI_INVALID_HANDLE;
+  }
   if (Buffer == NULL) {
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_LIBSMBIOSVIEW_NO_BUFF_SPEC), gShellDebug1HiiHandle);
+  if ((Buffer == NULL) || (Length == NULL)) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_LIBSMBIOSVIEW_NO_BUFF_LEN_SPEC), gShellDebug1HiiHandle);
     return DMI_INVALID_HANDLE;
+  }
 …
       //
       *Length = (UINT16) (Smbios.Raw - Raw);
       CopyMem (Buffer, Raw, *Length);
+      *Buffer = Raw;
       //
       // update with the next structure handle.
 …
         *Handle = Smbios.Hdr->Handle;
       } else {
         *Handle = INVALIDE_HANDLE;
+        *Handle = INVALID_HANDLE;
+      }
       return DMI_SUCCESS;
 …
+  }
   *Handle = INVALIDE_HANDLE;
+  *Handle = INVALID_HANDLE;
   return DMI_INVALID_HANDLE;
+}
-/**
-  Check the structure to see if it is legal.
-  @param[in] Smbios    - Pointer to the structure that will be checked.
-  @retval DMI_SUCCESS           Structure data is legal.
-  @retval DMI_BAD_PARAMETER     Structure data contains bad parameter.
-**/
-EFI_STATUS
-SmbiosCheckStructure (
-  IN  SMBIOS_STRUCTURE_POINTER *Smbios
+  )
+{
-  //
-  // If key != value, then error.
-  //
-#define CHECK_VALUE(key, value) (((key) == (value)) ? EFI_SUCCESS : DMI_BAD_PARAMETER)
-  EFI_STATUS  Status;
-  //
-  // Assume staus is EFI_SUCCESS,
-  // but if check is error, then EFI_ERROR.
-  //
-  Status = EFI_SUCCESS;
-  switch (Smbios->Hdr->Type) {
-  case 0:
-    break;
-  case 1:
-    if (Smbios->Type1->Hdr.Length == 0x08 || Smbios->Type0->Hdr.Length == 0x19) {
-      Status = EFI_SUCCESS;
-    } else {
-      Status = DMI_BAD_PARAMETER;
+    }
-    break;
-  case 2:
-    Status = CHECK_VALUE (Smbios->Type2->Hdr.Length, 0x08);
-    break;
-  case 6:
-    Status = CHECK_VALUE (Smbios->Type6->Hdr.Length, 0x0C);
-    break;
-  case 11:
-    Status = CHECK_VALUE (Smbios->Type11->Hdr.Length, 0x05);
-    break;
-  case 12:
-    Status = CHECK_VALUE (Smbios->Type12->Hdr.Length, 0x05);
-    break;
-  case 13:
-    Status = CHECK_VALUE (Smbios->Type13->Hdr.Length, 0x16);
-    break;
-  case 16:
-    Status = CHECK_VALUE (Smbios->Type16->Hdr.Length, 0x0F);
-    break;
-  case 19:
-    Status = CHECK_VALUE (Smbios->Type19->Hdr.Length, 0x0F);
-    break;
-  case 20:
-    Status = CHECK_VALUE (Smbios->Type20->Hdr.Length, 0x13);
-    break;
-  case 32:
-    //
-    // Because EFI_SUCCESS == 0,
-    // So errors added up is also error.
-    //
-    Status = CHECK_VALUE (Smbios->Type32->Reserved[0], 0x00) +
-      CHECK_VALUE (Smbios->Type32->Reserved[1], 0x00) +
-      CHECK_VALUE (Smbios->Type32->Reserved[2], 0x00) +
-      CHECK_VALUE (Smbios->Type32->Reserved[3], 0x00) +
-      CHECK_VALUE (Smbios->Type32->Reserved[4], 0x00) +
-      CHECK_VALUE (Smbios->Type32->Reserved[5], 0x00);
-    break;
-  default:
-    Status = DMI_BAD_PARAMETER;
+  }
-  return Status;
+}
-/**
-  Get a string from the smbios information.
-  @param[in] Smbios         The pointer to the smbios information.
-  @param[in] StringNumber   The index to the string to get.
-  @param[out] Buffer        The buffer to fill with the string when retrieved.
-**/
-VOID
-SmbiosGetPendingString (
-  IN  SMBIOS_STRUCTURE_POINTER      *Smbios,
-  IN  UINT16                        StringNumber,
-  OUT CHAR8                         *Buffer
+  )
+{
-  CHAR8 *String;
-  if (Buffer == NULL) {
-    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_LIBSMBIOSVIEW_NO_BUF_SPEC_WHEN_STRUCT), gShellDebug1HiiHandle);
-    return ;
+  }
-  //
-  // Get string and copy to buffer.
-  // Caller should provide the buffer.
-  //
-  String = LibGetSmbiosString (Smbios, StringNumber);
-  if (String != NULL) {
-    CopyMem (Buffer, String, AsciiStrLen(String));
-  } else {
-    Buffer = NULL;
+  }
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/LibSmbiosView.h

-              r48674
+              r58459
   API for SMBIOS Plug and Play functions, access to SMBIOS table and structures.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #define _LIB_SMBIOS_VIEW_H_
 #include "LibSmbios.h"
+#include <IndustryStandard/SmBios.h>
 #define DMI_SUCCESS                     0x00
 …
 #define DMI_INVALID_LOCK                0x92
 #define INVALIDE_HANDLE                 (UINT16) (-1)
+#define INVALID_HANDLE                  (UINT16) (-1)
 #define EFI_SMBIOSERR(val)              EFIERR (0x30000 | val)
 …
 VOID
 LibSmbiosGetEPS (
   OUT SMBIOS_STRUCTURE_TABLE **EntryPointStructure
+  OUT SMBIOS_TABLE_ENTRY_POINT **EntryPointStructure
   );
 /**
+    Get SMBIOS structure given the Handle,copy data to the Buffer,
+  Return SMBIOS string for the given string number.
+  @param[in] Smbios         Pointer to SMBIOS structure.
+  @param[in] StringNumber   String number to return. -1 is used to skip all strings and
+                            point to the next SMBIOS structure.
+  @return Pointer to string, or pointer to next SMBIOS strcuture if StringNumber == -1
+**/
+CHAR8*
+LibGetSmbiosString (
+  IN  SMBIOS_STRUCTURE_POINTER    *Smbios,
+  IN  UINT16                      StringNumber
+  );
+/**
+    Get SMBIOS structure for the given Handle,
     Handle is changed to the next handle or 0xFFFF when the end is
     reached or the handle is not found.
 …
     @param[in, out] Handle     0xFFFF: get the first structure
                                Others: get a structure according to this value.
     @param[in, out] Buffer     The pointer to the caller's memory buffer.
     @param[out] Length         Length of return buffer in bytes.
+    @param[out] Buffer         The pointer to the pointer to the structure.
+    @param[out] Length         Length of the structure.
+    @retval DMI_SUCCESS   Buffer contains the required structure data
+                          Handle is updated with next structure handle or
+    @retval DMI_SUCCESS   Handle is updated with next structure handle or
 xFFFF(end-of-list).
+    @retval DMI_INVALID_HANDLE  Buffer not contain the requiring structure data.
+                                Handle is updated with next structure handle or
+    @retval DMI_INVALID_HANDLE  Handle is updated with first structure handle or
 xFFFF(end-of-list).
 **/
 …
 LibGetSmbiosStructure (
   IN  OUT UINT16  *Handle,
   IN  OUT UINT8   *Buffer,
+  OUT UINT8       **Buffer,
   OUT UINT16      *Length
   );
-/**
-  Get a string from the smbios information.
-  @param[in] Smbios         The pointer to the smbios information.
-  @param[in] StringNumber   The index to the string to get.
-  @param[out] Buffer        The buffer to fill with the string when retrieved.
-**/
-VOID
-SmbiosGetPendingString (
-  IN  SMBIOS_STRUCTURE_POINTER      *Smbios,
-  IN  UINT16                        StringNumber,
-  OUT CHAR8                         *Buffer
-  );
-/**
-  Check the structure to see if it is legal.
-  @param[in] Smbios    - Pointer to the structure that will be checked.
-  @retval DMI_SUCCESS           Structure data is legal.
-  @retval DMI_BAD_PARAMETER     Structure data contains bad parameter.
-**/
-EFI_STATUS
-SmbiosCheckStructure (
-  IN  SMBIOS_STRUCTURE_POINTER *Smbios
-  );
 #endif

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.c

-              r48674
+              r58459
   Module for clarifying the content of the smbios structure element information.
+  Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 //
 #define BIT(value, bit) ((value) & ((UINT64) 1) << (bit))
+//
+// Check if above or equal to version
+//
+#define AE_SMBIOS_VERSION(MajorVersion, MinorVersion) \
+  (SmbiosMajorVersion > (MajorVersion) || (SmbiosMajorVersion == (MajorVersion) && SmbiosMinorVersion >= (MinorVersion)))
 //
 …
 #define PRINT_PENDING_STRING(pStruct, type, element) \
   do { \
+    CHAR8 StringBuf[64]; \
+    SetMem (StringBuf, sizeof (StringBuf), 0x00); \
+    SmbiosGetPendingString ((pStruct), (pStruct->type->element), StringBuf); \
+    CHAR8 *StringBuf; \
+    StringBuf = LibGetSmbiosString ((pStruct), (pStruct->type->element)); \
     ShellPrintEx(-1,-1,L"%a",#element); \
     ShellPrintEx(-1,-1,L": %a\n", StringBuf); \
+    ShellPrintEx(-1,-1,L": %a\n", (StringBuf != NULL) ? StringBuf: ""); \
   } while (0);
 #define PRINT_SMBIOS_STRING(pStruct, stringnumber, element) \
   do { \
+    CHAR8 StringBuf[64]; \
+    SetMem (StringBuf, sizeof (StringBuf), 0x00); \
+    SmbiosGetPendingString ((pStruct), (stringnumber), StringBuf); \
+    CHAR8 *StringBuf; \
+    StringBuf = LibGetSmbiosString ((pStruct), (stringnumber)); \
     ShellPrintEx(-1,-1,L"%a",#element); \
     ShellPrintEx(-1,-1,L": %a\n", StringBuf); \
+    ShellPrintEx(-1,-1,L": %a\n", (StringBuf != NULL) ? StringBuf: ""); \
   } while (0);
 …
     ShellPrintEx(-1,-1,L"%a",#element); \
     ShellPrintEx(-1,-1,L": 0x%x\n", (pStruct->type->element)); \
+  } while (0);
+#define PRINT_STRUCT_VALUE_LH(pStruct, type, element) \
+  do { \
+    ShellPrintEx(-1,-1,L"%a",#element); \
+    ShellPrintEx(-1,-1,L": 0x%lx\n", (pStruct->type->element)); \
   } while (0);
 …
 VOID
 SmbiosPrintEPSInfo (
   IN  SMBIOS_STRUCTURE_TABLE  *SmbiosTable,
   IN  UINT8                   Option
+  IN  SMBIOS_TABLE_ENTRY_POINT  *SmbiosTable,
+  IN  UINT8                     Option
+  )
+{
 …
   UINT8 *Buffer;
-  Buffer = (UINT8 *) (UINTN) (Struct->Raw);
   if (Struct == NULL) {
     return EFI_INVALID_PARAMETER;
 …
     return EFI_SUCCESS;
+  }
+  Buffer = (UINT8 *) (UINTN) (Struct->Raw);
   //
   // Display structure header
 …
   switch (Struct->Hdr->Type) {
   //
   //
+  // BIOS Information (Type 0)
   //
   case 0:
 …
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIOS_SIZE), gShellDebug1HiiHandle, 64 * (Struct->Type0->BiosSize + 1));
+    if (Option < SHOW_DETAIL) {
+      PRINT_STRUCT_VALUE_H (Struct, Type0, BiosCharacteristics);
+    } else {
+      DisplayBiosCharacteristics (Struct->Type0->BiosCharacteristics, Option);
+      //
+      // The length of above format part is 0x12 bytes,
+      // Ext bytes are following, size = 'len-0x12'.
+      // If len-0x12 > 0, then
+      //    there are extension bytes (Byte1, byte2, byte3...)
+      // And byte3 not stated in spec, so dump all extension bytes(1, 2, 3..)
+      //
+      if ((Buffer[1] - (CHAR8) 0x12) > 0) {
+        DisplayBiosCharacteristicsExt1 (Buffer[0x12], Option);
+      }
+      if ((Buffer[1] - (CHAR8) 0x12) > 1) {
+        DisplayBiosCharacteristicsExt2 (Buffer[0x13], Option);
+      }
+      if ((Buffer[1] - (CHAR8) 0x12) > 2) {
+        PRINT_BIT_FIELD (
+          Struct,
+          Type0,
+          BiosCharacteristics,
+          Buffer[1] - (CHAR8) 0x12
+         );
+      }
+    }
+    DisplayBiosCharacteristics (ReadUnaligned64 ((UINT64 *) (UINTN) &(Struct->Type0->BiosCharacteristics)), Option);
+    if (Struct->Hdr->Length > 0x12) {
+      DisplayBiosCharacteristicsExt1 (Struct->Type0->BIOSCharacteristicsExtensionBytes[0], Option);
+    }
+    if (Struct->Hdr->Length > 0x13) {
+      DisplayBiosCharacteristicsExt2 (Struct->Type0->BIOSCharacteristicsExtensionBytes[1], Option);
+    }
+    if (AE_SMBIOS_VERSION (0x2, 0x4) && (Struct->Hdr->Length > 0x14)) {
+      PRINT_STRUCT_VALUE (Struct, Type0, SystemBiosMajorRelease);
+      PRINT_STRUCT_VALUE (Struct, Type0, SystemBiosMinorRelease);
+      PRINT_STRUCT_VALUE (Struct, Type0, EmbeddedControllerFirmwareMajorRelease);
+      PRINT_STRUCT_VALUE (Struct, Type0, EmbeddedControllerFirmwareMinorRelease);
+    }
     break;
 …
     PRINT_BIT_FIELD (Struct, Type1, Uuid, 16);
     DisplaySystemWakeupType (Struct->Type1->WakeUpType, Option);
+    break;
+    if (AE_SMBIOS_VERSION (0x2, 0x4) && (Struct->Hdr->Length > 0x19)) {
+      PRINT_PENDING_STRING (Struct, Type1, SKUNumber);
+      PRINT_PENDING_STRING (Struct, Type1, Family);
+    }
+    break;
+  //
+  // Baseboard Information (Type 2)
+  //
   case 2:
     PRINT_PENDING_STRING (Struct, Type2, Manufacturer);
 …
     PRINT_PENDING_STRING (Struct, Type2, Version);
     PRINT_PENDING_STRING (Struct, Type2, SerialNumber);
+    if (Struct->Hdr->Length > 0x8) {
+      PRINT_PENDING_STRING (Struct, Type2, AssetTag);
+      DisplayBaseBoardFeatureFlags (*(UINT8 *) &Struct->Type2->FeatureFlag, Option);
+      PRINT_PENDING_STRING (Struct, Type2, LocationInChassis);
+      PRINT_STRUCT_VALUE_H (Struct, Type2, ChassisHandle);
+      DisplayBaseBoardBoardType (Struct->Type2->BoardType, Option);
+    }
     break;
 …
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SECURITY_STATUS), gShellDebug1HiiHandle);
     DisplaySESecurityStatus (Struct->Type3->SecurityStatus, Option);
+    PRINT_BIT_FIELD (Struct, Type3, OemDefined, 4);
+    if (AE_SMBIOS_VERSION (0x2, 0x3) && (Struct->Hdr->Length > 0xD)) {
+      PRINT_BIT_FIELD (Struct, Type3, OemDefined, 4);
+    }
     break;
 …
     PRINT_PENDING_STRING (Struct, Type4, Socket);
     DisplayProcessorType (Struct->Type4->ProcessorType, Option);
     if ((SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) &&
+    if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0x28) &&
         (Struct->Type4->ProcessorFamily == 0xFE)) {
       //
 …
     PRINT_BIT_FIELD (Struct, Type4, ProcessorId, 8);
     PRINT_PENDING_STRING (Struct, Type4, ProcessorVersion);
     DisplayProcessorVoltage (Struct->Type4->Voltage, Option);
+    DisplayProcessorVoltage (*(UINT8 *) &(Struct->Type4->Voltage), Option);
     PRINT_STRUCT_VALUE (Struct, Type4, ExternalClock);
     PRINT_STRUCT_VALUE (Struct, Type4, MaxSpeed);
 …
     PRINT_STRUCT_VALUE_H (Struct, Type4, L2CacheHandle);
     PRINT_STRUCT_VALUE_H (Struct, Type4, L3CacheHandle);
+    PRINT_PENDING_STRING (Struct, Type4, SerialNumber);
+    PRINT_PENDING_STRING (Struct, Type4, AssetTag);
+    PRINT_PENDING_STRING (Struct, Type4, PartNumber);
+    if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x5)) {
+    if (AE_SMBIOS_VERSION (0x2, 0x3) && (Struct->Hdr->Length > 0x20)) {
+      PRINT_PENDING_STRING (Struct, Type4, SerialNumber);
+      PRINT_PENDING_STRING (Struct, Type4, AssetTag);
+      PRINT_PENDING_STRING (Struct, Type4, PartNumber);
+    }
+    if (AE_SMBIOS_VERSION (0x2, 0x5) && (Struct->Hdr->Length > 0x23)) {
       PRINT_STRUCT_VALUE (Struct, Type4, CoreCount);
       PRINT_STRUCT_VALUE (Struct, Type4, EnabledCoreCount);
       PRINT_STRUCT_VALUE (Struct, Type4, ThreadCount);
+      PRINT_STRUCT_VALUE_H (Struct, Type4, ProcessorCharacteristics);
+      DisplayProcessorCharacteristics (Struct->Type4->ProcessorCharacteristics, Option);
+    }
+    if ((SmbiosMajorVersion >= 0x3) && (Struct->Hdr->Length > 0x2A)) {
+      PRINT_STRUCT_VALUE (Struct, Type4, CoreCount2);
+      PRINT_STRUCT_VALUE (Struct, Type4, EnabledCoreCount2);
+      PRINT_STRUCT_VALUE (Struct, Type4, ThreadCount2);
+    }
     break;
 …
       DisplayMcErrorDetectMethod (Struct->Type5->ErrDetectMethod, Option);
       DisplayMcErrorCorrectCapability (Struct->Type5->ErrCorrectCapability, Option);
+      DisplayMcErrorCorrectCapability (*(UINT8 *) &(Struct->Type5->ErrCorrectCapability), Option);
       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SUPOPRT), gShellDebug1HiiHandle);
       DisplayMcInterleaveSupport (Struct->Type5->SupportInterleave, Option);
 …
       DisplayMcInterleaveSupport (Struct->Type5->CurrentInterleave, Option);
       DisplayMaxMemoryModuleSize (Struct->Type5->MaxMemoryModuleSize, SlotNum, Option);
       DisplayMcMemorySpeeds (Struct->Type5->SupportSpeed, Option);
+      DisplayMcMemorySpeeds (*(UINT16 *) &(Struct->Type5->SupportSpeed), Option);
       DisplayMmMemoryType (Struct->Type5->SupportMemoryType, Option);
       DisplayMemoryModuleVoltage (Struct->Type5->MemoryModuleVoltage, Option);
 …
     DisplayMmBankConnections (Struct->Type6->BankConnections, Option);
     PRINT_STRUCT_VALUE (Struct, Type6, CurrentSpeed);
     DisplayMmMemoryType (Struct->Type6->CurrentMemoryType, Option);
+    DisplayMmMemoryType (*(UINT16 *) &(Struct->Type6->CurrentMemoryType), Option);
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INSTALLED), gShellDebug1HiiHandle);
     DisplayMmMemorySize (Struct->Type6->InstalledSize, Option);
+    DisplayMmMemorySize (*(UINT8 *) &(Struct->Type6->InstalledSize), Option);
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED), gShellDebug1HiiHandle);
     DisplayMmMemorySize (Struct->Type6->EnabledSize, Option);
+    DisplayMmMemorySize (*(UINT8 *) &(Struct->Type6->EnabledSize), Option);
     DisplayMmErrorStatus (Struct->Type6->ErrorStatus, Option);
     break;
 …
   case 7:
     PRINT_PENDING_STRING (Struct, Type7, SocketDesignation);
     PRINT_STRUCT_VALUE_H (Struct, Type7, CacheConfiguration);
+    DisplayCacheConfiguration (Struct->Type7->CacheConfiguration, Option);
     PRINT_STRUCT_VALUE_H (Struct, Type7, MaximumCacheSize);
     PRINT_STRUCT_VALUE_H (Struct, Type7, InstalledSize);
     PRINT_STRUCT_VALUE_H (Struct, Type7, SupportedSRAMType);
     PRINT_STRUCT_VALUE_H (Struct, Type7, CurrentSRAMType);
     DisplayCacheSRAMType (Struct->Type7->CurrentSRAMType, Option);
+    DisplayCacheSRAMType (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type7->CurrentSRAMType)), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type7, CacheSpeed);
     DisplayCacheErrCorrectingType (Struct->Type7->ErrorCorrectionType, Option);
 …
       Option
      );
     DisplaySlotCharacteristics1 (Struct->Type9->SlotCharacteristics1, Option);
     DisplaySlotCharacteristics2 (Struct->Type9->SlotCharacteristics2, Option);
     if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) {
+    DisplaySlotCharacteristics1 (*(UINT8 *) &(Struct->Type9->SlotCharacteristics1), Option);
+    DisplaySlotCharacteristics2 (*(UINT8 *) &(Struct->Type9->SlotCharacteristics2), Option);
+    if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0xD)) {
       PRINT_STRUCT_VALUE_H (Struct, Type9, SegmentGroupNum);
       PRINT_STRUCT_VALUE_H (Struct, Type9, BusNum);
 …
+    {
       UINTN NumOfDevice;
       NumOfDevice = (Struct->Type10->Hdr.Length - sizeof (SMBIOS_HEADER)) / (2 * sizeof (UINT8));
+      NumOfDevice = (Struct->Type10->Hdr.Length - sizeof (SMBIOS_STRUCTURE)) / (2 * sizeof (UINT8));
       for (Index = 0; Index < NumOfDevice; Index++) {
         DisplayOnboardDeviceTypes (Struct->Type10->Device[Index].DeviceType, Option);
         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DESC_STRING), gShellDebug1HiiHandle);
         ShellPrintEx(-1,-1,L"%a",LibGetSmbiosString (Struct, Struct->Type10->Device[Index].DescriptionString));
+        ShellPrintEx(-1,-1,L"%a\n",LibGetSmbiosString (Struct, Struct->Type10->Device[Index].DescriptionString));
+      }
+    }
     break;
+  //
+  // Oem Strings (Type 11)
+  //
   case 11:
     PRINT_STRUCT_VALUE (Struct, Type11, StringCount);
 …
     break;
+  //
+  // System Configuration Options (Type 12)
+  //
   case 12:
     PRINT_STRUCT_VALUE (Struct, Type12, StringCount);
 …
     break;
+  //
+  // BIOS Language Information (Type 13)
+  //
   case 13:
     PRINT_STRUCT_VALUE (Struct, Type13, InstallableLanguages);
 …
     break;
+  //
+  // Group Associations (Type 14)
+  //
   case 14:
+    PRINT_PENDING_STRING (Struct, Type14, GroupName);
+    PRINT_STRUCT_VALUE (Struct, Type14, ItemType);
+    PRINT_STRUCT_VALUE (Struct, Type14, ItemHandle);
+    {
+      UINT8 NumOfItem;
+      NumOfItem = (Struct->Type14->Hdr.Length - 5) / 3;
+      PRINT_PENDING_STRING (Struct, Type14, GroupName);
+      for (Index = 0; Index < NumOfItem; Index++) {
+        ShellPrintEx(-1,-1,L"ItemType %d: %d\n", Index + 1, Struct->Type14->Group[Index].ItemType);
+        ShellPrintEx(-1,-1,L"ItemHandle %d: %d\n", Index + 1, Struct->Type14->Group[Index].ItemHandle);
+      }
+    }
     break;
 …
   case 15:
+    {
       EVENTLOGTYPE  *Ptr;
       UINT8         Count;
       UINT8         *AccessMethodAddress;
+      EVENT_LOG_TYPE  *Ptr;
+      UINT8           Count;
+      UINT8           *AccessMethodAddress;
       PRINT_STRUCT_VALUE_H (Struct, Type15, LogAreaLength);
 …
             (UINT16)
+            (
             Struct->Type15->LogAreaLength -
             (Struct->Type15->LogDataStartOffset - Struct->Type15->LogDataStartOffset)
+           )
+              Struct->Type15->LogAreaLength -
+              (Struct->Type15->LogDataStartOffset - Struct->Type15->LogHeaderStartOffset)
+            )
            );
+        }
 …
     PRINT_STRUCT_VALUE_H (Struct, Type16, MemoryErrorInformationHandle);
     PRINT_STRUCT_VALUE_H (Struct, Type16, NumberOfMemoryDevices);
+    if (AE_SMBIOS_VERSION (0x2, 0x7) && Struct->Hdr->Length > 0xF) {
+      PRINT_STRUCT_VALUE_LH (Struct, Type16, ExtendedMaximumCapacity);
+    }
     break;
 …
     PRINT_PENDING_STRING (Struct, Type17, BankLocator);
     DisplayMemoryDeviceType (Struct->Type17->MemoryType, Option);
     DisplayMemoryDeviceTypeDetail (Struct->Type17->TypeDetail, Option);
+    DisplayMemoryDeviceTypeDetail (ReadUnaligned16 ((UINT16 *) (UINTN) &(Struct->Type17->TypeDetail)), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type17, Speed);
     PRINT_PENDING_STRING (Struct, Type17, Manufacturer);
 …
     PRINT_PENDING_STRING (Struct, Type17, AssetTag);
     PRINT_PENDING_STRING (Struct, Type17, PartNumber);
     if (SmbiosMajorVersion > 0x2 || (SmbiosMajorVersion == 0x2 && SmbiosMinorVersion >= 0x6)) {
+    if (AE_SMBIOS_VERSION (0x2, 0x6) && (Struct->Hdr->Length > 0x1B)) {
       PRINT_STRUCT_VALUE_H (Struct, Type17, Attributes);
+    }
+    if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0x1C)) {
+      PRINT_STRUCT_VALUE (Struct, Type17, ExtendedSize);
+      PRINT_STRUCT_VALUE (Struct, Type17, ConfiguredMemoryClockSpeed);
+    }
     break;
 …
     PRINT_STRUCT_VALUE_H (Struct, Type19, MemoryArrayHandle);
     PRINT_STRUCT_VALUE_H (Struct, Type19, PartitionWidth);
+    break;
+  //
+  // Memory Device Mapped Address  (Type 20)
+    if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0xF)) {
+      PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedStartingAddress);
+      PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedEndingAddress);
+    }
+    break;
+  //
+  // Memory Device Mapped Address (Type 20)
   //
   case 20:
 …
     PRINT_STRUCT_VALUE_H (Struct, Type20, InterleavePosition);
     PRINT_STRUCT_VALUE_H (Struct, Type20, InterleavedDataDepth);
+    break;
+  //
+  // Built-in Pointing Device  (Type 21)
+    if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0x13)) {
+      PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedStartingAddress);
+      PRINT_STRUCT_VALUE_LH (Struct, Type19, ExtendedEndingAddress);
+    }
+    break;
+  //
+  // Built-in Pointing Device (Type 21)
   //
   case 21:
 …
   //
   // Portable Battery  (Type 22)
+  // Portable Battery (Type 22)
   //
   case 22:
 …
     break;
+  //
+  // System Reset (Type 23)
+  //
   case 23:
     DisplaySystemResetCapabilities (
 …
     break;
+  //
+  // Hardware Security (Type 24)
+  //
   case 24:
     DisplayHardwareSecuritySettings (
 …
     break;
+  //
+  // System Power Controls (Type 25)
+  //
   case 25:
     PRINT_STRUCT_VALUE_H (Struct, Type25, NextScheduledPowerOnMonth);
 …
     break;
+  //
+  // Voltage Probe (Type 26)
+  //
   case 26:
     PRINT_PENDING_STRING (Struct, Type26, Description);
     DisplayVPLocation (Struct->Type26->LocationAndStatus, Option);
     DisplayVPStatus (Struct->Type26->LocationAndStatus, Option);
+    DisplayVPLocation (*(UINT8 *) &(Struct->Type26->LocationAndStatus), Option);
+    DisplayVPStatus (*(UINT8 *) &(Struct->Type26->LocationAndStatus), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type26, MaximumValue);
     PRINT_STRUCT_VALUE_H (Struct, Type26, MinimumValue);
 …
     break;
+  //
+  // Cooling Device (Type 27)
+  //
   case 27:
     PRINT_STRUCT_VALUE_H (Struct, Type27, TemperatureProbeHandle);
     DisplayCoolingDeviceStatus (Struct->Type27->DeviceTypeAndStatus, Option);
     DisplayCoolingDeviceType (Struct->Type27->DeviceTypeAndStatus, Option);
+    DisplayCoolingDeviceStatus (*(UINT8 *) &(Struct->Type27->DeviceTypeAndStatus), Option);
+    DisplayCoolingDeviceType (*(UINT8 *) &(Struct->Type27->DeviceTypeAndStatus), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type27, CoolingUnitGroup);
     PRINT_STRUCT_VALUE_H (Struct, Type27, OEMDefined);
     PRINT_STRUCT_VALUE_H (Struct, Type27, NominalSpeed);
+    break;
+    if (AE_SMBIOS_VERSION (0x2, 0x7) && (Struct->Hdr->Length > 0xE)) {
+      PRINT_PENDING_STRING (Struct, Type27, Description);
+    }
+    break;
+  //
+  // Temperature Probe (Type 28)
+  //
   case 28:
     PRINT_PENDING_STRING (Struct, Type28, Description);
     DisplayTemperatureProbeStatus (Struct->Type28->LocationAndStatus, Option);
     DisplayTemperatureProbeLoc (Struct->Type28->LocationAndStatus, Option);
+    DisplayTemperatureProbeStatus (*(UINT8 *) &(Struct->Type28->LocationAndStatus), Option);
+    DisplayTemperatureProbeLoc (*(UINT8 *) &(Struct->Type28->LocationAndStatus), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type28, MaximumValue);
     PRINT_STRUCT_VALUE_H (Struct, Type28, MinimumValue);
 …
     break;
+  //
+  // Electrical Current Probe (Type 29)
+  //
   case 29:
     PRINT_PENDING_STRING (Struct, Type29, Description);
     DisplayECPStatus (Struct->Type29->LocationAndStatus, Option);
     DisplayECPLoc (Struct->Type29->LocationAndStatus, Option);
+    DisplayECPStatus (*(UINT8 *) &(Struct->Type29->LocationAndStatus), Option);
+    DisplayECPLoc (*(UINT8 *) &(Struct->Type29->LocationAndStatus), Option);
     PRINT_STRUCT_VALUE_H (Struct, Type29, MaximumValue);
     PRINT_STRUCT_VALUE_H (Struct, Type29, MinimumValue);
 …
     break;
+  //
+  // Out-of-Band Remote Access (Type 30)
+  //
   case 30:
     PRINT_PENDING_STRING (Struct, Type30, ManufacturerName);
 …
     break;
+  //
+  // Boot Integrity Services (BIS) Entry Point (Type 31)
+  //
   case 31:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_STRUCT_TYPE31), gShellDebug1HiiHandle);
     break;
+  //
+  // System Boot Information (Type 32)
+  //
   case 32:
     PRINT_BIT_FIELD (Struct, Type32, Reserved, 6);
+    DisplaySystemBootStatus (Struct->Type32->BootStatus[0], Option);
+    break;
+    DisplaySystemBootStatus (Struct->Type32->BootStatus, Option);
+    break;
+  //
+  // 64-Bit Memory Error Information (Type 33)
+  //
   case 33:
     DisplayMemoryErrorType (Struct->Type33->ErrorType, Option);
 …
     DisplayMemoryErrorOperation (Struct->Type33->ErrorOperation, Option);
     PRINT_STRUCT_VALUE_H (Struct, Type33, VendorSyndrome);
     PRINT_STRUCT_VALUE_H (Struct, Type33, MemoryArrayErrorAddress);
     PRINT_STRUCT_VALUE_H (Struct, Type33, DeviceErrorAddress);
+    PRINT_STRUCT_VALUE_LH (Struct, Type33, MemoryArrayErrorAddress);
+    PRINT_STRUCT_VALUE_LH (Struct, Type33, DeviceErrorAddress);
     PRINT_STRUCT_VALUE_H (Struct, Type33, ErrorResolution);
     break;
   //
   // Management Device  (Type 34)
+  // Management Device (Type 34)
   //
   case 34:
 …
     DisplayMDType (Struct->Type34->Type, Option);
     PRINT_STRUCT_VALUE_H (Struct, Type34, Address);
+    PRINT_STRUCT_VALUE_H (Struct, Type34, AddressType);
+    break;
+    DisplayMDAddressType (Struct->Type34->AddressType, Option);
+    break;
+  //
+  // Management Device Component (Type 35)
+  //
   case 35:
     PRINT_PENDING_STRING (Struct, Type35, Description);
 …
     break;
+  //
+  // Management Device Threshold Data (Type 36)
+  //
   case 36:
     PRINT_STRUCT_VALUE_H (Struct, Type36, LowerThresholdNonCritical);
 …
   //
   // Memory Channel  (Type 37)
+  // Memory Channel (Type 37)
   //
   case 37:
+    {
       UINT8         Count;
       MEMORYDEVICE  *Ptr;
+      UINT8          Count;
+      MEMORY_DEVICE  *Ptr;
       DisplayMemoryChannelType (Struct->Type37->ChannelType, Option);
       PRINT_STRUCT_VALUE_H (Struct, Type37, MaximumChannelLoad);
 …
       for (Index = 0; Index < Count; Index++) {
         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MEM_DEVICE), gShellDebug1HiiHandle, Index + 1);
         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_LOAD), gShellDebug1HiiHandle, Ptr->DeviceLoad);
         ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_HANDLE), gShellDebug1HiiHandle, Ptr->DeviceHandle);
+        ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_LOAD), gShellDebug1HiiHandle, Ptr[Index].DeviceLoad);
+        ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DEV_HANDLE), gShellDebug1HiiHandle, Ptr[Index].DeviceHandle);
+      }
+    }
 …
   //
   // IPMI Device Information  (Type 38)
+  // IPMI Device Information (Type 38)
   //
   case 38:
 …
     PRINT_STRUCT_VALUE_H (Struct, Type38, I2CSlaveAddress);
     PRINT_STRUCT_VALUE_H (Struct, Type38, NVStorageDeviceAddress);
     PRINT_STRUCT_VALUE_H (Struct, Type38, BaseAddress);
+    PRINT_STRUCT_VALUE_LH (Struct, Type38, BaseAddress);
     break;
 …
     PRINT_STRUCT_VALUE_H (Struct, Type39, MaxPowerCapacity);
     DisplaySPSCharacteristics (
       Struct->Type39->PowerSupplyCharacteristics,
+      *(UINT16 *) &(Struct->Type39->PowerSupplyCharacteristics),
       Option
      );
 …
   case 41:
     PRINT_PENDING_STRING (Struct, Type41, ReferenceDesignation);
+    PRINT_STRUCT_VALUE_H (Struct, Type41, DeviceType);
+    ShellPrintEx(-1,-1,(((Struct->Type41->DeviceType) & 0x80) != 0) ? L"Device Enabled\n": L"Device Disabled\n");
+    DisplayOnboardDeviceTypes ((Struct->Type41->DeviceType) & 0x7F, Option);
     PRINT_STRUCT_VALUE_H (Struct, Type41, DeviceTypeInstance);
     PRINT_STRUCT_VALUE_H (Struct, Type41, SegmentGroupNum);
 …
     break;
+  //
+  // Management Controller Host Interface (Type 42)
+  //
+  case 42:
+    PRINT_STRUCT_VALUE_H (Struct, Type42, InterfaceType);
+    break;
+  //
+  // Inactive (Type 126)
+  //
   case 126:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INACTIVE_STRUCT), gShellDebug1HiiHandle);
     break;
+  //
+  // End-of-Table (Type 127)
+  //
   case 127:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_THIS_STRUCT_END_TABLE), gShellDebug1HiiHandle);
 …
+  }
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle);
+  if (AE_SMBIOS_VERSION (0x2, 0x4)) {
+    if (BIT (byte2, 2) != 0) {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLE_TAR_CONT_DIST), gShellDebug1HiiHandle);
+    }
+    if (AE_SMBIOS_VERSION (0x2, 0x7)) {
+      if (BIT (byte2, 3) != 0) {
+        ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UEFI_SPEC_SUPPORT), gShellDebug1HiiHandle);
+      }
+      if (BIT (byte2, 4) != 0) {
+        ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VIRTUAL_MACHINE), gShellDebug1HiiHandle);
+      }
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 5);
+    } else {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 3);
+    }
+  } else {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BITS_RSVD_FOR_FUTURE), gShellDebug1HiiHandle, 2);
+  }
+}
 …
     break;
+  case 0x13:
+    Print (L"M2 Family\n");
+    break;
+  case 0x14:
+    Print (L"Intel Celeron M\n");
+    break;
+  case 0x15:
+    Print (L"Intel Pentium 4 HT\n");
+    break;
   case 0x18:
     Print (L"AMD Duron\n");
 …
     break;
+  case 0x1A:
+    Print (L"K6 Family\n");
+    break;
+  case 0x1B:
+    Print (L"K6-2\n");
+    break;
+  case 0x1C:
+    Print (L"K6-3\n");
+    break;
+  case 0x1D:
+    Print (L"AMD Althon Processor Family\n");
+    break;
+  case 0x1E:
+    Print (L"AMD 29000 Family\n");
+    break;
+  case 0x1F:
+    Print (L"K6-2+\n");
+    break;
   case 0x20:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_POWER_PC_FAMILY), gShellDebug1HiiHandle);
 …
     break;
+  case 0x38:
+    Print (L"AMD Turion II Ultra Dual-Core Mobile M Processor Family\n");
+    break;
+  case 0x39:
+    Print (L"AMD Turion II Dual-Core Mobile M Processor Family\n");
+    break;
+  case 0x3A:
+    Print (L"AMD Althon II Dual-Core M Processor Family\n");
+    break;
+  case 0x3B:
+    Print (L"AMD Opteron 6100 Series Processor\n");
+    break;
+  case 0x3C:
+    Print (L"AMD Opteron 4100 Series Processor\n");
+    break;
+  case 0x3D:
+    Print (L"AMD Opteron 6200 Series Processor\n");
+    break;
+  case 0x3E:
+    Print (L"AMD Opteron 4200 Series Processor\n");
+    break;
+  case 0x3F:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_FX_SERIES), gShellDebug1HiiHandle);
+    break;
   case 0x40:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MIPS_FAMILY), gShellDebug1HiiHandle);
 …
     break;
+  case 0x46:
+    Print (L"AMD C-Series Processor\n");
+    break;
+  case 0x47:
+    Print (L"AMD E-Series Processor\n");
+    break;
+  case 0x48:
+    Print (L"AMD A-Series Processor\n");
+    break;
+  case 0x49:
+    Print (L"AMD G-Series Processor\n");
+    break;
+  case 0x4A:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_Z_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0x4B:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_R_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0x4C:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_4300_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0x4D:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_6300_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0x4E:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_3300_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0x4F:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_FIREPRO_SERIES), gShellDebug1HiiHandle);
+    break;
   case 0x50:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_SPARC_FAMILY), gShellDebug1HiiHandle);
 …
     break;
+  case 0x91:
+    Print (L"PA-RISC 8500\n");
+    break;
+  case 0x92:
+    Print (L"PA-RISC 8000\n");
+    break;
+  case 0x93:
+    Print (L"PA-RISC 7300LC\n");
+    break;
+  case 0x94:
+    Print (L"PA-RISC 7200\n");
+    break;
+  case 0x95:
+    Print (L"PA-RISC 7100LC\n");
+    break;
+  case 0x96:
+    Print (L"PA-RISC 7100\n");
+    break;
   case 0xA0:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_V30_FAMILY), gShellDebug1HiiHandle);
 …
     break;
+  case 0xB1:
+    Print (L"Pentium III Processorwith Intel SpeedStep Technology\n");
+    break;
+  case 0xB2:
+    Print (L"Pentium 4 processor\n");
+    break;
+  case 0xB3:
+    Print (L"Intel Xeon Processor\n");
+    break;
+  case 0xB4:
+    Print (L"AS400 Family\n");
+    break;
+  case 0xB5:
+    Print (L"Intel Xeon processor MP\n");
+    break;
+  case 0xB6:
+    Print (L"AMD Althon XP Processor Family\n");
+    break;
+  case 0xB7:
+    Print (L"AMD Althon MP Promcessor Family\n");
+    break;
+  case 0xB8:
+    Print (L"Intel Itanium 2 processor\n");
+    break;
+  case 0xB9:
+    Print (L"Intel Penium M processor\n");
+    break;
+  case 0xBA:
+    Print (L"Intel Celeron D processor\n");
+    break;
+  case 0xBB:
+    Print (L"Intel Pentium D processor\n");
+    break;
+  case 0xBC:
+    Print (L"Intel Pentium Processor Extreme Edition\n");
+    break;
+  case 0xBD:
+    Print (L"Intel Core Solo Processor\n");
+    break;
+  case 0xBF:
+    Print (L"Intel Core 2 Duo Processor\n");
+    break;
   case 0xC0:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_INTEL_CORE2_SOLO), gShellDebug1HiiHandle);
 …
   case 0xCC:
+    Print (L"zArchitectur\n");
+    Print (L"zArchitecture\n");
+    break;
+  case 0xCD:
+    Print (L"Intel Core i5 processor\n");
+    break;
+  case 0xCE:
+    Print (L"Intel Core i3 processor\n");
     break;
 …
     break;
+  case 0xE0:
+    Print (L"Multi-Core Intel Xeon processor 3400 Series\n");
+    break;
+  case 0xE4:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_OPTERON_3000_SERIES), gShellDebug1HiiHandle);
+    break;
+  case 0xE5:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_SEMPRON_II), gShellDebug1HiiHandle);
+    break;
   case 0xE6:
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_AMD_EMBEDDED_OPTERON_QUAD_CORE), gShellDebug1HiiHandle);
 …
     break;
+  case 0xEC:
+    Print (L"AMD Phenom II Processor Family\n");
+    break;
+  case 0xED:
+    Print (L"AMD Althon II Processor Family\n");
+    break;
+  case 0xEE:
+    Print (L"Six-Core AMD Opteron Processor Family\n");
+    break;
+  case 0xEF:
+    Print (L"AMD Sempron M Processor Family\n");
+    break;
   case 0xFA:
     Print (L"i860\n");
 …
   default:
+    //
+    // In order to reduce code quality notice of
+    // case & break not pair, so
+    // move multiple case into the else part and
+    // use if/else to check value.
+    //
+    if (Family >= 0x13 && Family <= 0x17) {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_M1), gShellDebug1HiiHandle);
+    } else if (Family >= 0x1A && Family <= 0x1F) {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_K5), gShellDebug1HiiHandle);
+    } else if (Family >= 0xB1 && Family <= 0xBF) {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RSVD_FOR_SPEC_PENTIUM), gShellDebug1HiiHandle);
+    } else {
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), gShellDebug1HiiHandle);
+    }
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNDEFINED_PROC_FAMILY), gShellDebug1HiiHandle);
+  }
   //
 …
   @param[in] Status   The status.
 Bit 7 Reserved, must be 0
 Bit 6   CPU Socket Populated
 - CPU Socket Populated
 - CPU Socket UnpopulatedBits
 :3  Reserved, must be zero
  Bits 2:0 CPU Status
+Bit 6 CPU Socket Populated
+- CPU Socket Populated
+- CPU Socket Unpopulated
+Bits 5:3 Reserved, must be zero
+Bits 2:0 CPU Status
 h - Unknown
 h - CPU Enabled
 …
   if (BIT (Status, 7) != 0) {
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT7), gShellDebug1HiiHandle);
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT7_NOT_ZERO), gShellDebug1HiiHandle);
   } else if (BIT (Status, 5) != 0) {
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT5), gShellDebug1HiiHandle);
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT5_NOT_ZERO), gShellDebug1HiiHandle);
   } else if (BIT (Status, 4) != 0) {
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT4), gShellDebug1HiiHandle);
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), gShellDebug1HiiHandle);
   } else if (BIT (Status, 3) != 0) {
     ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ERROR_BIT3), gShellDebug1HiiHandle);
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT3_NOT_ZERO), gShellDebug1HiiHandle);
+  }
   //
 …
 /**
+  Display Cache Configuration.
+  @param[in] CacheConfiguration   Cache Configuration.
+Bits 15:10 Reserved, must be 0
+Bits 9:8 Operational Mode
+h - Write Through
+h - Write Back
+h - Varies with Memory Address
+h - Unknown
+Bit 7 Enabled/Disabled
+- Enabled
+- Disabled
+Bits 6:5 Location
+h - Internal
+h - External
+h - Reserved
+h - Unknown
+Bit 4 Reserved, must be zero
+Bit 3 Cache Socketed
+- Socketed
+- Unsocketed
+Bits 2:0 Cache Level
+through 8 (For example, an L1 cache would
+  use value 000b and an L3 cache would use 010b.)
+  @param[in] Option   The option
+**/
+VOID
+DisplayCacheConfiguration (
+  IN UINT16 CacheConfiguration,
+  IN UINT8 Option
+  )
+{
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_CONFIGURATION), gShellDebug1HiiHandle);
+  PRINT_INFO_OPTION (CacheConfiguration, Option);
+  if (BIT (CacheConfiguration, 15) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT15_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 14) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT14_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 13) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT13_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 12) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT12_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 11) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT11_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 10) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT10_NOT_ZERO), gShellDebug1HiiHandle);
+  } else if (BIT (CacheConfiguration, 4) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_BIT4_NOT_ZERO), gShellDebug1HiiHandle);
+  }
+  //
+  // Check BITs 9:8
+  //
+  switch ((CacheConfiguration & 0x300) >> 8) {
+  case 0:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_WRITE_THROUGH), gShellDebug1HiiHandle);
+    break;
+  case 1:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_WRITE_BACK), gShellDebug1HiiHandle);
+    break;
+  case 2:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_VARIES_WITH_MEM_ADDR), gShellDebug1HiiHandle);
+    break;
+  case 3:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
+    break;
+  }
+  //
+  // Check BIT 7
+  //
+  if (BIT (CacheConfiguration, 7) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_ENABLED), gShellDebug1HiiHandle);
+  } else {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_DISABLED), gShellDebug1HiiHandle);
+  }
+  //
+  // Check BITs 6:5
+  //
+  switch ((CacheConfiguration & 0x60) >> 5) {
+  case 0:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_INTERNAL), gShellDebug1HiiHandle);
+    break;
+  case 1:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_EXTERNAL), gShellDebug1HiiHandle);
+    break;
+  case 2:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_RESERVED), gShellDebug1HiiHandle);
+    break;
+  case 3:
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_UNKNOWN), gShellDebug1HiiHandle);
+    break;
+  }
+  //
+  // Check BIT 3
+  //
+  if (BIT (CacheConfiguration, 3) != 0) {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_SOCKETED), gShellDebug1HiiHandle);
+  } else {
+    ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_NOT_SOCKETED), gShellDebug1HiiHandle);
+  }
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_CACHE_LEVEL), gShellDebug1HiiHandle, (CacheConfiguration & 0x07) + 1);
+}
+/**
   The Slot ID field of the System Slot structure provides a mechanism to
   correlate the physical attributes of the slot to its logical access method
 …
   default:
     if (SlotType >= 0x0E && SlotType <= 0x12) {
+    if ((SlotType >= 0x0E && SlotType <= 0x12) || (SlotType >= 0xA6 && SlotType <= 0xB6)){
       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_VALUE_PRESENT), gShellDebug1HiiHandle, SlotId);
     } else {
 …
   //
   Day   = Date & 0x001F;
   Month = (Date & 0x00E0) >> 5;
   Year  = ((Date & 0xFF00) >> 8) + 1980;
+  Month = (Date & 0x01E0) >> 5;
+  Year  = ((Date & 0xFE00) >> 9) + 1980;
   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_PRINTINFO_MONTH_DAY_YEAR), gShellDebug1HiiHandle, Day, Month, Year);
 …
 /**
   Display System Reset  (Type 23) information.
+  Display System Reset (Type 23) information.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/PrintInfo.h

-              r48674
+              r58459
   Module to clarify the element info of the smbios structure.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #define _SMBIOS_PRINT_INFO_H_
 #include "LibSmbios.h"
+#include <IndustryStandard/SmBios.h>
 extern UINT8  SmbiosMajorVersion;
 …
 VOID
 SmbiosPrintEPSInfo (
   IN  SMBIOS_STRUCTURE_TABLE  *SmbiosTable,
   IN  UINT8                   Option
+  IN  SMBIOS_TABLE_ENTRY_POINT  *SmbiosTable,
+  IN  UINT8                     Option
   );
 …
   @param[in] Status   The status.
                         Bit 7 Reserved, must be 0
                         Bit 6   CPU Socket Populated
 - CPU Socket Populated
 - CPU Socket UnpopulatedBits
 :3  Reserved, must be zero
                          Bits 2:0 CPU Status
 h - Unknown
 h - CPU Enabled
 h - CPU Disabled by User via BIOS Setup
 h - CPU Disabled By BIOS (POST Error)
 h - CPU is Idle, waiting to be enabled.
 -6h - Reserved
 h - Other
+Bit 7 Reserved, must be 0
+Bit 6 CPU Socket Populated
+- CPU Socket Populated
+- CPU Socket Unpopulated
+Bits 5:3 Reserved, must be zero
+Bits 2:0 CPU Status
+h - Unknown
+h - CPU Enabled
+h - CPU Disabled by User via BIOS Setup
+h - CPU Disabled By BIOS (POST Error)
+h - CPU is Idle, waiting to be enabled.
+-6h - Reserved
+h - Other
   @param[in] Option   The option
 …
 DisplayMmMemorySize (
   IN UINT8 Size,
+  IN UINT8 Option
+  );
+/**
+  Display Cache Configuration.
+  @param[in] CacheConfiguration   Cache Configuration.
+Bits 15:10 Reserved, must be 0
+Bits 9:8 Operational Mode
+h - Write Through
+h - Write Back
+h - Varies with Memory Address
+h - Unknown
+Bit 7 Enabled/Disabled
+- Enabled
+- Disabled
+Bits 6:5 Location
+h - Internal
+h - External
+h - Reserved
+h - Unknown
+Bit 4 Reserved, must be zero
+Bit 3 Cache Socketed
+- Socketed
+- Unsocketed
+Bits 2:0 Cache Level
+through 8 (For example, an L1 cache would
+  use value 000b and an L3 cache would use 010b.)
+  @param[in] Option   The option
+**/
+VOID
+DisplayCacheConfiguration (
+  IN UINT16 CacheConfiguration,
   IN UINT8 Option
   );

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/QueryTable.c

-              r48674
+              r58459
   And give a interface of query a string out of a table.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2015, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 };
+TABLE_ITEM  BaseBoardFeatureFlagsTable[] = {
+  {
+,
+    L" Hosting board"
+  },
+  {
+,
+    L" Requires at least one daughter board or auxiliary card"
+  },
+  {
+,
+    L" Removable"
+  },
+  {
+,
+    L" Replaceable"
+  },
+  {
+,
+    L" Hot swappable"
+  }
+};
+TABLE_ITEM  BaseBoardBoardTypeTable[] = {
+  {
+x01,
+    L" Unknown"
+  },
+  {
+x02,
+    L" Other"
+  },
+  {
+x03,
+    L" Server Blade"
+  },
+  {
+x04,
+    L" Connectivity Switch"
+  },
+  {
+x05,
+    L" System Management Module"
+  },
+  {
+x06,
+    L" Processor Module"
+  },
+  {
+x07,
+    L" I/O Module"
+  },
+  {
+x08,
+    L" Memory Module"
+  },
+  {
+x09,
+    L" Daughter board"
+  },
+  {
+x0A,
+    L" Motherboard"
+  },
+  {
+x0B,
+    L" Processor/Memory Module"
+  },
+  {
+x0C,
+    L" Processor/IO Module"
+  },
+  {
+x0D,
+    L" Interconnect Board"
+  }
+};
 TABLE_ITEM  SystemEnclosureTypeTable[] = {
+  {
 x01,
     L"  None"
+    L"  Other"
   },
+  {
 …
 x19,
     L"Socket LGA1366"
+  }\
+};
+  },
+  {
+x1A,
+    L"Socket G34"
+  },
+  {
+x1B,
+    L"Socket AM3"
+  },
+  {
+x1C,
+    L"Socket C32"
+  },
+  {
+x1D,
+    L"Socket LGA1156"
+  },
+  {
+x1E,
+    L"Socket LGA1567"
+  },
+  {
+x1F,
+    L"Socket PGA988A"
+  },
+  {
+x20,
+    L"Socket BGA1288"
+  },
+  {
+x21,
+    L"Socket rPGA988B"
+  },
+  {
+x22,
+    L"Socket BGA1023"
+  },
+  {
+x23,
+    L"Socket BGA1224"
+  },
+  {
+x24,
+    L"Socket LGA1155"
+  },
+  {
+x25,
+    L"Socket LGA1356"
+  },
+  {
+x26,
+    L"Socket LGA2011"
+  },
+  {
+x27,
+    L"Socket FS1"
+  },
+  {
+x28,
+    L"Socket FS2"
+  },
+  {
+x29,
+    L"Socket FM1"
+  },
+  {
+x2A,
+    L"Socket FM2"
+  },
+  {
+x2B,
+    L"Socket LGA2011-3"
+  },
+  {
+x2C,
+    L"Socket LGA1356-3"
+  }
+};
+TABLE_ITEM  ProcessorCharacteristicsTable[] = {
+  {
+,
+    L" Unknown"
+  },
+  {
+,
+    L" 64-bit Capable"
+  },
+  {
+,
+    L" Multi-Core"
+  },
+  {
+,
+    L" Hardware Thread"
+  },
+  {
+,
+    L" Execute Protection"
+  },
+  {
+,
+    L" Enhanced Virtualization"
+  },
+  {
+,
+    L" Power/Performance Control"
+  }
+};
 TABLE_ITEM  McErrorDetectMethodTable[] = {
 …
 x06,
     L"Multi-bit ECC"
-  },
+  {
-x07,
-    L"Sixteen Way Interleave"
+  }
 };
 …
 x0D,
     L"64-way Set-Associative"
+  },
+  {
+x0E,
+    L"20-way Set-Associative"
+  }
 };
 …
+  {
 xAB,
     L"PCI Express Gen 26"
+    L"PCI Express Gen 2"
   },
+  {
 …
 xB0,
     L"PCI Express Gen 2 X16"
+  },
+  {
+xB1,
+    L"PCI Express Gen 3"
+  },
+  {
+xB2,
+    L"PCI Express Gen 3 X1"
+  },
+  {
+xB3,
+    L"PCI Express Gen 3 X2"
+  },
+  {
+xB4,
+    L"PCI Express Gen 3 X4"
+  },
+  {
+xB5,
+    L"PCI Express Gen 3 X8"
+  },
+  {
+xB6,
+    L"PCI Express Gen 3 X16"
+  }
 };
 …
     L" 128 bit"
   },
+  {
+x08,
+    L" 1x or x1"
+  },
+  {
+x09,
+    L" 2x or x2"
+  },
+  {
+x0A,
+    L" 4x or x4"
+  },
+  {
+x0B,
+    L" 8x or x8"
+  },
+  {
+x0C,
+    L" 12x or x12"
+  },
+  {
+x0D,
+    L" 16x or x16"
+  },
+  {
+x0E,
+    L" 32x or x32"
+  }
 };
 …
     L" Non-volatile"
   },
+  {
+,
+    L" Registered(Buffered)"
+  },
+  {
+,
+    L" Unbuffered(Unregistered)"
+  }
 };
 …
   },
+  {
 x0A,
+x10,
     L" Active Cooling "
   },
+  {
 x0B,
+x11,
     L" Passive Cooling "
   },
 …
 ,
     L" System Power Supply"
+  },
+  {
+,
+    L" Additional Information"
+  },
+  {
+,
+    L" Onboard Devices Extended Information"
+  },
+  {
+,
+    L" Management Controller Host Interface"
   },
+  {
 …
     High  = (UINT8) (Table[Index].Key >> 8);
     Low   = (UINT8) (Table[Index].Key & 0x00FF);
     //
     // Check if Key is in the range
+    // or if Key == Value in the table
     //
+    if (High > Low && Key >= Low && Key <= High) {
+    if ((High > Low && Key >= Low && Key <= High)
+      || (Table[Index].Key == Key)) {
       StrnCpy (Info, Table[Index].Info, InfoLen-1);
+      StrnCat (Info, L"\n", InfoLen - StrLen(Info));
+      return Key;
+    }
+    //
+    // Check if Key == Value in the table
+    //
+    if (Table[Index].Key == Key) {
+      StrnCpy (Info, Table[Index].Info, InfoLen-1);
+      StrnCat (Info, L"\n", InfoLen - StrLen(Info));
+      StrnCat (Info, L"\n", InfoLen - 1 - StrLen(Info));
       return Key;
+    }
+  }
   StrnCpy (Info, L"Undefined Value\n", InfoLen);
+  StrnCpy (Info, L"Undefined Value\n", InfoLen - 1);
   return QUERY_TABLE_UNFOUND;
+}
 …
 /**
+  Display Base Board (Type 2) Feature Flags.
+  @param[in] FeatureFlags   The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayBaseBoardFeatureFlags (
+  IN UINT8 FeatureFlags,
+  IN UINT8 Option
+  )
+{
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_BASE_BOARD_FEATURE_FLAGS), gShellDebug1HiiHandle);
+  PRINT_INFO_OPTION (FeatureFlags, Option);
+  PRINT_BITS_INFO (BaseBoardFeatureFlagsTable, FeatureFlags);
+}
+/**
+  Display Base Board (Type 2) Board Type.
+  @param[in] Type           The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayBaseBoardBoardType(
+  IN UINT8 Type,
+  IN UINT8 Option
+  )
+{
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_BASE_BOARD_BOARD_TYPE), gShellDebug1HiiHandle);
+  PRINT_INFO_OPTION (Type, Option);
+  PRINT_TABLE_ITEM (BaseBoardBoardTypeTable, Type);
+}
+/**
   Display System Enclosure (Type 3) Enclosure Type.
 …
   PRINT_INFO_OPTION (Upgrade, Option);
   PRINT_TABLE_ITEM (ProcessorUpgradeTable, Upgrade);
+}
+/**
+  Display Processor Information (Type 4) Characteristics.
+  @param[in] Type           The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayProcessorCharacteristics (
+  IN UINT16 Type,
+  IN UINT8 Option
+  )
+{
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_PROC_CHARACTERISTICS), gShellDebug1HiiHandle);
+  PRINT_INFO_OPTION (Type, Option);
+  PRINT_BITS_INFO (ProcessorCharacteristicsTable, Type);
+}
 …
+  )
+{
   ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_PHYS_MEM_ARRAY_LOCATION), gShellDebug1HiiHandle);
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_PHYS_MEM_ARRAY_USE), gShellDebug1HiiHandle);
   PRINT_INFO_OPTION (Use, Option);
   PRINT_TABLE_ITEM (PMAUseTable, Use);
 …
 /**
   Display Management Device (Type 34) information.
+  Display Management Device (Type 34) Type.
   @param[in] Key      The key of the structure.
 …
   PRINT_INFO_OPTION (Key, Option);
   PRINT_TABLE_ITEM (MDTypeTable, Key);
+}
+/**
+  Display Management Device (Type 34) Address Type.
+  @param[in] Key      The key of the structure.
+  @param[in] Option   The optional information.
+**/
+VOID
+DisplayMDAddressType (
+  IN UINT8 Key,
+  IN UINT8 Option
+  )
+{
+  ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_QUERYTABLE_MANAGEMENT_DEV_ADDR_TYPE), gShellDebug1HiiHandle);
+  PRINT_INFO_OPTION (Key, Option);
+  PRINT_TABLE_ITEM (MDAddressTypeTable, Key);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/QueryTable.h

-              r48674
+              r58459
   and give a interface of query a string out of a table.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Display Base Board (Type 2) Feature Flags.
+  @param[in] FeatureFlags   The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayBaseBoardFeatureFlags (
+  IN UINT8 FeatureFlags,
+  IN UINT8 Option
+  );
+/**
+  Display Base Board (Type 2) Board Type.
+  @param[in] Type           The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayBaseBoardBoardType(
+  IN UINT8 Type,
+  IN UINT8 Option
+  );
+/**
   Display System Enclosure (Type 3) Enclosure Type.
 …
 DisplayProcessorUpgrade (
   IN UINT8 Upgrade,
+  IN UINT8 Option
+  );
+/**
+  Display Processor Information (Type 4) Characteristics.
+  @param[in] Type           The key of the structure.
+  @param[in] Option         The optional information.
+**/
+VOID
+DisplayProcessorCharacteristics (
+  IN UINT16 Type,
   IN UINT8 Option
   );
 …
 /**
   Display Management Device (Type 34) information.
+  Display Management Device (Type 34) Type.
   @param[in] Key      The key of the structure.
 …
 /**
+  Display Management Device (Type 34) Address Type.
+  @param[in] Key      The key of the structure.
+  @param[in] Option   The optional information.
+**/
+VOID
+DisplayMDAddressType (
+  IN UINT8 Key,
+  IN UINT8 Option
+  );
+/**
   Display Memory Channel (Type 37) information.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/SmbiosView.c

-              r48674
+              r58459
   Tools of clarify the content of the smbios table.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
       // Initialize the StructHandle to be the first handle
       //
       StructHandle  = STRUCTURE_HANDLE_INVALID;
+      StructHandle  = INVALID_HANDLE;
       LibGetSmbiosStructure (&StructHandle, NULL, NULL);
 …
+{
   UINT16                    Handle;
+  UINT8                     Buffer[1024];
+  //
+  // bigger than SMBIOS_STRUCTURE_TABLE.MaxStructureSize
+  //
+  UINT8                     *Buffer;
   UINT16                    Length;
   UINTN                     Index;
-  UINT16                    Offset;
-  //
-  // address offset from structure table head.
-  //
-  UINT32                    TableHead;
-  //
-  // structure table head.
-  //
   SMBIOS_STRUCTURE_POINTER  SmbiosStruct;
   SMBIOS_STRUCTURE_TABLE    *SMBiosTable;
+  SMBIOS_TABLE_ENTRY_POINT  *SMBiosTable;
   SMBiosTable = NULL;
 …
   if (CompareMem (SMBiosTable->AnchorString, "_SM_", 4) == 0) {
     //
     // Have get SMBIOS table
+    // Have got SMBIOS table
     //
     SmbiosPrintEPSInfo (SMBiosTable, Option);
 …
     //
     Handle    = QueryHandle;
-    TableHead = SMBiosTable->TableAddress;
-    Offset    = 0;
     for (Index = 0; Index < SMBiosTable->NumberOfSmbiosStructures; Index++) {
       //
       // if reach the end of table, break..
       //
       if (Handle == STRUCTURE_HANDLE_INVALID) {
+      if (Handle == INVALID_HANDLE) {
         break;
+      }
 …
       // handle then point to the next!
       //
       if (LibGetSmbiosStructure (&Handle, Buffer, &Length) != DMI_SUCCESS) {
+      if (LibGetSmbiosStructure (&Handle, &Buffer, &Length) != DMI_SUCCESS) {
         break;
+      }
+      Offset      = (UINT16) (Offset + Length);
       SmbiosStruct.Raw = Buffer;
 …
       // Addr of structure in structure in table
       //
       ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ADDR), gShellDebug1HiiHandle, TableHead + Offset);
+      ShellPrintHiiEx(-1,-1,NULL,STRING_TOKEN (STR_SMBIOSVIEW_SMBIOSVIEW_ADDR), gShellDebug1HiiHandle, (UINTN) Buffer);
       DumpHex (0, 0, Length, Buffer);
 …
       if (gShowType != SHOW_NONE) {
-        //
-        // check structure legality
-        //
-        SmbiosCheckStructure (&SmbiosStruct);
         //
         // Print structure information
 …
         break;
+      }
+      //
+      // Support Execution Interrupt.
+      //
+      if (ShellGetExecutionBreakFlag ()) {
+        return EFI_ABORTED;
+      }
+    }
 …
+{
   UINT16                    Handle;
   UINT8                     Buffer[1024];
+  UINT8                     *Buffer;
   UINT16                    Length;
   UINT16                    Offset;
 …
   SMBIOS_STRUCTURE_POINTER  SmbiosStruct;
   SMBIOS_STRUCTURE_TABLE    *SMBiosTable;
+  SMBIOS_TABLE_ENTRY_POINT  *SMBiosTable;
   STRUCTURE_STATISTICS      *StatisticsPointer;
 …
   // search from the first one
   //
   Handle = STRUCTURE_HANDLE_INVALID;
+  Handle = INVALID_HANDLE;
   LibGetSmbiosStructure (&Handle, NULL, NULL);
   for (Index = 1; Index <= SMBiosTable->NumberOfSmbiosStructures; Index++) {
 …
     // If reach the end of table, break..
     //
     if (Handle == STRUCTURE_HANDLE_INVALID) {
+    if (Handle == INVALID_HANDLE) {
       break;
+    }
 …
     // After LibGetSmbiosStructure(), handle then point to the next!
     //
     if (LibGetSmbiosStructure (&Handle, Buffer, &Length) != DMI_SUCCESS) {
+    if (LibGetSmbiosStructure (&Handle, &Buffer, &Length) != DMI_SUCCESS) {
       break;
+    }
     SmbiosStruct.Raw = Buffer;
-    Offset      = (UINT16) (Offset + Length);
     //
 …
     StatisticsPointer->Length = Length;
     StatisticsPointer->Addr   = Offset;
+    Offset = (UINT16) (Offset + Length);
     StatisticsPointer         = &mStatisticsTable[Index];
 …
+  )
+{
   UINTN                   Index;
   UINTN                   Num;
   STRUCTURE_STATISTICS    *StatisticsPointer;
   SMBIOS_STRUCTURE_TABLE  *SMBiosTable;
+  UINTN                    Index;
+  UINTN                    Num;
+  STRUCTURE_STATISTICS     *StatisticsPointer;
+  SMBIOS_TABLE_ENTRY_POINT *SMBiosTable;
   SMBiosTable = NULL;
 …
+}
-/*
-EFI_STATUS
-InitializeSmbiosViewApplicationGetLineHelp (
-  OUT CHAR16              **Str
+  )
+{
-  return LibCmdGetStringByToken (STRING_ARRAY_NAME, &EfiSmbiosViewGuid, STRING_TOKEN (STR_SMBIOSVIEW_LINE_HELP), Str);
+}
-*/

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/SmbiosView/SmbiosView.h

-              r48674
+              r58459
   Tools of clarify the content of the smbios table.
   Copyright (c) 2005 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2005 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #define STRUCTURE_TYPE_RANDOM     (UINT8) 0xFE
 #define STRUCTURE_TYPE_INVALID    (UINT8) 0xFF
-#define STRUCTURE_HANDLE_INVALID  (UINT16) 0xFFFF
 typedef struct {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.c

-              r48674
+              r58459
 #include "UefiShellDebug1CommandsLib.h"
+#include <Library/BcfgCommandLib.h>
 STATIC CONST CHAR16 mFileName[] = L"Debug1Commands";
 …
   ShellCommandRegisterCommandName(L"hexedit",       ShellCommandRunHexEdit            , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_HEXEDIT)      );
-  //
-  // check install profile bit of the profiles mask is set
-  //
-  if ((PcdGet8(PcdShellProfileMask) & BIT2) == 0) {
-    ShellCommandRegisterCommandName(L"bcfg",        ShellCommandRunBcfg               , ShellCommandGetManFileNameDebug1, 0, L"Debug1", TRUE, gShellDebug1HiiHandle, STRING_TOKEN(STR_GET_HELP_BCFG)         );
+  }
   ShellCommandRegisterAlias(L"dmem", L"mem");
+  BcfgLibraryRegisterBcfgCommand(ImageHandle, SystemTable, L"Debug1");
   return (EFI_SUCCESS);
 …
     HiiRemovePackages(gShellDebug1HiiHandle);
+  }
+  BcfgLibraryUnregisterBcfgCommand(ImageHandle, SystemTable);
   return (EFI_SUCCESS);
+}
 …
     Val[Index * 3]  = 0;
     Str[Index]      = 0;
     ShellPrintEx(-1, -1, L"%*a%02X: %-.48a *%a*\r\n", Indent, "", Offset, Val, Str);
+    ShellPrintEx(-1, -1, L"%*a%08X: %-48a *%a*\r\n", Indent, "", Offset, Val, Str);
     Data += Size;
 …
   EFI_STATUS         Status;
   UINTN              Suffix;
-  BOOLEAN            FoundNewFile;
   CHAR16             *FileNameTmp;
   Suffix       = 0;
-  FoundNewFile = FALSE;
   do {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.h

-              r48674
+              r58459
   Main file for NULL named library for Profile1 shell command functions.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Protocol/LoadedImage.h>
 #include <Protocol/UnicodeCollation.h>
-#include <Protocol/DevicePathToText.h>
 #include <Protocol/DriverDiagnostics2.h>
 #include <Protocol/DriverDiagnostics.h>
 …
 #include <Protocol/DriverFamilyOverride.h>
 #include <Protocol/DriverHealth.h>
-#include <Protocol/DevicePathFromText.h>
 #include <Protocol/SimplePointer.h>
 #include <Protocol/PciRootBridgeIo.h>

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.inf

-              r48674
+              r58459
 # Provides shell Debug1 profile functions
+#
 # Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
+#
 #  This program and the accompanying materials
 …
   SetVar.c
   SerMode.c
-  Bcfg.c
   Pci.c
   Pci.h
 …
   SmbiosView/QueryTable.c
   SmbiosView/SmbiosView.c
-  SmbiosView/Smbios.c
   SmbiosView/SmbiosViewStrings.uni
   SmbiosView/LibSmbiosView.c
   SmbiosView/PrintInfo.h
   SmbiosView/LibSmbiosView.h
-  SmbiosView/LibSmbios.h
   SmbiosView/QueryTable.h
   SmbiosView/SmbiosView.h
 …
   SortLib
   PrintLib
+  BcfgCommandLib
 [Pcd]
   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask              # ALWAYS_CONSUMED
   gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize        # ALWAYS_CONSUMED
   gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength      # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask              ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize        ## CONSUMES
+  gEfiMdePkgTokenSpaceGuid.PcdMaximumUnicodeStringLength      ## CONSUMES
 [Protocols]
   gEfiPciRootBridgeIoProtocolGuid
   gEfiBlockIoProtocolGuid
   gEfiSimplePointerProtocolGuid
+  gEfiPciRootBridgeIoProtocolGuid             ## CONSUMES
+  gEfiBlockIoProtocolGuid                     ## CONSUMES
+  gEfiSimplePointerProtocolGuid               ## CONSUMES
 [Guids]
   gEfiGlobalVariableGuid
   gEfiSmbiosTableGuid
   gEfiMpsTableGuid
   gEfiSalSystemTableGuid
   gEfiAcpi10TableGuid
   gEfiAcpi20TableGuid
   gShellDebug1HiiGuid
+  gEfiGlobalVariableGuid          ## SOMETIMES_CONSUMES ## GUID
+  gEfiSmbiosTableGuid             ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiMpsTableGuid                ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiSalSystemTableGuid          ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiAcpi10TableGuid             ## SOMETIMES_CONSUMES ## SystemTable
+  gEfiAcpi20TableGuid             ## SOMETIMES_CONSUMES ## SystemTable
+  gShellDebug1HiiGuid             ## SOMETIMES_CONSUMES ## HII

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Connect.c

-              r48674
+              r58459
   Main file for connect shell Driver1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
+  Create all handles associate with every device path node.
+  @param  DevicePathToConnect           The device path which will be connected.
+  @retval EFI_SUCCESS                   All handles associate with every device path node
+                                        have been created.
+  @retval EFI_INVALID_PARAMETER         DevicePathToConnect is NULL.
+  @retval EFI_NOT_FOUND                 Create the handle associate with one device path
+                                        node failed
+**/
+EFI_STATUS
+ShellConnectDevicePath (
+  IN EFI_DEVICE_PATH_PROTOCOL   *DevicePathToConnect
+  )
+{
+  EFI_DEVICE_PATH_PROTOCOL  *RemainingDevicePath;
+  EFI_STATUS                Status;
+  EFI_HANDLE                Handle;
+  EFI_HANDLE                PreviousHandle;
+  if (DevicePathToConnect == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  PreviousHandle = NULL;
+  do{
+    RemainingDevicePath = DevicePathToConnect;
+    Status = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &RemainingDevicePath, &Handle);
+    if (!EFI_ERROR (Status) && (Handle != NULL)) {
+      if (PreviousHandle == Handle) {
+        Status = EFI_NOT_FOUND;
+      } else {
+        PreviousHandle = Handle;
+        Status = gBS->ConnectController (Handle, NULL, RemainingDevicePath, FALSE);
+      }
+    }
+  } while (!EFI_ERROR (Status) && !IsDevicePathEnd (RemainingDevicePath) );
+  return Status;
+}
+/**
+  Connect drivers for PCI root bridge.
+  @retval EFI_SUCCESS                     Connect drivers successfully.
+  @retval EFI_NOT_FOUND                   Cannot find PCI root bridge device.
+**/
+EFI_STATUS
+ShellConnectPciRootBridge (
+  VOID
+  )
+{
+  UINTN               RootBridgeHandleCount;
+  EFI_HANDLE          *RootBridgeHandleBuffer;
+  UINTN               RootBridgeIndex;
+  EFI_STATUS          Status;
+  RootBridgeHandleCount = 0;
+  Status = gBS->LocateHandleBuffer (
+              ByProtocol,
+              &gEfiPciRootBridgeIoProtocolGuid,
+              NULL,
+              &RootBridgeHandleCount,
+              &RootBridgeHandleBuffer
+              );
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+  for (RootBridgeIndex = 0; RootBridgeIndex < RootBridgeHandleCount; RootBridgeIndex++) {
+    gBS->ConnectController (RootBridgeHandleBuffer[RootBridgeIndex], NULL, NULL, FALSE);
+  }
+  return EFI_SUCCESS;
+}
+/**
   Connect controller(s) and driver(s).
   @param[in] ControllerHandle     The handle to the controller.  Should have driver binding on it.
   @param[in] DriverHandle         The handle to the driver.  Should have driver binding.
+  @param[in] ControllerHandle     The handle to the controller. Should have driver binding on it.
+  @param[in] DriverHandle         The handle to the driver. Should have driver binding.
   @param[in] Recursive            TRUE to connect recursively, FALSE otherwise.
   @param[in] Output               TRUE to have info on the screen, FALSE otherwise.
 …
+{
   EFI_DEVICE_PATH_PROTOCOL  *DevPath;
+  EFI_DEVICE_PATH_PROTOCOL  *DevPathWalker;
+  EFI_DEVICE_PATH_PROTOCOL  *CopyOfDevPath;
+  EFI_DEVICE_PATH_PROTOCOL  *Instance;
+  EFI_DEVICE_PATH_PROTOCOL  *Next;
   UINTN                     Length;
+  EFI_HANDLE                Handle;
+  UINTN                     Index;
+  UINTN                     HandleArrayCount;
+  UINTN                     Size;
+  EFI_HANDLE                *HandleArray;
   EFI_STATUS                Status;
+  BOOLEAN                   AtLeastOneConnected;
+  EFI_PCI_IO_PROTOCOL       *PciIo;
+  UINT8                     Class[3];
   DevPath = NULL;
   Length  = 0;
+  AtLeastOneConnected = FALSE;
   //
 …
   if (Status == EFI_BUFFER_TOO_SMALL) {
     DevPath = AllocateZeroPool(Length);
+    if (DevPath == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
     Status = gRT->GetVariable((CHAR16*)Key, (EFI_GUID*)&gEfiGlobalVariableGuid, NULL, &Length, DevPath);
+    if (EFI_ERROR (Status)) {
+      if (DevPath != NULL) {
+        FreePool (DevPath);
+      }
+      return Status;
+    }
+  } else if (EFI_ERROR (Status)) {
+    return Status;
+  }
   Status = EFI_NOT_FOUND;
+  CopyOfDevPath = DevPath;
   //
   // walk the list of devices and connect them
   //
+  for (DevPathWalker = DevPath
+    ;  DevPathWalker < (DevPath + Length) && EFI_ERROR(Status) && DevPath != NULL
+    ;  DevPathWalker += GetDevicePathSize(DevPathWalker)
+   ){
+    //
+    // get the correct handle from a given device path
+    //
+    if ((StrCmp(Key, L"ConInDev") == 0)
+      ||(StrCmp(Key, L"ConIn") == 0)
+    ){
+      Status = gBS->LocateDevicePath((EFI_GUID*)&gEfiConsoleInDeviceGuid, &DevPathWalker, &Handle);
+      if (!EFI_ERROR(Status)) {
+        Status = ConnectControllers(NULL, Handle, FALSE, TRUE, FALSE);
+      }
+    } else if ((StrCmp(Key, L"ConOutDev") == 0)
+            || (StrCmp(Key, L"ConErrDev") == 0)
+            || (StrCmp(Key, L"ConOut")    == 0)
+            || (StrCmp(Key, L"ConErr")    == 0)
+            ){
+      Status = gBS->LocateDevicePath((EFI_GUID*)&gEfiConsoleOutDeviceGuid, &DevPathWalker, &Handle);
+      if (!EFI_ERROR(Status)) {
+        Status = ConnectControllers(NULL, Handle, FALSE, TRUE, FALSE);
+      }
+    }
+  }
+  do {
+    //
+    // Check every instance of the console variable
+    //
+    Instance = GetNextDevicePathInstance (&CopyOfDevPath, &Size);
+    if (Instance == NULL) {
+      if (DevPath != NULL) {
+        FreePool (DevPath);
+      }
+      return EFI_UNSUPPORTED;
+    }
+    Next = Instance;
+    while (!IsDevicePathEndType (Next)) {
+      Next = NextDevicePathNode (Next);
+    }
+    SetDevicePathEndNode (Next);
+    //
+    // connect short form device path
+    //
+    if ((DevicePathType (Instance) == MESSAGING_DEVICE_PATH) &&
+      ((DevicePathSubType (Instance) == MSG_USB_CLASS_DP)
+      || (DevicePathSubType (Instance) == MSG_USB_WWID_DP)
+      )) {
+      Status = ShellConnectPciRootBridge ();
+      if (EFI_ERROR(Status)) {
+        FreePool(Instance);
+        FreePool(DevPath);
+        return Status;
+      }
+      Status = gBS->LocateHandleBuffer (
+                  ByProtocol,
+                  &gEfiPciIoProtocolGuid,
+                  NULL,
+                  &HandleArrayCount,
+                  &HandleArray
+                  );
+      if (!EFI_ERROR (Status)) {
+        for (Index = 0; Index < HandleArrayCount; Index++) {
+          Status = gBS->HandleProtocol (
+                      HandleArray[Index],
+                      &gEfiPciIoProtocolGuid,
+                      (VOID **)&PciIo
+                      );
+          if (!EFI_ERROR (Status)) {
+            Status = PciIo->Pci.Read (PciIo, EfiPciIoWidthUint8, 0x09, 3, &Class);
+            if (!EFI_ERROR (Status)) {
+              if ((PCI_CLASS_SERIAL == Class[2]) &&
+                  (PCI_CLASS_SERIAL_USB == Class[1])) {
+                Status = gBS->ConnectController (
+                              HandleArray[Index],
+                              NULL,
+                              Instance,
+                              FALSE
+                              );
+                if (!EFI_ERROR(Status)) {
+                  AtLeastOneConnected = TRUE;
+                }
+              }
+            }
+          }
+        }
+      }
+      if (HandleArray != NULL) {
+        FreePool (HandleArray);
+      }
+    } else {
+      //
+      // connect the entire device path
+      //
+      Status = ShellConnectDevicePath (Instance);
+      if (!EFI_ERROR (Status)) {
+        AtLeastOneConnected = TRUE;
+      }
+    }
+    FreePool (Instance);
+  } while (CopyOfDevPath != NULL);
   if (DevPath != NULL) {
     FreePool(DevPath);
+  }
+  return (Status);
+  if (AtLeastOneConnected) {
+    return EFI_SUCCESS;
+  } else {
+    return EFI_NOT_FOUND;
+  }
+}
 …
   ShellStatus         = SHELL_SUCCESS;
   //
   // initialize the shell lib (we must be in non-auto-init...)
 …
+      }
       if (EFI_ERROR(Status)) {
         ConnectFromDevPaths(L"ConErrDev");
       } else {
         Status = ConnectFromDevPaths(L"ConErrDev");
+      }
       if (EFI_ERROR(Status)) {
         ConnectFromDevPaths(L"ConErr");
       } else {
         Status = ConnectFromDevPaths(L"ConErr");
+        ConnectFromDevPaths(L"ErrOutDev");
+      } else {
+        Status = ConnectFromDevPaths(L"ErrOutDev");
+      }
+      if (EFI_ERROR(Status)) {
+        ConnectFromDevPaths(L"ErrOut");
+      } else {
+        Status = ConnectFromDevPaths(L"ErrOut");
+      }
       if (EFI_ERROR(Status)) {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/DevTree.c

-              r48674
+              r58459
   Main file for DevTree shell Driver1 function.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   ASSERT(TheHandle    != NULL);
+  if (ShellGetExecutionBreakFlag()) {
+    ShellStatus = SHELL_ABORTED;
+    return ShellStatus;
+  }
   //
   // We want controller handles.  they will not have LoadedImage or DriverBinding (or others...)
 …
   if (!EFI_ERROR (Status)) {
     return SHELL_SUCCESS;
+  }
-  //
-  // If we are at the begining then we want root handles they have no parents and do have device path.
-  //
-  if (IndentCharCount == 0) {
-    Status = gBS->OpenProtocol (
-                  TheHandle,
-                  &gEfiDevicePathProtocolGuid,
-                  NULL,
-                  NULL,
-                  NULL,
-                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
-                 );
-    if (EFI_ERROR (Status)) {
-      return SHELL_SUCCESS;
+    }
+  }
 …
   for (LoopVar = 0 ; LoopVar < ChildCount && ShellStatus == SHELL_SUCCESS; LoopVar++){
     ShellStatus = DoDevTreeForHandle(ChildHandleBuffer[LoopVar], Lang, UseDevPaths, IndentCharCount+2, HiiString);
+    if (ShellStatus == SHELL_ABORTED) {
+      break;
+    }
+  }
 …
   BOOLEAN             FlagD;
   UINT64              Intermediate;
+  UINTN               ParentControllerHandleCount;
+  EFI_HANDLE          *ParentControllerHandleBuffer;
   ShellStatus         = SHELL_SUCCESS;
 …
           break;
+        }
+        //
+        // Skip handles that do not have device path protocol
+        //
+        Status = gBS->OpenProtocol (
+                      TheHandle,
+                      &gEfiDevicePathProtocolGuid,
+                      NULL,
+                      NULL,
+                      NULL,
+                      EFI_OPEN_PROTOCOL_TEST_PROTOCOL
+                     );
+        if (EFI_ERROR (Status)) {
+          continue;
+        }
+        //
+        // Skip handles that do have parents
+        //
+        ParentControllerHandleBuffer = NULL;
+        Status = PARSE_HANDLE_DATABASE_PARENTS (
+                   TheHandle,
+                   &ParentControllerHandleCount,
+                   &ParentControllerHandleBuffer
+                   );
+        SHELL_FREE_NON_NULL (ParentControllerHandleBuffer);
+        if (ParentControllerHandleCount > 0) {
+          continue;
+        }
+        //
+        // Start a devtree from TheHandle that has a device path and no parents
+        //
         ShellStatus = DoDevTreeForHandle(TheHandle, Language, FlagD, 0, HiiString);
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Devices.c

-              r48674
+              r58459
   Main file for devices shell Driver1 function.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2012-2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
+  {L"-sfo", TypeFlag},
   {L"-l", TypeValue},
   {NULL, TypeMax}
 …
   CHAR16              *Name;
   CONST CHAR16        *Lang;
+  BOOLEAN             SfoFlag;
   ShellStatus         = SHELL_SUCCESS;
   Language            = NULL;
+  SfoFlag             = FALSE;
   //
 …
       //
       // Print Header
+      //
+      ShellPrintHiiEx(-1, -1, Language, STRING_TOKEN (STR_DEVICES_HEADER_LINES), gShellDriver1HiiHandle);
+      //
+      if (ShellCommandLineGetFlag (Package, L"-sfo")) {
+        ShellPrintHiiEx (-1, -1, Language, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellDriver1HiiHandle, L"devices");
+        SfoFlag = TRUE;
+      } else {
+        ShellPrintHiiEx (-1, -1, Language, STRING_TOKEN (STR_DEVICES_HEADER_LINES), gShellDriver1HiiHandle);
+      }
       //
 …
         Status = GetDeviceHandleInfo(*HandleListWalker, &Type, &Cfg, &Diag, &Parents, &Devices, &Children, &Name, Language);
         if (Name != NULL && (Parents != 0 || Devices != 0 || Children != 0)) {
           ShellPrintHiiEx(
+          ShellPrintHiiEx (
             -1,
             -1,
             Language,
             STRING_TOKEN (STR_DEVICES_ITEM_LINE),
+            SfoFlag?STRING_TOKEN (STR_DEVICES_ITEM_LINE_SFO):STRING_TOKEN (STR_DEVICES_ITEM_LINE),
             gShellDriver1HiiHandle,
             ConvertHandleToHandleIndex(*HandleListWalker),
+            ConvertHandleToHandleIndex (*HandleListWalker),
             Type,
             Cfg?L'X':L'-',
             Diag?L'X':L'-',
+            Cfg?(SfoFlag?L'Y':L'X'):(SfoFlag?L'N':L'-'),
+            Diag?(SfoFlag?L'Y':L'X'):(SfoFlag?L'N':L'-'),
             Parents,
             Devices,
 …
           FreePool(Name);
+        }
+        if (ShellGetExecutionBreakFlag ()) {
+          ShellStatus = SHELL_ABORTED;
+          break;
+        }
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Dh.c

-              r48674
+              r58459
   Main file for Dh shell Driver1 function.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
+{
   CHAR8                             *Lang;
-  CHAR8                             *TempChar;
   EFI_STATUS                        Status;
   EFI_COMPONENT_NAME2_PROTOCOL      *CompName2;
 …
     return (EFI_NOT_FOUND);
+  }
+  if (Language == NULL) {
+    Lang = AllocateZeroPool(AsciiStrSize(CompName2->SupportedLanguages));
+    if (Lang == NULL) {
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    AsciiStrCpy(Lang, CompName2->SupportedLanguages);
+    TempChar = AsciiStrStr(Lang, ";");
+    if (TempChar != NULL){
+      *TempChar = CHAR_NULL;
+    }
+  } else {
+    Lang = AllocateZeroPool(AsciiStrSize(Language));
+    if (Lang == NULL) {
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    AsciiStrCpy(Lang, Language);
+  }
+  Lang = GetBestLanguageForDriver (CompName2->SupportedLanguages, Language, FALSE);
   Status = CompName2->GetDriverName(CompName2, Lang, &NameToReturn);
   FreePool(Lang);
 …
             StrnCatGrow(&RetVal, &Size, L"(", 0);
             StrnCatGrow(&RetVal, &Size, Temp, 0);
             StrnCatGrow(&RetVal, &Size, L")", 0);
+            StrnCatGrow(&RetVal, &Size, L")\r\n", 0);
           } else {
             StrnCatGrow(&RetVal, &Size, Seperator, 0);
 …
+  }
   DevicePath = LoadedImage->FilePath;
   *Name = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, TRUE);
+  *Name = ConvertDevicePathToText(DevicePath, TRUE, TRUE);
   return (EFI_SUCCESS);
+}
 …
   BOOLEAN                     Image;
+  DriverName = NULL;
   //
   // See if Handle is a device handle and display its details.
 …
     SHELL_FREE_NON_NULL(TempStringPointer);
     TempStringPointer = gDevPathToText->ConvertDevicePathToText(DevicePath, TRUE, FALSE);
+    TempStringPointer = ConvertDevicePathToText(DevicePath, TRUE, FALSE);
     ShellPrintHiiEx(
       -1,
 …
                   &DriverName
                   );
         if (DriverName == NULL) {
+        if (EFI_ERROR (Status)) {
           Status = GetDriverImageName (
                     DriverBindingHandleBuffer[Index],
                     &DriverName
                     );
+          if (EFI_ERROR (Status)) {
+            DriverName = NULL;
+          }
+        }
 …
   Status = GetDriverName (Handle, Language, &DriverName);
+  if (EFI_ERROR (Status)) {
+    DriverName = NULL;
+  }
   ShellPrintHiiEx(
 …
     );
   SHELL_FREE_NON_NULL(DriverName);
-  DriverName = NULL;
   Status = GetDriverImageName (
             Handle,
             &DriverName
             );
+  if (EFI_ERROR (Status)) {
+    DriverName = NULL;
+  }
   ShellPrintHiiEx(
     -1,
 …
   CHAR16              *ProtocolInfoString;
   SHELL_STATUS        ShellStatus;
+  EFI_STATUS          Status;
+  Status              = EFI_SUCCESS;
   ShellStatus         = SHELL_SUCCESS;
   ProtocolInfoString  = NULL;
 …
   @param[in] HandleList       The NULL-terminated list of handles.
+  @param[in] Verbose          TRUE for extra info, FALSE otherwise.
   @param[in] Sfo              TRUE to output in standard format output (spec).
   @param[in] Language         Language string per UEFI specification.
 …
 DoDhForHandleList(
   IN CONST EFI_HANDLE *HandleList,
+  IN CONST BOOLEAN    Verbose,
   IN CONST BOOLEAN    Sfo,
   IN CONST CHAR8      *Language,
 …
     ShellStatus = DoDhByHandle(
           *HandleWalker,
           FALSE,
+          Verbose,
           Sfo,
           Language,
 …
           TRUE
          );
+    if (ShellGetExecutionBreakFlag ()) {
+      ShellStatus = SHELL_ABORTED;
+      break;
+    }
+  }
   return (ShellStatus);
 …
   @param[in] Sfo              TRUE to output in standard format output (spec).
+  @param[in] Verbose          TRUE for extra info, FALSE otherwise.
   @param[in] Language         Language string per UEFI specification.
   @param[in] DriverInfo       TRUE to show all info about the handle.
 …
 DoDhForAll(
   IN CONST BOOLEAN  Sfo,
+  IN CONST BOOLEAN  Verbose,
   IN CONST CHAR8    *Language,
   IN CONST BOOLEAN  DriverInfo
 …
   ShellStatus = DoDhForHandleList(
     HandleList,
+    Verbose,
     Sfo,
     Language,
 …
   @param[in] ProtocolName     The pointer to the name of the protocol.
+  @param[in] Verbose          TRUE for extra info, FALSE otherwise.
   @param[in] Sfo              TRUE to output in standard format output (spec).
   @param[in] Language         Language string per UEFI specification.
 …
 DoDhByProtocol(
   IN CONST CHAR16   *ProtocolName,
+  IN CONST BOOLEAN  Verbose,
   IN CONST BOOLEAN  Sfo,
   IN CONST CHAR8    *Language,
 …
   ShellStatus = DoDhForHandleList(
     HandleList,
+    Verbose,
     Sfo,
     Language,
 …
         ShellStatus = DoDhByProtocol(
           ShellCommandLineGetValue(Package, L"-p"),
+          Verbose,
           SfoMode,
           Lang==NULL?NULL:Language,
 …
         ShellStatus = DoDhForAll(
           SfoMode,
+          Verbose,
           Lang==NULL?NULL:Language,
           FlagD

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Disconnect.c

-              r48674
+              r58459
   Main file for Disconnect shell Driver1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_INV_HANDLE), gShellDriver1HiiHandle, Param3);
           ShellStatus = SHELL_INVALID_PARAMETER;
-        } else if (EFI_ERROR(gBS->OpenProtocol(Handle1, &gEfiDevicePathProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
-          ASSERT(Param1 != NULL);
-          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_HANDLE_NOT), gShellDriver1HiiHandle, ShellStrToUintn(Param1), L"controller handle");
-          ShellStatus = SHELL_INVALID_PARAMETER;
         } else if (Handle2 != NULL && EFI_ERROR(gBS->OpenProtocol(Handle2, &gEfiDriverBindingProtocolGuid, NULL, gImageHandle, NULL, EFI_OPEN_PROTOCOL_TEST_PROTOCOL))) {
           ASSERT(Param2 != NULL);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Drivers.c

-              r48674
+              r58459
   Main file for Drivers shell Driver1 function.
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2012-2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellDriver1CommandsLib.h"
+#define MAX_LEN_DRIVER_NAME 35
 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
 …
   RetVal = gEfiShellProtocol->GetFilePathFromDevicePath(FinalPath);
   if (RetVal == NULL) {
     RetVal = gDevPathToText->ConvertDevicePathToText(FinalPath, TRUE, TRUE);
+    RetVal = ConvertDevicePathToText(FinalPath, TRUE, TRUE);
+  }
   FreePool(FinalPath);
 …
   UINTN               DeviceCount;
   CHAR16              *Temp2;
+  CONST CHAR16        *FullDriverName;
+  CHAR16              *TruncatedDriverName;
   CHAR16              *FormatString;
   UINT32              DriverVersion;
   BOOLEAN             DriverConfig;
   BOOLEAN             DriverDiag;
+  BOOLEAN             SfoFlag;
   ShellStatus         = SHELL_SUCCESS;
 …
   Language            = NULL;
   FormatString        = NULL;
+  SfoFlag             = FALSE;
   //
 …
       ShellStatus = SHELL_INVALID_PARAMETER;
     } else {
+      Lang = ShellCommandLineGetValue(Package, L"-l");
+      if (Lang != NULL) {
+        Language = AllocateZeroPool(StrSize(Lang));
+        AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
+      } else if (!ShellCommandLineGetFlag(Package, L"-l")){
+        ASSERT(Language == NULL);
+  //      Language = AllocateZeroPool(10);
+  //      AsciiSPrint(Language, 10, "en-us");
+      if (ShellCommandLineGetFlag(Package, L"-l")){
+        Lang = ShellCommandLineGetValue(Package, L"-l");
+        if (Lang != NULL) {
+          Language = AllocateZeroPool(StrSize(Lang));
+          AsciiSPrint(Language, StrSize(Lang), "%S", Lang);
+        } else {
+          ASSERT(Language == NULL);
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
+          ShellCommandLineFreeVarList (Package);
+          return (SHELL_INVALID_PARAMETER);
+        }
+      }
+      if (ShellCommandLineGetFlag (Package, L"-sfo")) {
+        SfoFlag = TRUE;
+        FormatString = HiiGetString (gShellDriver1HiiHandle, STRING_TOKEN (STR_DRIVERS_ITEM_LINE_SFO), Language);
+        //
+        // print the SFO header
+        //
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          Language,
+          STRING_TOKEN (STR_GEN_SFO_HEADER),
+          gShellDriver1HiiHandle,
+          L"drivers");
       } else {
+        ASSERT(Language == NULL);
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_VALUE), gShellDriver1HiiHandle, L"-l");
+        ShellCommandLineFreeVarList (Package);
+        return (SHELL_INVALID_PARAMETER);
+      }
+      if (ShellCommandLineGetFlag(Package, L"-sfo")) {
+        FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE_SFO), Language);
+      } else {
+        FormatString = HiiGetString(gShellDriver1HiiHandle, STRING_TOKEN(STR_DRIVERS_ITEM_LINE), Language);
+        FormatString = HiiGetString (gShellDriver1HiiHandle, STRING_TOKEN (STR_DRIVERS_ITEM_LINE), Language);
         //
         // print the header row
 …
           -1,
           Language,
           STRING_TOKEN(STR_DRIVERS_HEADER_LINES),
+          STRING_TOKEN (STR_DRIVERS_HEADER_LINES),
           gShellDriver1HiiHandle);
+      }
 …
       HandleList = GetHandleListByProtocol(&gEfiDriverBindingProtocolGuid);
       for (HandleWalker = HandleList ; HandleWalker != NULL && *HandleWalker != NULL ; HandleWalker++){
+        ChildCount    = 0;
+        DeviceCount   = 0;
+        Status        = ParseHandleDatabaseForChildDevices (*HandleWalker, &ChildCount , NULL);
+        Status        = PARSE_HANDLE_DATABASE_DEVICES      (*HandleWalker, &DeviceCount, NULL);
+        Temp2         = GetDevicePathTextForHandle(*HandleWalker);
+        DriverVersion = ReturnDriverVersion(*HandleWalker);
+        DriverConfig  = ReturnDriverConfig(*HandleWalker);
+        DriverDiag    = ReturnDriverDiag  (*HandleWalker);
+        Lang          = GetStringNameFromHandle(*HandleWalker, Language==NULL?"en":Language);
+        ChildCount     = 0;
+        DeviceCount    = 0;
+        Status         = ParseHandleDatabaseForChildDevices (*HandleWalker, &ChildCount , NULL);
+        Status         = PARSE_HANDLE_DATABASE_DEVICES      (*HandleWalker, &DeviceCount, NULL);
+        Temp2          = GetDevicePathTextForHandle(*HandleWalker);
+        DriverVersion  = ReturnDriverVersion(*HandleWalker);
+        DriverConfig   = ReturnDriverConfig(*HandleWalker);
+        DriverDiag     = ReturnDriverDiag  (*HandleWalker);
+        FullDriverName = GetStringNameFromHandle(*HandleWalker, Language);
+        TruncatedDriverName = NULL;
+        if (!SfoFlag && (FullDriverName != NULL)) {
+          TruncatedDriverName = AllocateZeroPool ((MAX_LEN_DRIVER_NAME + 1) * sizeof (CHAR16));
+          StrnCpy (TruncatedDriverName, FullDriverName, MAX_LEN_DRIVER_NAME);
+        }
         ShellPrintEx(
 …
           DeviceCount,
           ChildCount,
           Lang,
+          SfoFlag?FullDriverName:TruncatedDriverName,
           Temp2==NULL?L"":Temp2
          );
+        if (TruncatedDriverName != NULL) {
+          FreePool (TruncatedDriverName);
+        }
         if (Temp2 != NULL) {
           FreePool(Temp2);
+        }
+        if (ShellGetExecutionBreakFlag ()) {
+          ShellStatus = SHELL_ABORTED;
+          break;
+        }
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/DrvCfg.c

-              r48674
+              r58459
   Main file for DrvCfg shell Driver1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
                 // print out an error.
                 //
                 TempDevPathString = gDevPathToText->ConvertDevicePathToText((EFI_DEVICE_PATH_PROTOCOL*)(((CHAR8*)PackageHeader) + sizeof(EFI_HII_PACKAGE_HEADER)), TRUE, TRUE);
+                TempDevPathString = ConvertDevicePathToText((EFI_DEVICE_PATH_PROTOCOL*)(((CHAR8*)PackageHeader) + sizeof(EFI_HII_PACKAGE_HEADER)), TRUE, TRUE);
                 ShellPrintHiiEx(
                   -1,
 …
   default:
     return (EFI_INVALID_PARAMETER);
-    break;
+  }
 …
   if (!Found) {
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE), gShellDriver1HiiHandle);
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DRVCFG_NONE_FOUND), gShellDriver1HiiHandle);
     return (SHELL_SUCCESS);
+  }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/DrvDiag.c

-              r48674
+              r58459
   Main file for DrvDiag shell Driver1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   UINTN                               HandleIndex2;
   CHAR8                               *Language;
-  CHAR8                               *TempChar;
   BOOLEAN                             Found;
 …
                 NULL,
                 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+              if (!EFI_ERROR(Status)) {
+                if (Lang == NULL) {
+                  Language = AllocateZeroPool(AsciiStrSize(DriverDiagnostics2->SupportedLanguages));
+                  if (Language == NULL) {
+                    return (EFI_OUT_OF_RESOURCES);
+                  }
+                  AsciiStrCpy(Language, DriverDiagnostics2->SupportedLanguages);
+                  TempChar = AsciiStrStr(Language, ";");
+                  if (TempChar != NULL){
+                    *TempChar = CHAR_NULL;
+                  }
+                } else {
+                  Language = AllocateZeroPool(AsciiStrSize(Lang));
+                  if (Language == NULL) {
+                    return (EFI_OUT_OF_RESOURCES);
+                  }
+                  AsciiStrCpy(Language, Lang);
+                }
+              if (!EFI_ERROR(Status) && (DriverDiagnostics2 != NULL)) {
+                Language = GetBestLanguageForDriver(DriverDiagnostics2->SupportedLanguages, Lang, FALSE);
                 Found = TRUE;
                 Status = DriverDiagnostics2->RunDiagnostics(
 …
                 EFI_OPEN_PROTOCOL_GET_PROTOCOL);
               if (!EFI_ERROR(Status)) {
+                if (Lang == NULL) {
+                  Language = AllocateZeroPool(AsciiStrSize(DriverDiagnostics2->SupportedLanguages));
+                  if (Language == NULL) {
+                    return (EFI_OUT_OF_RESOURCES);
+                  }
+                  AsciiStrCpy(Language, DriverDiagnostics2->SupportedLanguages);
+                  TempChar = AsciiStrStr(Language, ";");
+                  if (TempChar != NULL){
+                    *TempChar = CHAR_NULL;
+                  }
+                } else {
+                  Language = AllocateZeroPool(AsciiStrSize(Lang));
+                  if (Language == NULL) {
+                    return (EFI_OUT_OF_RESOURCES);
+                  }
+                  AsciiStrCpy(Language, Lang);
+                }
+                Language = GetBestLanguageForDriver(DriverDiagnostics->SupportedLanguages, Lang, FALSE);
                 Status = DriverDiagnostics->RunDiagnostics(
                   DriverDiagnostics,

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/OpenInfo.c

-              r48674
+              r58459
   UINTN                               HandleIndex;
   CONST CHAR16                        *Name;
+  UINTN                               ControllerIndex;
   if (TheHandle == NULL) {
 …
             default:                                    OpenTypeString = StringUnknown;   break;
+          }
+          HandleIndex = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].AgentHandle);
+          Name        = GetStringNameFromHandle(OpenInfo[OpenInfoIndex].AgentHandle, "en");
+          if (OpenInfo[OpenInfoIndex].ControllerHandle!=NULL) {
+          HandleIndex     = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].AgentHandle);
+          Name            = GetStringNameFromHandle(OpenInfo[OpenInfoIndex].AgentHandle, NULL);
+          ControllerIndex = ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].ControllerHandle);
+          if (ControllerIndex != 0) {
             ShellPrintHiiEx(
               -1,
 …
               gShellDriver1HiiHandle,
               HandleIndex,
               ConvertHandleToHandleIndex(OpenInfo[OpenInfoIndex].ControllerHandle),
+              ControllerIndex,
               OpenInfo[OpenInfoIndex].OpenCount,
               OpenTypeString,

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/UefiShellDriver1CommandsLib.c

r48674	r58459
2	2	Main file for NULL named library for level 1 shell command functions.
3	3
4		Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
	4	Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
5	5	This program and the accompanying materials
6	6	are licensed and made available under the terms and conditions of the BSD License

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/UefiShellDriver1CommandsLib.h

-              r48674
+              r58459
   Main file for NULL named library for Profile1 shell command functions.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Guid/ConsoleOutDevice.h>
 #include <Guid/ShellLibHiiGuid.h>
+#include <IndustryStandard/Pci.h>
 #include <Protocol/EfiShell.h>
 …
 #include <Protocol/LoadedImage.h>
 #include <Protocol/UnicodeCollation.h>
-#include <Protocol/DevicePathToText.h>
 #include <Protocol/DriverDiagnostics2.h>
 #include <Protocol/DriverDiagnostics.h>
 …
 #include <Protocol/DriverFamilyOverride.h>
 #include <Protocol/DriverHealth.h>
+#include <Protocol/PciIo.h>
+#include <Protocol/PciRootBridgeIo.h>
 #include <Library/BaseLib.h>
 …
 #include <Library/HandleParsingLib.h>
 #include <Library/PeCoffGetEntryPointLib.h>
+#include <Library/HandleParsingLib.h>

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/UefiShellDriver1CommandsLib.inf

-              r48674
+              r58459
 # Provides shell driver1 profile functions
+#
 # Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved.<BR>
+#
 #  This program and the accompanying materials
 …
 [Pcd]
   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask  # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask  ## CONSUMES
 [Protocols]
   gEfiDriverHealthProtocolGuid                    # ALWAYS_CONSUMED
   gEfiDriverFamilyOverrideProtocolGuid            # ALWAYS_CONSUMED
   gEfiHiiConfigAccessProtocolGuid                 # ALWAYS_CONSUMED
   gEfiHiiDatabaseProtocolGuid                     # ALWAYS_CONSUMED
+  gEfiDriverHealthProtocolGuid                    ## CONSUMES
+  gEfiDriverFamilyOverrideProtocolGuid            ## CONSUMES
+  gEfiHiiConfigAccessProtocolGuid                 ## CONSUMES
+  gEfiHiiDatabaseProtocolGuid                     ## CONSUMES
 [Guids]
   gEfiGlobalVariableGuid                          # ALWAYS_CONSUMED
   gEfiConsoleInDeviceGuid                         # ALWAYS_CONSUMED
   gEfiConsoleOutDeviceGuid                        # ALWAYS_CONSUMED
   gShellDriver1HiiGuid                            ## PRODUCES
+  gEfiGlobalVariableGuid                          ## CONSUMES ## GUID
+  gEfiConsoleInDeviceGuid                         ## CONSUMES ## GUID
+  gEfiConsoleOutDeviceGuid                        ## CONSUMES ## GUID
+  gShellDriver1HiiGuid                            ## PRODUCES ## HII

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellDriver1CommandsLib/Unload.c

-              r48674
+              r58459
   Main file for Unload shell Driver1 function.
   Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2010 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellDriver1CommandsLib.h"
-/**
-  Function to translate the EFI_MEMORY_TYPE into a string.
-  @param[in] Memory     The memory type.
-  @retval               A string representation of the type allocated from BS Pool.
-**/
-CHAR16*
-EFIAPI
-ConvertMemoryType (
-  IN CONST EFI_MEMORY_TYPE Memory
+  )
+{
-  CHAR16 *RetVal;
-  RetVal = NULL;
-  switch (Memory) {
-  case EfiReservedMemoryType:       StrnCatGrow(&RetVal, NULL, L"EfiReservedMemoryType", 0);        break;
-  case EfiLoaderCode:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderCode", 0);                break;
-  case EfiLoaderData:               StrnCatGrow(&RetVal, NULL, L"EfiLoaderData", 0);                break;
-  case EfiBootServicesCode:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesCode", 0);          break;
-  case EfiBootServicesData:         StrnCatGrow(&RetVal, NULL, L"EfiBootServicesData", 0);          break;
-  case EfiRuntimeServicesCode:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesCode", 0);       break;
-  case EfiRuntimeServicesData:      StrnCatGrow(&RetVal, NULL, L"EfiRuntimeServicesData", 0);       break;
-  case EfiConventionalMemory:       StrnCatGrow(&RetVal, NULL, L"EfiConventionalMemory", 0);        break;
-  case EfiUnusableMemory:           StrnCatGrow(&RetVal, NULL, L"EfiUnusableMemory", 0);            break;
-  case EfiACPIReclaimMemory:        StrnCatGrow(&RetVal, NULL, L"EfiACPIReclaimMemory", 0);         break;
-  case EfiACPIMemoryNVS:            StrnCatGrow(&RetVal, NULL, L"EfiACPIMemoryNVS", 0);             break;
-  case EfiMemoryMappedIO:           StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIO", 0);            break;
-  case EfiMemoryMappedIOPortSpace:  StrnCatGrow(&RetVal, NULL, L"EfiMemoryMappedIOPortSpace", 0);   break;
-  case EfiPalCode:                  StrnCatGrow(&RetVal, NULL, L"EfiPalCode", 0);                   break;
-  case EfiMaxMemoryType:            StrnCatGrow(&RetVal, NULL, L"EfiMaxMemoryType", 0);             break;
-  default: ASSERT(FALSE);
+  }
-  return (RetVal);
+}
 /**
 …
+  )
+{
+  EFI_LOADED_IMAGE_PROTOCOL         *Image;
+  EFI_STATUS                        Status;
+  EFI_DEVICE_PATH_TO_TEXT_PROTOCOL  *DevicePathToText;
+  CHAR16                            *DevicePathText;
+  CHAR16                            *CodeTypeText;
+  CHAR16                            *DataTypeText;
+  CHAR8                             *PdbPointer;
+  CHAR16 *TheString;
+  Image = NULL;
+  TheString = GetProtocolInformationDump(TheHandle, &gEfiLoadedImageProtocolGuid, TRUE);
+  ShellPrintEx(-1, -1, L"%s", TheString);
+  Status = gBS->OpenProtocol(TheHandle, &gEfiLoadedImageProtocolGuid, (VOID**)&Image, gImageHandle, NULL, EFI_OPEN_PROTOCOL_GET_PROTOCOL);
+  if (EFI_ERROR(Status)) {
+    return (EFI_INVALID_PARAMETER);
+  }
+  Status = gBS->LocateProtocol(
+    &gEfiDevicePathToTextProtocolGuid,
+    NULL,
+    (VOID**)&DevicePathToText);
+  //
+  // we now have the device path to text protocol
+  //
+  if (!EFI_ERROR(Status)) {
+    DevicePathText = DevicePathToText->ConvertDevicePathToText(Image->FilePath, TRUE, TRUE);
+  } else {
+    DevicePathText = NULL;
+  }
+  CodeTypeText = ConvertMemoryType(Image->ImageCodeType);
+  DataTypeText = ConvertMemoryType(Image->ImageDataType);
+  PdbPointer = (CHAR8*)PeCoffLoaderGetPdbPointer(Image->ImageBase);
+  ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_UNLOAD_VERBOSE), gShellDriver1HiiHandle,
+    ConvertHandleToHandleIndex(TheHandle),
+    TheHandle,
+    Image,
+    Image->ParentHandle,
+    Image->SystemTable,
+    Image->DeviceHandle,
+    DevicePathText,
+    PdbPointer,
+    Image->ImageBase,
+    Image->ImageSize,
+    CodeTypeText,
+    DataTypeText
+    );
+  SHELL_FREE_NON_NULL(DevicePathText);
+  SHELL_FREE_NON_NULL(CodeTypeText);
+  SHELL_FREE_NON_NULL(DataTypeText);
+  SHELL_FREE_NON_NULL(TheString);
   return (EFI_SUCCESS);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellInstall1CommandsLib/UefiShellInstall1CommandsLib.c

-              r48674
+              r58459
 **/
+#include "UefiShellInstall1CommandsLib.h"
+STATIC CONST CHAR16 mFileName[] = L"ShellCommands";
+EFI_HANDLE gShellInstall1HiiHandle = NULL;
+/**
+  Function to get the filename with help context if HII will not be used.
+  @return   The filename with help text in it.
+**/
+CONST CHAR16*
+EFIAPI
+ShellCommandGetManFileNameInstall1 (
+  VOID
+  )
+{
+  return (mFileName);
+}
+#include <Library/BcfgCommandLib.h>
 /**
 …
+  }
+  gShellInstall1HiiHandle = HiiAddPackages (&gShellInstall1HiiGuid, gImageHandle, UefiShellInstall1CommandsLibStrings, NULL);
+  if (gShellInstall1HiiHandle == NULL) {
+    return (EFI_DEVICE_ERROR);
+  }
+  //
+  // install our shell command handlers that are always installed
+  //
+  ShellCommandRegisterCommandName(L"bcfg", ShellCommandRunBcfgInstall , ShellCommandGetManFileNameInstall1, 0, L"Install", FALSE, gShellInstall1HiiHandle, STRING_TOKEN(STR_GET_HELP_BCFG));
+  return (EFI_SUCCESS);
+  return (BcfgLibraryRegisterBcfgCommand(ImageHandle, SystemTable, L"Install1"));
+}
 …
+  )
+{
+  if (gShellInstall1HiiHandle != NULL) {
+    HiiRemovePackages(gShellInstall1HiiHandle);
+  }
+  return (EFI_SUCCESS);
+  return (BcfgLibraryUnregisterBcfgCommand(ImageHandle, SystemTable));
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellInstall1CommandsLib/UefiShellInstall1CommandsLib.inf

-              r48674
+              r58459
 #  Provides shell install1 functions
+#
 #  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
 [Sources.common]
   UefiShellInstall1CommandsLib.c
-  UefiShellInstall1CommandsLib.h
-  UefiShellInstall1CommandsLib.uni
-  Bcfg.c
 [Packages]
 …
   SortLib
   PrintLib
+  BcfgCommandLib
 [Pcd]
   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask ## CONSUMES
 [Guids]
   gShellInstall1HiiGuid
+  gShellInstall1HiiGuid                         ## UNDEFINED

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel1CommandsLib/For.c

-              r48674
+              r58459
   Main file for endfor and for shell level 1 functions.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
+  }
   return (FALSE);
+}
+/**
+  Function to determine whether a string is decimal or hex representation of a number
+  and return the number converted from the string.
+  @param[in] String   String representation of a number
+  @return             the number
+  @retval (UINTN)(-1) An error ocurred.
+**/
+UINTN
+EFIAPI
+ReturnUintn(
+  IN CONST CHAR16 *String
+  )
+{
+  UINT64        RetVal;
+  if (!EFI_ERROR(ShellConvertStringToUint64(String, &RetVal, FALSE, TRUE))) {
+    return ((UINTN)RetVal);
+  }
+  return ((UINTN)(-1));
+}
 …
   CHAR16              *ArgSet;
   CHAR16              *ArgSetWalker;
+  CHAR16              *Parameter;
   UINTN               ArgSize;
   UINTN               LoopVar;
 …
   ArgSetWalker        = NULL;
   TempString          = NULL;
+  Parameter           = NULL;
   FirstPass           = FALSE;
 …
   ASSERT(CurrentScriptFile != NULL);
   if (CurrentScriptFile->CurrentCommand->Data == NULL) {
+  if ((CurrentScriptFile->CurrentCommand != NULL) && (CurrentScriptFile->CurrentCommand->Data == NULL)) {
     FirstPass = TRUE;
 …
         L"EndFor",
         L"For",
+        CurrentScriptFile->CurrentCommand!=NULL
+          ?CurrentScriptFile->CurrentCommand->Line:0);
+        CurrentScriptFile->CurrentCommand->Line);
       return (SHELL_DEVICE_ERROR);
+    }
 …
       for (LoopVar = 0x3 ; LoopVar < gEfiShellParametersProtocol->Argc ; LoopVar++) {
         ASSERT((ArgSet == NULL && ArgSize == 0) || (ArgSet != NULL));
-        if (ArgSet == NULL) {
-  //        ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L"\"", 0);
-        } else {
-          ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L" \"", 0);
+        }
         if (StrStr(gEfiShellParametersProtocol->Argv[LoopVar], L"*") != NULL
           ||StrStr(gEfiShellParametersProtocol->Argv[LoopVar], L"?") != NULL
 …
           Status = ShellOpenFileMetaArg ((CHAR16*)gEfiShellParametersProtocol->Argv[LoopVar], EFI_FILE_MODE_READ, &FileList);
           if (EFI_ERROR(Status) || FileList == NULL || IsListEmpty(&FileList->Link)) {
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L" \"", 0);
             ArgSet = StrnCatGrow(&ArgSet, &ArgSize, gEfiShellParametersProtocol->Argv[LoopVar], 0);
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L"\"", 0);
           } else {
             for (Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&FileList->Link)
 …
+          }
         } else {
+          ArgSet = StrnCatGrow(&ArgSet, &ArgSize, gEfiShellParametersProtocol->Argv[LoopVar], 0);
+        }
+        ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L"\"", 0);
+          Parameter = gEfiShellParametersProtocol->Argv[LoopVar];
+          if (Parameter[0] == L'\"' && Parameter[StrLen(Parameter)-1] == L'\"') {
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L" ", 0);
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, Parameter, 0);
+          } else {
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L" \"", 0);
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, Parameter, 0);
+            ArgSet = StrnCatGrow(&ArgSet, &ArgSize, L"\"", 0);
+          }
+        }
+      }
       if (ArgSet == NULL) {
 …
         Info = AllocateZeroPool(sizeof(SHELL_FOR_INFO)+StrSize(gEfiShellParametersProtocol->Argv[1]));
         ASSERT(Info != NULL);
+        Info->Signature = SHELL_FOR_INFO_SIGNATURE;
         CopyMem(Info->Set, gEfiShellParametersProtocol->Argv[1], StrSize(gEfiShellParametersProtocol->Argv[1]));
         Info->ReplacementName = Info->Set;
 …
             gShellLevel1HiiHandle,
             ArgSet,
+            CurrentScriptFile!=NULL
+              && CurrentScriptFile->CurrentCommand!=NULL
+              ? CurrentScriptFile->CurrentCommand->Line:0);
+            CurrentScriptFile->CurrentCommand->Line);
           ShellStatus = SHELL_INVALID_PARAMETER;
         } else {
 …
               STRING_TOKEN (STR_GEN_PROBLEM_SCRIPT),
               gShellLevel1HiiHandle,
+              CurrentScriptFile!=NULL
+                && CurrentScriptFile->CurrentCommand!=NULL
+                ? CurrentScriptFile->CurrentCommand->Line:0);
+              CurrentScriptFile->CurrentCommand->Line);
             ShellStatus = SHELL_INVALID_PARAMETER;
           } else {
 …
                 gShellLevel1HiiHandle,
                 ArgSet,
+                CurrentScriptFile!=NULL
+                  && CurrentScriptFile->CurrentCommand!=NULL
+                  ? CurrentScriptFile->CurrentCommand->Line:0);
+                CurrentScriptFile->CurrentCommand->Line);
               ShellStatus = SHELL_INVALID_PARAMETER;
             } else {
               if (ArgSetWalker[0] == L'-') {
                 Info->Current = 0 - (INTN)ShellStrToUintn(ArgSetWalker+1);
+                Info->Current = 0 - (INTN)ReturnUintn(ArgSetWalker+1);
               } else {
                 Info->Current = (INTN)ShellStrToUintn(ArgSetWalker);
+                Info->Current = (INTN)ReturnUintn(ArgSetWalker);
+              }
               ArgSetWalker  = StrStr(ArgSetWalker, L" ");
 …
                   gShellLevel1HiiHandle,
                   ArgSet,
+                  CurrentScriptFile!=NULL
+                    && CurrentScriptFile->CurrentCommand!=NULL
+                    ? CurrentScriptFile->CurrentCommand->Line:0);
+                  CurrentScriptFile->CurrentCommand->Line);
                 ShellStatus = SHELL_INVALID_PARAMETER;
               } else {
                 if (ArgSetWalker[0] == L'-') {
                   Info->End = 0 - (INTN)ShellStrToUintn(ArgSetWalker+1);
+                  Info->End = 0 - (INTN)ReturnUintn(ArgSetWalker+1);
                 } else {
                   Info->End = (INTN)ShellStrToUintn(ArgSetWalker);
+                  Info->End = (INTN)ReturnUintn(ArgSetWalker);
+                }
                 if (Info->Current < Info->End) {
 …
                       gShellLevel1HiiHandle,
                       ArgSet,
+                      CurrentScriptFile!=NULL
+                        && CurrentScriptFile->CurrentCommand!=NULL
+                        ? CurrentScriptFile->CurrentCommand->Line:0);
+                      CurrentScriptFile->CurrentCommand->Line);
                     ShellStatus = SHELL_INVALID_PARAMETER;
                   } else {
 …
                     } else {
                       if (ArgSetWalker[0] == L'-') {
                         Info->Step = 0 - (INTN)ShellStrToUintn(ArgSetWalker+1);
+                        Info->Step = 0 - (INTN)ReturnUintn(ArgSetWalker+1);
                       } else {
                         Info->Step = (INTN)ShellStrToUintn(ArgSetWalker);
+                        Info->Step = (INTN)ReturnUintn(ArgSetWalker);
+                      }
 …
                           gShellLevel1HiiHandle,
                           ArgSet,
+                          CurrentScriptFile!=NULL
+                            && CurrentScriptFile->CurrentCommand!=NULL
+                            ? CurrentScriptFile->CurrentCommand->Line:0);
+                          CurrentScriptFile->CurrentCommand->Line);
                         ShellStatus = SHELL_INVALID_PARAMETER;
+                      }
 …
       ASSERT(Info->Set != NULL);
       if (Info->CurrentValue != NULL && *Info->CurrentValue != CHAR_NULL) {
         if (Info->CurrentValue[0] == L'\"') {
+        if (Info->CurrentValue[0] == L' ') {
           Info->CurrentValue++;
+        }
-//        while (Info->CurrentValue[0] == L' ') {
-//          Info->CurrentValue++;
-//        }
         if (Info->CurrentValue[0] == L'\"') {
           Info->CurrentValue++;
 …
             Info->CurrentValue++;
+          }
-          while (Info->CurrentValue[0] == L' ') {
-            Info->CurrentValue++;
+          }
-          if (Info->CurrentValue[0] == L'\"') {
-            Info->CurrentValue++;
+          }
           FreePool(TempString);
+        }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel1CommandsLib/If.c

-              r48674
+              r58459
   Main file for If and else shell level 1 function.
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
+    }
     return (FALSE);
-    break;
   case OperatorUnsignedLessThan:
   case OperatorLessThan:
 …
+    }
     return (FALSE);
-    break;
   case OperatorEqual:
     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 …
+    }
     return (FALSE);
-    break;
   case OperatorNotEqual:
     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 …
+    }
     return (FALSE);
-    break;
   case OperatorUnsignedGreaterOrEqual:
   case OperatorGreatorOrEqual:
 …
+    }
     return (FALSE);
-    break;
   case OperatorLessOrEqual:
   case OperatorUnsignedLessOrEqual:
 …
+    }
     return (FALSE);
-    break;
   default:
     ASSERT(FALSE);
 …
+  )
+{
-  CHAR16    *Buffer;
-  UINTN     BufferSize;
   *EndTag = EndTagMax;
   for(Buffer = NULL, BufferSize = 0
+  for(
     ; ParameterNumber < gEfiShellParametersProtocol->Argc
     ; ParameterNumber++
 …
+    }
     CommandWalker = CommandName;
+    while (CommandWalker[0] == L' ') {
+    //
+    // Skip leading spaces and tabs.
+    //
+    while ((CommandWalker[0] == L' ') || (CommandWalker[0] == L'\t')) {
       CommandWalker++;
+    }
 …
       STRING_TOKEN (STR_SYNTAX_NO_MATCHING),
       gShellLevel1HiiHandle,
       L"EnfIf",
+      L"EndIf",
       L"If",
       CurrentScriptFile!=NULL

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel1CommandsLib/UefiShellLevel1CommandsLib.c

-              r48674
+              r58459
   Main file for NULL named library for level 1 shell command functions.
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
   CommandNameWalker = CommandName;
+  while(CommandNameWalker[0] == L' ') {
+  //
+  // Skip leading spaces and tabs.
+  //
+  while ((CommandNameWalker[0] == L' ') || (CommandNameWalker[0] == L'\t')) {
     CommandNameWalker++;
+  }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel1CommandsLib/UefiShellLevel1CommandsLib.h

-              r48674
+              r58459
   Main file for NULL named library for level 1 shell command functions.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Protocol/LoadedImage.h>
 #include <Protocol/UnicodeCollation.h>
-#include <Protocol/DevicePathToText.h>
 #include <Library/BaseLib.h>

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel1CommandsLib/UefiShellLevel1CommandsLib.inf

-              r48674
+              r58459
 #  Provides shell level 1 functions
+#
 #  Copyright (c) 2009-2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2009-2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
 [Pcd.common]
   gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel ## CONSUMES
 [Guids]
   gShellLevel1HiiGuid
+  gShellLevel1HiiGuid       ## SOMETIMES_CONSUMES ## HII

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Attrib.c

-              r48674
+              r58459
   Main file for attrib shell level 2 function.
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
                 FileNode->FileName
                );
+              if (ShellGetExecutionBreakFlag()) {
+                  ShellStatus = SHELL_ABORTED;
+                  break;
+              }
+            }
             Status = ShellCloseFileMetaArg(&ListOfFiles);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Cd.c

-              r48674
+              r58459
   Main file for attrib shell level 2 function.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   CONST CHAR16      *Param1;
   CHAR16            *Param1Copy;
+  CHAR16*           Walker;
   ProblemParam = NULL;
 …
     } else {
       Param1Copy = CatSPrint(NULL, L"%s", Param1, NULL);
+      for (Walker = Param1Copy; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
+        if (*Walker == L'\"') {
+          CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
+        }
+      }
       if (Param1Copy != NULL) {
         Param1Copy = PathCleanUpDirectories(Param1Copy);
 …
+          }
         } else if (StrStr(Param1Copy, L":") == NULL) {
+          //
+          // change directory without a drive identifier
+          //
           if (ShellGetCurrentDir(NULL) == NULL) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);
 …
         } else {
           //
           // change directory on other drive letter
           //
           Drive = AllocateZeroPool(StrSize(Param1Copy));
+          // change directory with a drive letter
+          //
+          Drive = AllocateCopyPool(StrSize(Param1Copy), Param1Copy);
           if (Drive == NULL) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellLevel2HiiHandle);
             ShellStatus = SHELL_OUT_OF_RESOURCES;
           } else {
-            Drive = StrCpy(Drive, Param1Copy);
             Path = StrStr(Drive, L":");
             ASSERT(Path != NULL);
+            if (*(Path+1) == CHAR_NULL) {
+            if (EFI_ERROR(ShellIsDirectory(Param1Copy))) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, Param1Copy);
+              ShellStatus = SHELL_NOT_FOUND;
+            } else if (*(Path+1) == CHAR_NULL) {
               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CD_NF), gShellLevel2HiiHandle);
               ShellStatus = SHELL_NOT_FOUND;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Cp.c

-              r48674
+              r58459
   Main file for cp shell level 2 function.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellLevel2CommandsLib.h"
+#include <Guid/FileSystemInfo.h>
+#include <Guid/FileSystemVolumeLabelInfo.h>
 /**
 …
+  )
+{
+  VOID                *Response;
+  UINTN               ReadSize;
+  SHELL_FILE_HANDLE   SourceHandle;
+  SHELL_FILE_HANDLE   DestHandle;
+  EFI_STATUS          Status;
+  VOID                *Buffer;
+  CHAR16              *TempName;
+  UINTN               Size;
+  EFI_SHELL_FILE_INFO *List;
+  SHELL_STATUS        ShellStatus;
+  VOID                  *Response;
+  UINTN                 ReadSize;
+  SHELL_FILE_HANDLE     SourceHandle;
+  SHELL_FILE_HANDLE     DestHandle;
+  EFI_STATUS            Status;
+  VOID                  *Buffer;
+  CHAR16                *TempName;
+  UINTN                 Size;
+  EFI_SHELL_FILE_INFO   *List;
+  SHELL_STATUS          ShellStatus;
+  UINT64                SourceFileSize;
+  UINT64                DestFileSize;
+  EFI_FILE_PROTOCOL     *DestVolumeFP;
+  EFI_FILE_SYSTEM_INFO  *DestVolumeInfo;
+  UINTN                 DestVolumeInfoSize;
   ASSERT(Resp != NULL);
+  SourceHandle  = NULL;
+  DestHandle    = NULL;
+  Response      = *Resp;
+  List          = NULL;
+  ReadSize = PcdGet16(PcdShellFileOperationSize);
+  SourceHandle    = NULL;
+  DestHandle      = NULL;
+  Response        = *Resp;
+  List            = NULL;
+  DestVolumeInfo  = NULL;
+  ShellStatus     = SHELL_SUCCESS;
+  ReadSize = PcdGet32(PcdShellFileOperationSize);
   // Why bother copying a file to itself
   if (StrCmp(Source, Dest) == 0) {
 …
   //
-  // Open destination file without create
-  //
-  Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, 0);
-  //
-  // close file
-  //
-  if (DestHandle != NULL) {
-    ShellCloseFile(&DestHandle);
-    DestHandle   = NULL;
+  }
-  //
   // if the destination file existed check response and possibly prompt user
   //
   if (!EFI_ERROR(Status)) {
+  if (ShellFileExists(Dest) == EFI_SUCCESS) {
     if (Response == NULL && !SilentMode) {
       Status = ShellPromptForResponseHii(ShellPromptResponseTypeYesNoAllCancel, STRING_TOKEN (STR_GEN_DEST_EXIST_OVR), gShellLevel2HiiHandle, &Response);
 …
     Status = ShellCreateDirectory(Dest, &DestHandle);
     if (EFI_ERROR(Status)) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_DIR_FAIL), gShellLevel2HiiHandle, Dest);
       return (SHELL_ACCESS_DENIED);
+    }
 …
     //
     TempName    = NULL;
     Size          = 0;
+    Size        = 0;
     StrnCatGrow(&TempName, &Size, Source, 0);
     StrnCatGrow(&TempName, &Size, L"\\*", 0);
+    ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List);
+    TempName = NULL;
+    StrnCatGrow(&TempName, &Size, Dest, 0);
+    StrnCatGrow(&TempName, &Size, L"\\", 0);
+    ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp);
+    ShellCloseFileMetaArg(&List);
+    FreePool(TempName);
+    Size = 0;
+    if (TempName != NULL) {
+      ShellOpenFileMetaArg((CHAR16*)TempName, EFI_FILE_MODE_READ, &List);
+      *TempName = CHAR_NULL;
+      StrnCatGrow(&TempName, &Size, Dest, 0);
+      StrnCatGrow(&TempName, &Size, L"\\", 0);
+      ShellStatus = ValidateAndCopyFiles(List, TempName, SilentMode, TRUE, Resp);
+      ShellCloseFileMetaArg(&List);
+      SHELL_FREE_NON_NULL(TempName);
+      Size = 0;
+    }
   } else {
+    Status = ShellDeleteFileByName(Dest);
     //
     // open file with create enabled
 …
     Status = ShellOpenFileByName(Dest, &DestHandle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE|EFI_FILE_MODE_CREATE, 0);
     if (EFI_ERROR(Status)) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_OPEN_FAIL), gShellLevel2HiiHandle, Dest);
       return (SHELL_ACCESS_DENIED);
+    }
 …
     //
+    // copy data between files
+    //
+    Buffer = AllocateZeroPool(ReadSize);
+    ASSERT(Buffer != NULL);
+    while (ReadSize == PcdGet16(PcdShellFileOperationSize) && !EFI_ERROR(Status)) {
+      Status = ShellReadFile(SourceHandle, &ReadSize, Buffer);
+      ASSERT_EFI_ERROR(Status);
+      Status = ShellWriteFile(DestHandle, &ReadSize, Buffer);
+    }
+  }
+    //get file size of source file and freespace available on destination volume
+    //
+    ShellGetFileSize(SourceHandle, &SourceFileSize);
+    ShellGetFileSize(DestHandle, &DestFileSize);
+    //
+    //if the destination file already exists then it will be replaced, meaning the sourcefile effectively needs less storage space
+    //
+    if(DestFileSize < SourceFileSize){
+      SourceFileSize -= DestFileSize;
+    } else {
+      SourceFileSize = 0;
+    }
+    //
+    //get the system volume info to check the free space
+    //
+    DestVolumeFP = ConvertShellHandleToEfiFileProtocol(DestHandle);
+    DestVolumeInfo = NULL;
+    DestVolumeInfoSize = 0;
+    Status = DestVolumeFP->GetInfo(
+      DestVolumeFP,
+      &gEfiFileSystemInfoGuid,
+      &DestVolumeInfoSize,
+      DestVolumeInfo
+      );
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      DestVolumeInfo = AllocateZeroPool(DestVolumeInfoSize);
+      Status = DestVolumeFP->GetInfo(
+        DestVolumeFP,
+        &gEfiFileSystemInfoGuid,
+        &DestVolumeInfoSize,
+        DestVolumeInfo
+        );
+    }
+    //
+    //check if enough space available on destination drive to complete copy
+    //
+    if (DestVolumeInfo!= NULL && (DestVolumeInfo->FreeSpace < SourceFileSize)) {
+      //
+      //not enough space on destination directory to copy file
+      //
+      SHELL_FREE_NON_NULL(DestVolumeInfo);
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_FAIL), gShellLevel2HiiHandle);
+      return(SHELL_VOLUME_FULL);
+    } else {
+      //
+      // copy data between files
+      //
+      Buffer = AllocateZeroPool(ReadSize);
+      ASSERT(Buffer != NULL);
+      while (ReadSize == PcdGet32(PcdShellFileOperationSize) && !EFI_ERROR(Status)) {
+        Status = ShellReadFile(SourceHandle, &ReadSize, Buffer);
+        if (!EFI_ERROR(Status)) {
+          Status = ShellWriteFile(DestHandle, &ReadSize, Buffer);
+          if (EFI_ERROR(Status)) {
+            ShellStatus = (SHELL_STATUS) (Status & (~MAX_BIT));
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_WRITE_ERROR), gShellLevel2HiiHandle, Dest);
+            break;
+          }
+        } else {
+          ShellStatus = (SHELL_STATUS) (Status & (~MAX_BIT));
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CPY_READ_ERROR), gShellLevel2HiiHandle, Source);
+          break;
+        }
+      }
+    }
+    SHELL_FREE_NON_NULL(DestVolumeInfo);
+  }
   //
   // close files
 …
   // return
   //
   return (SHELL_SUCCESS);
+  return ShellStatus;
+}
 …
   CONST EFI_SHELL_FILE_INFO *Node;
   SHELL_STATUS              ShellStatus;
+  EFI_STATUS                Status;
   CHAR16                    *DestPath;
   VOID                      *Response;
   UINTN                     PathLen;
+  UINTN                     PathSize;
   CONST CHAR16              *Cwd;
-  CONST CHAR16              *TempLocation;
   UINTN                     NewSize;
+  CHAR16                    *CleanFilePathStr;
   if (Resp == NULL) {
 …
+  }
+  DestPath    = NULL;
+  ShellStatus = SHELL_SUCCESS;
+  PathLen     = 0;
+  Cwd         = ShellGetCurrentDir(NULL);
+  DestPath         = NULL;
+  ShellStatus      = SHELL_SUCCESS;
+  PathSize         = 0;
+  Cwd              = ShellGetCurrentDir(NULL);
+  CleanFilePathStr = NULL;
   ASSERT(FileList != NULL);
   ASSERT(DestDir  != NULL);
+  //
+  // We already verified that this was present.
+  //
+  ASSERT(Cwd      != NULL);
+  Status = ShellLevel2StripQuotes (DestDir, &CleanFilePathStr);
+  if (EFI_ERROR (Status)) {
+    if (Status == EFI_OUT_OF_RESOURCES) {
+      return SHELL_OUT_OF_RESOURCES;
+    } else {
+      return SHELL_INVALID_PARAMETER;
+    }
+  }
+  ASSERT (CleanFilePathStr != NULL);
   //
   // If we are trying to copy multiple files... make sure we got a directory for the target...
   //
   if (EFI_ERROR(ShellIsDirectory(DestDir)) && FileList->Link.ForwardLink != FileList->Link.BackLink) {
+  if (EFI_ERROR(ShellIsDirectory(CleanFilePathStr)) && FileList->Link.ForwardLink != FileList->Link.BackLink) {
     //
     // Error for destination not a directory
     //
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, CleanFilePathStr);
+    FreePool (CleanFilePathStr);
     return (SHELL_INVALID_PARAMETER);
+  }
 …
     ;  !IsNull(&FileList->Link, &Node->Link)
     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
    ){
+    ){
     //
     // skip the directory traversing stuff...
 …
+    }
     NewSize =  StrSize(DestDir);
+    NewSize =  StrSize(CleanFilePathStr);
     NewSize += StrSize(Node->FullName);
     NewSize += StrSize(Cwd);
     if (NewSize > PathLen) {
       PathLen = NewSize;
+    NewSize += (Cwd == NULL)? 0 : StrSize(Cwd);
+    if (NewSize > PathSize) {
+      PathSize = NewSize;
+    }
 …
     if (!RecursiveMode && !EFI_ERROR(ShellIsDirectory(Node->FullName))) {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DIR_REQ), gShellLevel2HiiHandle);
+      FreePool (CleanFilePathStr);
       return (SHELL_INVALID_PARAMETER);
+    }
 …
     // make sure got dest as dir if needed
     //
     if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(DestDir))) {
+    if (!EFI_ERROR(ShellIsDirectory(Node->FullName)) && EFI_ERROR(ShellIsDirectory(CleanFilePathStr))) {
       //
       // Error for destination not a directory
       //
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, DestDir);
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_DIR), gShellLevel2HiiHandle, CleanFilePathStr);
+      FreePool (CleanFilePathStr);
       return (SHELL_INVALID_PARAMETER);
+    }
 …
   HiiOutput   = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_CP_OUTPUT), NULL);
   HiiResultOk = HiiGetString (gShellLevel2HiiHandle, STRING_TOKEN (STR_GEN_RES_OK), NULL);
   DestPath    = AllocateZeroPool(PathLen);
+  DestPath    = AllocateZeroPool(PathSize);
   if (DestPath == NULL || HiiOutput == NULL || HiiResultOk == NULL) {
 …
     SHELL_FREE_NON_NULL(HiiOutput);
     SHELL_FREE_NON_NULL(HiiResultOk);
+    FreePool (CleanFilePathStr);
     return (SHELL_OUT_OF_RESOURCES);
+  }
 …
     ;  !IsNull(&FileList->Link, &Node->Link)
     ;  Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&FileList->Link, &Node->Link)
    ){
+    ){
     if (ShellGetExecutionBreakFlag()) {
       break;
 …
     if (FileList->Link.ForwardLink == FileList->Link.BackLink // 1 item
       && EFI_ERROR(ShellIsDirectory(DestDir))                 // not an existing directory
      ) {
       if (StrStr(DestDir, L":") == NULL) {
+      && EFI_ERROR(ShellIsDirectory(CleanFilePathStr))                 // not an existing directory
+      ) {
+      if (StrStr(CleanFilePathStr, L":") == NULL) {
         //
         // simple copy of a single file
         //
+        StrCpy(DestPath, Cwd);
+        if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
+          StrCat(DestPath, L"\\");
+        } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
+        if (Cwd != NULL) {
+          StrnCpy(DestPath, Cwd, PathSize/sizeof(CHAR16)-1);
+        } else {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, CleanFilePathStr);
+          FreePool (CleanFilePathStr);
+          return (SHELL_INVALID_PARAMETER);
+        }
+        if (DestPath[StrLen(DestPath)-1] != L'\\' && CleanFilePathStr[0] != L'\\') {
+          StrnCat(DestPath, L"\\", PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        } else if (DestPath[StrLen(DestPath)-1] == L'\\' && CleanFilePathStr[0] == L'\\') {
           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
+        }
         StrCat(DestPath, DestDir);
+        StrnCat(DestPath, CleanFilePathStr, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
       } else {
         StrCpy(DestPath, DestDir);
+        StrnCpy(DestPath, CleanFilePathStr, PathSize/sizeof(CHAR16) -1);
+      }
     } else {
 …
       // Check for leading slash
       //
       if (DestDir[0] == L'\\') {
+      if (CleanFilePathStr[0] == L'\\') {
          //
          // Copy to the root of CWD
          //
+        StrCpy(DestPath, Cwd);
+        if (Cwd != NULL) {
+          StrnCpy(DestPath, Cwd, PathSize/sizeof(CHAR16) -1);
+        } else {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, CleanFilePathStr);
+          FreePool(CleanFilePathStr);
+          return (SHELL_INVALID_PARAMETER);
+        }
         while (PathRemoveLastItem(DestPath));
+        StrCat(DestPath, DestDir+1);
+        StrCat(DestPath, Node->FileName);
+      } else if (StrStr(DestDir, L":") == NULL) {
+        StrCpy(DestPath, Cwd);
+        if (DestPath[StrLen(DestPath)-1] != L'\\' && DestDir[0] != L'\\') {
+          StrCat(DestPath, L"\\");
+        } else if (DestPath[StrLen(DestPath)-1] == L'\\' && DestDir[0] == L'\\') {
+        StrnCat(DestPath, CleanFilePathStr+1, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        StrnCat(DestPath, Node->FileName, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+      } else if (StrStr(CleanFilePathStr, L":") == NULL) {
+        if (Cwd != NULL) {
+          StrnCpy(DestPath, Cwd, PathSize/sizeof(CHAR16) -1);
+        } else {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_DIR_NF), gShellLevel2HiiHandle, CleanFilePathStr);
+          FreePool(CleanFilePathStr);
+          return (SHELL_INVALID_PARAMETER);
+        }
+        if (DestPath[StrLen(DestPath)-1] != L'\\' && CleanFilePathStr[0] != L'\\') {
+          StrnCat(DestPath, L"\\", PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        } else if (DestPath[StrLen(DestPath)-1] == L'\\' && CleanFilePathStr[0] == L'\\') {
           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
+        }
         StrCat(DestPath, DestDir);
         if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
           StrCat(DestPath, L"\\");
         } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
+        StrnCat(DestPath, CleanFilePathStr, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] != L'\\' && Node->FileName[0] != L'\\') {
+          StrnCat(DestPath, L"\\", PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        } else if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] == L'\\' && Node->FileName[0] == L'\\') {
           ((CHAR16*)DestPath)[StrLen(DestPath)-1] = CHAR_NULL;
+        }
         StrCat(DestPath, Node->FileName);
+        StrnCat(DestPath, Node->FileName, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
       } else {
         StrCpy(DestPath, DestDir);
         if (DestDir[StrLen(DestDir)-1] != L'\\' && Node->FileName[0] != L'\\') {
           StrCat(DestPath, L"\\");
         } else if (DestDir[StrLen(DestDir)-1] == L'\\' && Node->FileName[0] == L'\\') {
           ((CHAR16*)DestDir)[StrLen(DestDir)-1] = CHAR_NULL;
+        }
         StrCat(DestPath, Node->FileName);
+        StrnCpy(DestPath, CleanFilePathStr, PathSize/sizeof(CHAR16) -1);
+        if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] != L'\\' && Node->FileName[0] != L'\\') {
+          StrnCat(DestPath, L"\\", PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+        } else if (CleanFilePathStr[StrLen(CleanFilePathStr)-1] == L'\\' && Node->FileName[0] == L'\\') {
+          ((CHAR16*)CleanFilePathStr)[StrLen(CleanFilePathStr)-1] = CHAR_NULL;
+        }
+        StrnCat(DestPath, Node->FileName, PathSize/sizeof(CHAR16) - StrLen(DestPath) -1);
+      }
+    }
     //
     // Make sure the path exists
 …
       && !EFI_ERROR(ShellIsDirectory(DestPath))
       && StrniCmp(Node->FullName, DestPath, StrLen(DestPath)) == NULL
      ){
+      ){
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_PARENT), gShellLevel2HiiHandle);
       ShellStatus = SHELL_INVALID_PARAMETER;
 …
+    }
     if ((TempLocation = StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName))) == 0
+    if ((StrniCmp(Node->FullName, DestPath, StrLen(Node->FullName)) == 0)
       && (DestPath[StrLen(Node->FullName)] == CHAR_NULL || DestPath[StrLen(Node->FullName)] == L'\\')
      ) {
+      ) {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_SD_SAME), gShellLevel2HiiHandle);
       ShellStatus = SHELL_INVALID_PARAMETER;
 …
     PathCleanUpDirectories(DestPath);
+    ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath);
+    if (!SilentMode) {
+      ShellPrintEx(-1, -1, HiiOutput, Node->FullName, DestPath);
+    }
     //
 …
   SHELL_FREE_NON_NULL(HiiOutput);
   SHELL_FREE_NON_NULL(HiiResultOk);
+  SHELL_FREE_NON_NULL(CleanFilePathStr);
   if (Resp == NULL) {
     SHELL_FREE_NON_NULL(Response);
 …
   return (ShellStatus);
+}
 …
   SHELL_STATUS        ShellStatus;
   EFI_SHELL_FILE_INFO *List;
-  EFI_STATUS          Status;
   EFI_FILE_INFO       *FileInfo;
+  List = NULL;
+  Status = ShellOpenFileMetaArg((CHAR16*)DestDir, EFI_FILE_MODE_READ, &List);
+  CHAR16              *FullName;
+  List      = NULL;
+  FullName  = NULL;
+  FileInfo  = NULL;
+  ShellOpenFileMetaArg((CHAR16*)DestDir, EFI_FILE_MODE_READ, &List);
   if (List != NULL && List->Link.ForwardLink != List->Link.BackLink) {
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_MARG_ERROR), gShellLevel2HiiHandle, DestDir);
 …
     ASSERT(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink) != NULL);
     ASSERT(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->FullName != NULL);
-    FileInfo    = NULL;
     FileInfo = gEfiShellProtocol->GetFileInfo(((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->Handle);
     ASSERT(FileInfo != NULL);
+    StrnCatGrow(&FullName, NULL, ((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->FullName, 0);
+    ShellCloseFileMetaArg(&List);
     if ((FileInfo->Attribute & EFI_FILE_READ_ONLY) == 0) {
       ShellStatus = ValidateAndCopyFiles(FileList, ((EFI_SHELL_FILE_INFO *)List->Link.ForwardLink)->FullName, SilentMode, RecursiveMode, NULL);
+      ShellStatus = ValidateAndCopyFiles(FileList, FullName, SilentMode, RecursiveMode, NULL);
     } else {
       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_CP_DEST_ERROR), gShellLevel2HiiHandle);
       ShellStatus = SHELL_ACCESS_DENIED;
+    }
     SHELL_FREE_NON_NULL(FileInfo);
+  } else {
     ShellCloseFileMetaArg(&List);
+  } else {
+      ShellStatus = ValidateAndCopyFiles(FileList, DestDir, SilentMode, RecursiveMode, NULL);
+  }
+    ShellStatus = ValidateAndCopyFiles(FileList, DestDir, SilentMode, RecursiveMode, NULL);
+  }
+  SHELL_FREE_NON_NULL(FileInfo);
+  SHELL_FREE_NON_NULL(FullName);
   return (ShellStatus);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Load.c

-              r48674
+              r58459
   EFI_HANDLE                    LoadedDriverHandle;
   EFI_STATUS                    Status;
-  EFI_DEVICE_PATH_PROTOCOL      *Node;
   EFI_DEVICE_PATH_PROTOCOL      *FilePath;
   EFI_LOADED_IMAGE_PROTOCOL     *LoadedDriverImage;
 …
   LoadedDriverImage   = NULL;
   FilePath            = NULL;
-  Node                = NULL;
   LoadedDriverHandle  = NULL;
   Status              = EFI_SUCCESS;

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Ls.c

-              r48674
+              r58459
   Main file for ls shell level 2 function.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 - 2014, Hewlett-Packard Development Company, L.P.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include "UefiShellLevel2CommandsLib.h"
 #include <Guid/FileSystemInfo.h>
+/**
+  print out the standard format output volume entry.
+  @param[in] TheList           a list of files from the volume.
+**/
+EFI_STATUS
+EFIAPI
+PrintSfoVolumeInfoTableEntry(
+  IN CONST EFI_SHELL_FILE_INFO *TheList
+  )
+{
+  EFI_STATUS            Status;
+  EFI_SHELL_FILE_INFO   *Node;
+  CHAR16                *DirectoryName;
+  EFI_FILE_SYSTEM_INFO  *SysInfo;
+  UINTN                 SysInfoSize;
+  SHELL_FILE_HANDLE     ShellFileHandle;
+  EFI_FILE_PROTOCOL     *EfiFpHandle;
+  //
+  // Get the first valid handle (directories)
+  //
+  for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&TheList->Link)
+      ; !IsNull(&TheList->Link, &Node->Link) && Node->Handle == NULL
+      ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&TheList->Link, &Node->Link)
+     );
+  if (Node->Handle == NULL) {
+    DirectoryName = GetFullyQualifiedPath(((EFI_SHELL_FILE_INFO *)GetFirstNode(&TheList->Link))->FullName);
+    //
+    // We need to open something up to get system information
+    //
+    Status = gEfiShellProtocol->OpenFileByName(
+      DirectoryName,
+      &ShellFileHandle,
+      EFI_FILE_MODE_READ
+      );
+    ASSERT_EFI_ERROR(Status);
+    FreePool(DirectoryName);
+    //
+    // Get the Volume Info from ShellFileHandle
+    //
+    SysInfo     = NULL;
+    SysInfoSize = 0;
+    EfiFpHandle = ConvertShellHandleToEfiFileProtocol(ShellFileHandle);
+    Status = EfiFpHandle->GetInfo(
+      EfiFpHandle,
+      &gEfiFileSystemInfoGuid,
+      &SysInfoSize,
+      SysInfo
+      );
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      SysInfo = AllocateZeroPool(SysInfoSize);
+      Status = EfiFpHandle->GetInfo(
+        EfiFpHandle,
+        &gEfiFileSystemInfoGuid,
+        &SysInfoSize,
+        SysInfo
+        );
+    }
+    ASSERT_EFI_ERROR(Status);
+    gEfiShellProtocol->CloseFile(ShellFileHandle);
+  } else {
+    //
+    // Get the Volume Info from Node->Handle
+    //
+    SysInfo = NULL;
+    SysInfoSize = 0;
+    EfiFpHandle = ConvertShellHandleToEfiFileProtocol(Node->Handle);
+    Status = EfiFpHandle->GetInfo(
+      EfiFpHandle,
+      &gEfiFileSystemInfoGuid,
+      &SysInfoSize,
+      SysInfo
+      );
+    if (Status == EFI_BUFFER_TOO_SMALL) {
+      SysInfo = AllocateZeroPool(SysInfoSize);
+      Status = EfiFpHandle->GetInfo(
+        EfiFpHandle,
+        &gEfiFileSystemInfoGuid,
+        &SysInfoSize,
+        SysInfo
+        );
+    }
+    ASSERT_EFI_ERROR(Status);
+  }
+  ShellPrintHiiEx (
+    -1,
+    -1,
+    NULL,
+    STRING_TOKEN (STR_GEN_SFO_HEADER),
+    gShellLevel2HiiHandle,
+    L"ls"
+    );
+  //
+  // print VolumeInfo table
+  //
+  ASSERT(SysInfo != NULL);
+  ShellPrintHiiEx (
+,
+    gST->ConOut->Mode->CursorRow,
+    NULL,
+    STRING_TOKEN (STR_LS_SFO_VOLINFO),
+    gShellLevel2HiiHandle,
+    SysInfo->VolumeLabel,
+    SysInfo->VolumeSize,
+    SysInfo->ReadOnly?L"TRUE":L"FALSE",
+    SysInfo->FreeSpace,
+    SysInfo->BlockSize
+    );
+  SHELL_FREE_NON_NULL(SysInfo);
+  return (Status);
+}
+/**
+  print out the info on a single file.
+  @param[in] Sfo      TRUE if in SFO, false otherwise.
+  @param[in] TheNode  the EFI_SHELL_FILE_INFO node to print out information on.
+  @param[in] Files    incremented if a file is printed.
+  @param[in] Size     incremented by file size.
+  @param[in] Dirs     incremented if a directory is printed.
+**/
+VOID
+EFIAPI
+PrintFileInformation(
+  IN CONST BOOLEAN              Sfo,
+  IN CONST EFI_SHELL_FILE_INFO  *TheNode,
+  IN UINT64                     *Files,
+  IN UINT64                     *Size,
+  IN UINT64                     *Dirs
+  )
+{
+  ASSERT(Files    != NULL);
+  ASSERT(Size     != NULL);
+  ASSERT(Dirs     != NULL);
+  ASSERT(TheNode  != NULL);
+  if (Sfo) {
+    //
+    // Print the FileInfo Table
+    //
+    ShellPrintHiiEx (
+,
+      gST->ConOut->Mode->CursorRow,
+      NULL,
+      STRING_TOKEN (STR_LS_SFO_FILEINFO),
+      gShellLevel2HiiHandle,
+      TheNode->FullName,
+      TheNode->Info->FileSize,
+      TheNode->Info->PhysicalSize,
+      (TheNode->Info->Attribute & EFI_FILE_ARCHIVE)   != 0?L"a":L"",
+      (TheNode->Info->Attribute & EFI_FILE_DIRECTORY) != 0?L"d":L"",
+      (TheNode->Info->Attribute & EFI_FILE_HIDDEN)    != 0?L"h":L"",
+      (TheNode->Info->Attribute & EFI_FILE_READ_ONLY) != 0?L"r":L"",
+      (TheNode->Info->Attribute & EFI_FILE_SYSTEM)    != 0?L"s":L"",
+      TheNode->Info->CreateTime.Hour,
+      TheNode->Info->CreateTime.Minute,
+      TheNode->Info->CreateTime.Second,
+      TheNode->Info->CreateTime.Day,
+      TheNode->Info->CreateTime.Month,
+      TheNode->Info->CreateTime.Year,
+      TheNode->Info->LastAccessTime.Hour,
+      TheNode->Info->LastAccessTime.Minute,
+      TheNode->Info->LastAccessTime.Second,
+      TheNode->Info->LastAccessTime.Day,
+      TheNode->Info->LastAccessTime.Month,
+      TheNode->Info->LastAccessTime.Year,
+      TheNode->Info->ModificationTime.Hour,
+      TheNode->Info->ModificationTime.Minute,
+      TheNode->Info->ModificationTime.Second,
+      TheNode->Info->ModificationTime.Day,
+      TheNode->Info->ModificationTime.Month,
+      TheNode->Info->ModificationTime.Year
+      );
+  } else {
+    //
+    // print this one out...
+    // first print the universal start, next print the type specific name format, last print the CRLF
+    //
+    ShellPrintHiiEx (
+      -1,
+      -1,
+      NULL,
+      STRING_TOKEN (STR_LS_LINE_START_ALL),
+      gShellLevel2HiiHandle,
+      &TheNode->Info->ModificationTime,
+      (TheNode->Info->Attribute & EFI_FILE_DIRECTORY) != 0?L"<DIR>":L"",
+      (TheNode->Info->Attribute & EFI_FILE_READ_ONLY) != 0?L'r':L' ',
+      TheNode->Info->FileSize
+      );
+    if (TheNode->Info->Attribute & EFI_FILE_DIRECTORY) {
+      (*Dirs)++;
+      ShellPrintHiiEx (
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN (STR_LS_LINE_END_DIR),
+        gShellLevel2HiiHandle,
+        TheNode->FileName
+        );
+    } else {
+      (*Files)++;
+      (*Size) += TheNode->Info->FileSize;
+      if ( (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)L".nsh", (CHAR16*)&(TheNode->FileName[StrLen (TheNode->FileName) - 4])) == 0)
+        || (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)L".efi", (CHAR16*)&(TheNode->FileName[StrLen (TheNode->FileName) - 4])) == 0)
+       ){
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN (STR_LS_LINE_END_EXE),
+          gShellLevel2HiiHandle,
+          TheNode->FileName
+          );
+      } else {
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN (STR_LS_LINE_END_FILE),
+          gShellLevel2HiiHandle,
+          TheNode->FileName
+          );
+      }
+    }
+  }
+}
+/**
+  print out the header when not using standard format output.
+  @param[in] Path           String with starting path.
+**/
+VOID
+EFIAPI
+PrintNonSfoHeader(
+  IN CONST CHAR16 *Path
+  )
+{
+  CHAR16 *DirectoryName;
+  //
+  // get directory name from path...
+  //
+  DirectoryName = GetFullyQualifiedPath(Path);
+  if (DirectoryName != NULL) {
+    //
+    // print header
+    //
+    ShellPrintHiiEx (
+,
+      gST->ConOut->Mode->CursorRow,
+      NULL,
+      STRING_TOKEN (STR_LS_HEADER_LINE1),
+      gShellLevel2HiiHandle,
+      DirectoryName
+      );
+    SHELL_FREE_NON_NULL(DirectoryName);
+  }
+}
+/**
+  print out the footer when not using standard format output.
+  @param[in] Files            The number of files.
+  @param[in] Size             The size of files in bytes.
+  @param[in] Dirs             The number of directories.
+**/
+VOID
+EFIAPI
+PrintNonSfoFooter(
+  IN UINT64                     Files,
+  IN UINT64                     Size,
+  IN UINT64                     Dirs
+  )
+{
+  //
+  // print footer
+  //
+  ShellPrintHiiEx (
+    -1,
+    -1,
+    NULL,
+    STRING_TOKEN (STR_LS_FOOTER_LINE),
+    gShellLevel2HiiHandle,
+    Files,
+    Size,
+    Dirs
+   );
+}
 /**
 …
                             If 0 then all non-system and non-hidden files will be printed.
   @param[in] Sfo            TRUE to use Standard Format Output, FALSE otherwise
+  @param[in] Path           String with starting path.
+  @param[in] First          TRUE for the original and FALSE for any recursion spawned instances.
+  @param[in] RootPath       String with starting path to search in.
+  @param[in] SearchString   String with search string.
+  @param[in] Found          Set to TRUE, if anyone were found.
   @param[in] Count          The count of bits enabled in Attribs.
   @param[in] TimeZone       The current time zone offset.
 …
   IN CONST UINT64  Attribs,
   IN CONST BOOLEAN Sfo,
+  IN CONST CHAR16  *Path,
+  IN CONST BOOLEAN First,
+  IN CONST CHAR16  *RootPath,
+  IN CONST CHAR16  *SearchString,
+  IN       BOOLEAN *Found,
   IN CONST UINTN   Count,
   IN CONST INT16   TimeZone
 …
   UINT64                DirCount;
   UINT64                FileSize;
-  CHAR16                *DirectoryName;
   UINTN                 LongestPath;
-  EFI_FILE_SYSTEM_INFO  *SysInfo;
-  UINTN                 SysInfoSize;
-  SHELL_FILE_HANDLE     ShellFileHandle;
   CHAR16                *CorrectedPath;
+  EFI_FILE_PROTOCOL     *EfiFpHandle;
+  BOOLEAN               FoundOne;
+  BOOLEAN               HeaderPrinted;
+  HeaderPrinted = FALSE;
   FileCount     = 0;
   DirCount      = 0;
 …
   CorrectedPath = NULL;
+  CorrectedPath = StrnCatGrow(&CorrectedPath, NULL, Path, 0);
+  ASSERT(CorrectedPath != NULL);
+  if (Found != NULL) {
+    FoundOne = *Found;
+  } else {
+    FoundOne = FALSE;
+  }
+  CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, RootPath,     0);
+  if (CorrectedPath == NULL) {
+    return SHELL_OUT_OF_RESOURCES;
+  }
+  if (CorrectedPath[StrLen(CorrectedPath)-1] != L'\\'
+    &&CorrectedPath[StrLen(CorrectedPath)-1] != L'/') {
+    CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, L"\\",     0);
+  }
+  CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, SearchString, 0);
+  if (CorrectedPath == NULL) {
+    return (SHELL_OUT_OF_RESOURCES);
+  }
   PathCleanUpDirectories(CorrectedPath);
   Status = ShellOpenFileMetaArg((CHAR16*)CorrectedPath, EFI_FILE_MODE_READ, &ListHead);
+  if (EFI_ERROR(Status)) {
+    return (SHELL_DEVICE_ERROR);
+  }
+  if (ListHead == NULL || IsListEmpty(&ListHead->Link)) {
+    //
+    // On the first one only we expect to find something...
+    // do we find the . and .. directories otherwise?
+    //
+    if (First) {
+      return (SHELL_NOT_FOUND);
+    }
+    return (SHELL_SUCCESS);
+  }
+  if (Sfo && First) {
+    //
+    // Get the first valid handle (directories)
+    //
+    for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link)
+        ; !IsNull(&ListHead->Link, &Node->Link) && Node->Handle == NULL
+  if (!EFI_ERROR(Status)) {
+    if (ListHead == NULL || IsListEmpty(&ListHead->Link)) {
+      SHELL_FREE_NON_NULL(CorrectedPath);
+      return (SHELL_SUCCESS);
+    }
+    if (Sfo && Found == NULL) {
+      PrintSfoVolumeInfoTableEntry(ListHead);
+    }
+    for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link), LongestPath = 0
+        ; !IsNull(&ListHead->Link, &Node->Link)
         ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&ListHead->Link, &Node->Link)
+       );
+    if (Node->Handle == NULL) {
+      DirectoryName = GetFullyQualifiedPath(((EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link))->FullName);
+      //
+      // We need to open something up to get system information
+      //
+      Status = gEfiShellProtocol->OpenFileByName(
+        DirectoryName,
+        &ShellFileHandle,
+        EFI_FILE_MODE_READ);
+      ASSERT_EFI_ERROR(Status);
+      FreePool(DirectoryName);
+      //
+      // Get the Volume Info from ShellFileHandle
+      //
+      SysInfo     = NULL;
+      SysInfoSize = 0;
+      EfiFpHandle = ConvertShellHandleToEfiFileProtocol(ShellFileHandle);
+      Status = EfiFpHandle->GetInfo(
+        EfiFpHandle,
+        &gEfiFileSystemInfoGuid,
+        &SysInfoSize,
+        SysInfo);
+      if (Status == EFI_BUFFER_TOO_SMALL) {
+        SysInfo = AllocateZeroPool(SysInfoSize);
+        Status = EfiFpHandle->GetInfo(
+          EfiFpHandle,
+          &gEfiFileSystemInfoGuid,
+          &SysInfoSize,
+          SysInfo);
+        ){
+      if (ShellGetExecutionBreakFlag ()) {
+        ShellStatus = SHELL_ABORTED;
+        break;
+      }
+      ASSERT_EFI_ERROR(Status);
+      gEfiShellProtocol->CloseFile(ShellFileHandle);
+    } else {
+      //
+      // Get the Volume Info from Node->Handle
+      //
+      SysInfo = NULL;
+      SysInfoSize = 0;
+      EfiFpHandle = ConvertShellHandleToEfiFileProtocol(Node->Handle);
+      Status = EfiFpHandle->GetInfo(
+        EfiFpHandle,
+        &gEfiFileSystemInfoGuid,
+        &SysInfoSize,
+        SysInfo);
+      if (Status == EFI_BUFFER_TOO_SMALL) {
+        SysInfo = AllocateZeroPool(SysInfoSize);
+        Status = EfiFpHandle->GetInfo(
+          EfiFpHandle,
+          &gEfiFileSystemInfoGuid,
+          &SysInfoSize,
+          SysInfo);
+      ASSERT(Node != NULL);
+      if (LongestPath < StrSize(Node->FullName)) {
+        LongestPath = StrSize(Node->FullName);
+      }
+      ASSERT_EFI_ERROR(Status);
+    }
+    ShellPrintHiiEx (
+      -1,
+      -1,
+      NULL,
+      STRING_TOKEN (STR_GEN_SFO_HEADER),
+      gShellLevel2HiiHandle,
+      L"ls");
+    //
+    // print VolumeInfo table
+    //
+    ASSERT(SysInfo != NULL);
+    ShellPrintHiiEx (
+,
+      gST->ConOut->Mode->CursorRow,
+      NULL,
+      STRING_TOKEN (STR_LS_SFO_VOLINFO),
+      gShellLevel2HiiHandle,
+      SysInfo->VolumeLabel,
+      SysInfo->VolumeSize,
+      SysInfo->ReadOnly?L"TRUE":L"FALSE",
+      SysInfo->FreeSpace,
+      SysInfo->BlockSize
+     );
+    if (SysInfo != NULL) {
+      FreePool(SysInfo);
+    }
+  }
+  if (!Sfo) {
+    //
+    // get directory name from path...
+    //
+    DirectoryName = GetFullyQualifiedPath(CorrectedPath);
+    //
+    // print header
+    //
+    ShellPrintHiiEx (
+,
+      gST->ConOut->Mode->CursorRow,
+      NULL,
+      STRING_TOKEN (STR_LS_HEADER_LINE1),
+      gShellLevel2HiiHandle,
+      DirectoryName
+     );
+    FreePool(DirectoryName);
+  }
+  for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link)
+      ; !IsNull(&ListHead->Link, &Node->Link)
+      ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&ListHead->Link, &Node->Link)
+     ){
+    ASSERT(Node != NULL);
+    if (LongestPath < StrSize(Node->FullName)) {
+      LongestPath = StrSize(Node->FullName);
+    }
+    ASSERT(Node->Info != NULL);
+    ASSERT((Node->Info->Attribute & EFI_FILE_VALID_ATTR) == Node->Info->Attribute);
+    if (Attribs == 0) {
+      //
+      // NOT system & NOT hidden
+      //
+      if ( (Node->Info->Attribute & EFI_FILE_SYSTEM)
+        || (Node->Info->Attribute & EFI_FILE_HIDDEN)
+       ){
+        continue;
+      }
+    } else if (Attribs != EFI_FILE_VALID_ATTR) {
+      if (Count == 1) {
+      ASSERT(Node->Info != NULL);
+      ASSERT((Node->Info->Attribute & EFI_FILE_VALID_ATTR) == Node->Info->Attribute);
+      if (Attribs == 0) {
         //
+        // the bit must match
+        // NOT system & NOT hidden
+        //
+        if ( (Node->Info->Attribute & EFI_FILE_SYSTEM)
+          || (Node->Info->Attribute & EFI_FILE_HIDDEN)
+         ){
+          continue;
+        }
+      } else if ((Attribs != EFI_FILE_VALID_ATTR) ||
+                 (Count == 5)) {
+        //
+        // Only matches the bits which "Attribs" contains, not
+        // all files/directories with any of the bits.
+        // Count == 5 is used to tell the difference between a user
+        // specifying all bits (EX: -arhsda) and just specifying
+        // -a (means display all files with any attribute).
         //
         if ( (Node->Info->Attribute & Attribs) != Attribs) {
           continue;
+        }
-      } else {
-        //
-        // exact match on all bits
-        //
-        if ( (Node->Info->Attribute|EFI_FILE_ARCHIVE) != (Attribs|EFI_FILE_ARCHIVE)) {
-          continue;
+        }
+      }
+    }
+    if (Sfo) {
+      //
+      // Print the FileInfo Table
+      //
+    ShellPrintHiiEx (
+,
+      gST->ConOut->Mode->CursorRow,
+      NULL,
+      STRING_TOKEN (STR_LS_SFO_FILEINFO),
+      gShellLevel2HiiHandle,
+      Node->FullName,
+      Node->Info->FileSize,
+      Node->Info->PhysicalSize,
+      (Node->Info->Attribute & EFI_FILE_ARCHIVE)   != 0?L"a":L"",
+      (Node->Info->Attribute & EFI_FILE_DIRECTORY) != 0?L"d":L"",
+      (Node->Info->Attribute & EFI_FILE_HIDDEN)    != 0?L"h":L"",
+      (Node->Info->Attribute & EFI_FILE_READ_ONLY) != 0?L"r":L"",
+      (Node->Info->Attribute & EFI_FILE_SYSTEM)    != 0?L"s":L"",
+      Node->Info->CreateTime.Hour,
+      Node->Info->CreateTime.Minute,
+      Node->Info->CreateTime.Second,
+      Node->Info->CreateTime.Day,
+      Node->Info->CreateTime.Month,
+      Node->Info->CreateTime.Year,
+      Node->Info->LastAccessTime.Hour,
+      Node->Info->LastAccessTime.Minute,
+      Node->Info->LastAccessTime.Second,
+      Node->Info->LastAccessTime.Day,
+      Node->Info->LastAccessTime.Month,
+      Node->Info->LastAccessTime.Year,
+      Node->Info->ModificationTime.Hour,
+      Node->Info->ModificationTime.Minute,
+      Node->Info->ModificationTime.Second,
+      Node->Info->ModificationTime.Day,
+      Node->Info->ModificationTime.Month,
+      Node->Info->ModificationTime.Year
+     );
+    } else {
+      //
+      // print this one out...
+      // first print the universal start, next print the type specific name format, last print the CRLF
+      //
+      ShellPrintHiiEx (
+        -1,
+        -1,
+        NULL,
+        STRING_TOKEN (STR_LS_LINE_START_ALL),
+        gShellLevel2HiiHandle,
+        &Node->Info->ModificationTime,
+        (Node->Info->Attribute & EFI_FILE_DIRECTORY) != 0?L"<DIR>":L"",
+        (Node->Info->Attribute & EFI_FILE_READ_ONLY) != 0?L'r':L' ',
+        Node->Info->FileSize
+       );
+      if (Node->Info->Attribute & EFI_FILE_DIRECTORY) {
+        DirCount++;
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN (STR_LS_LINE_END_DIR),
+          gShellLevel2HiiHandle,
+          Node->FileName
+         );
+      } else {
+        FileCount++;
+        FileSize += Node->Info->FileSize;
+        if ( (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)L".nsh", (CHAR16*)&(Node->FileName[StrLen (Node->FileName) - 4])) == 0)
+          || (gUnicodeCollation->StriColl(gUnicodeCollation, (CHAR16*)L".efi", (CHAR16*)&(Node->FileName[StrLen (Node->FileName) - 4])) == 0)
+         ){
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_LS_LINE_END_EXE),
+            gShellLevel2HiiHandle,
+            Node->FileName
+           );
+        } else {
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_LS_LINE_END_FILE),
+            gShellLevel2HiiHandle,
+            Node->FileName
+           );
+        }
+      if (!Sfo && !HeaderPrinted) {
+        PrintNonSfoHeader(CorrectedPath);
+      }
+    }
+  }
+  if (!Sfo) {
+    //
+    // print footer
+    //
+    ShellPrintHiiEx (
+      -1,
+      -1,
+      NULL,
+      STRING_TOKEN (STR_LS_FOOTER_LINE),
+      gShellLevel2HiiHandle,
+      FileCount,
+      FileSize,
+      DirCount
+     );
+  }
+  if (Rec){
+    DirectoryName = AllocateZeroPool(LongestPath + 2*sizeof(CHAR16));
+    if (DirectoryName == NULL) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_MEM), gShellLevel2HiiHandle);
+      ShellStatus = SHELL_OUT_OF_RESOURCES;
+    } else {
+      PrintFileInformation(Sfo, Node, &FileCount, &FileSize, &DirCount);
+      FoundOne = TRUE;
+      HeaderPrinted = TRUE;
+    }
+    if (!Sfo && ShellStatus != SHELL_ABORTED) {
+      PrintNonSfoFooter(FileCount, FileSize, DirCount);
+    }
+  }
+  if (Rec && ShellStatus != SHELL_ABORTED) {
+    //
+    // Re-Open all the files under the starting path for directories that didnt necessarily match our file filter
+    //
+    ShellCloseFileMetaArg(&ListHead);
+    CorrectedPath[0] = CHAR_NULL;
+    CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, RootPath, 0);
+    if (CorrectedPath == NULL) {
+      return SHELL_OUT_OF_RESOURCES;
+    }
+    if (CorrectedPath[StrLen(CorrectedPath)-1] != L'\\'
+      &&CorrectedPath[StrLen(CorrectedPath)-1] != L'/') {
+      CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, L"\\",     0);
+    }
+    CorrectedPath = StrnCatGrow(&CorrectedPath, &LongestPath, L"*",     0);
+    Status = ShellOpenFileMetaArg((CHAR16*)CorrectedPath, EFI_FILE_MODE_READ, &ListHead);
+    if (!EFI_ERROR(Status)) {
       for ( Node = (EFI_SHELL_FILE_INFO *)GetFirstNode(&ListHead->Link)
           ; !IsNull(&ListHead->Link, &Node->Link)
+          ; !IsNull(&ListHead->Link, &Node->Link) && ShellStatus == SHELL_SUCCESS
           ; Node = (EFI_SHELL_FILE_INFO *)GetNextNode(&ListHead->Link, &Node->Link)
          ){
+        if (ShellGetExecutionBreakFlag ()) {
+          ShellStatus = SHELL_ABORTED;
+          break;
+        }
         //
         // recurse on any directory except the traversing ones...
 …
           && StrCmp(Node->FileName, L"..") != 0
          ){
+          StrCpy(DirectoryName, Node->FullName);
+          StrCat(DirectoryName, L"\\*");
+          PrintLsOutput(
+          ShellStatus = PrintLsOutput(
             Rec,
             Attribs,
             Sfo,
+            DirectoryName,
+            FALSE,
+            Node->FullName,
+            SearchString,
+            &FoundOne,
             Count,
             TimeZone);
+          //
+          // Since it's running recursively, we have to break immediately when returned SHELL_ABORTED
+          //
+          if (ShellStatus == SHELL_ABORTED) {
+            break;
+          }
+        }
+      }
+      FreePool(DirectoryName);
+    }
+  }
+  FreePool(CorrectedPath);
+    }
+  }
+  SHELL_FREE_NON_NULL(CorrectedPath);
   ShellCloseFileMetaArg(&ListHead);
+  FreePool(ListHead);
+  if (Found == NULL && !FoundOne) {
+    return (SHELL_NOT_FOUND);
+  }
+  if (Found != NULL) {
+    *Found = FoundOne;
+  }
   return (ShellStatus);
+}
 …
   UINTN         Size;
   EFI_TIME      TheTime;
   BOOLEAN       SfoMode;
+  CHAR16        *SearchString;
   Size                = 0;
 …
   RequiredAttributes  = 0;
   PathName            = NULL;
+  SearchString        = NULL;
   CurDir              = NULL;
   Count               = 0;
 …
         PathName = ShellCommandLineGetRawValue(Package, 1);
         if (PathName == NULL) {
+          //
+          // Nothing specified... must start from current directory
+          //
           CurDir = gEfiShellProtocol->GetCurDir(NULL);
           if (CurDir == NULL) {
 …
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);
+          }
+        }
+        if (PathName != NULL) {
+          //
+          // Copy to the 2 strings for starting path and file search string
+          //
+          ASSERT(SearchString == NULL);
+          ASSERT(FullPath == NULL);
+          StrnCatGrow(&SearchString, NULL, L"*", 0);
+          StrnCatGrow(&FullPath, NULL, CurDir, 0);
+        } else {
           if (StrStr(PathName, L":") == NULL && gEfiShellProtocol->GetCurDir(NULL) == NULL) {
+            //
+            // If we got something and it doesnt have a fully qualified path, then we needed to have a CWD.
+            //
             ShellStatus = SHELL_NOT_FOUND;
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_CWD), gShellLevel2HiiHandle);
           } else {
+            //
+            // We got a valid fully qualified path or we have a CWD
+            //
             ASSERT((FullPath == NULL && Size == 0) || (FullPath != NULL));
+            if (StrStr(PathName, L":") == NULL) {
+              StrnCatGrow(&FullPath, &Size, gEfiShellProtocol->GetCurDir(NULL), 0);
+              if (FullPath == NULL) {
+                ShellCommandLineFreeVarList (Package);
+                return SHELL_OUT_OF_RESOURCES;
+              }
+            }
             StrnCatGrow(&FullPath, &Size, PathName, 0);
+            if (FullPath == NULL) {
+                ShellCommandLineFreeVarList (Package);
+                return SHELL_OUT_OF_RESOURCES;
+            }
             if  (ShellIsDirectory(PathName) == EFI_SUCCESS) {
+              StrnCatGrow(&FullPath, &Size, L"\\*", 0);
+              //
+              // is listing ends with a directory, then we list all files in that directory
+              //
+              StrnCatGrow(&SearchString, NULL, L"*", 0);
+            } else {
+              //
+              // must split off the search part that applies to files from the end of the directory part
+              //
+              for (StrnCatGrow(&SearchString, NULL, PathName, 0)
+                ; SearchString != NULL && StrStr(SearchString, L"\\") != NULL
+                ; CopyMem(SearchString, StrStr(SearchString, L"\\") + 1, 1 + StrSize(StrStr(SearchString, L"\\") + 1))) ;
+              FullPath[StrLen(FullPath) - StrLen(SearchString)] = CHAR_NULL;
+            }
+          }
-        } else {
-          ASSERT(FullPath == NULL);
-          StrnCatGrow(&FullPath, NULL, L"*", 0);
+        }
         Status = gRT->GetTime(&TheTime, NULL);
 …
+        }
-        SfoMode = ShellCommandLineGetFlag(Package, L"-sfo");
         if (ShellStatus == SHELL_SUCCESS) {
           ShellStatus = PrintLsOutput(
             ShellCommandLineGetFlag(Package, L"-r"),
             RequiredAttributes,
             SfoMode,
+            ShellCommandLineGetFlag(Package, L"-sfo"),
             FullPath,
+            TRUE,
+            SearchString,
+            NULL,
             Count,
             (INT16)(TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:TheTime.TimeZone)
            );
           if (ShellStatus == SHELL_NOT_FOUND) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_NO_FILES), gShellLevel2HiiHandle);
+            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_LS_FILE_NOT_FOUND), gShellLevel2HiiHandle);
           } else if (ShellStatus == SHELL_INVALID_PARAMETER) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle);
+          } else if (ShellStatus == SHELL_ABORTED) {
+            //
+            // Ignore aborting.
+            //
           } else if (ShellStatus != SHELL_SUCCESS) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PARAM_INV), gShellLevel2HiiHandle);
 …
+  }
+  if (FullPath != NULL) {
+    FreePool(FullPath);
+  }
+  //
+  // free the command line package
+  //
+  //
+  // Free memory allocated
+  //
+  SHELL_FREE_NON_NULL(SearchString);
+  SHELL_FREE_NON_NULL(FullPath);
   ShellCommandLineFreeVarList (Package);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Map.c

-              r48674
+              r58459
   Main file for map shell level 2 command.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 /**
-  Add mappings for any devices without one.  Do not change any existing maps.
-  @retval EFI_SUCCESS   The operation was successful.
-**/
-EFI_STATUS
-EFIAPI
-UpdateMapping (
-  VOID
+  )
+{
-  EFI_STATUS                Status;
-  EFI_HANDLE                *HandleList;
-  UINTN                     Count;
-  EFI_DEVICE_PATH_PROTOCOL  **DevicePathList;
-  CHAR16                    *NewDefaultName;
-  CHAR16                    *NewConsistName;
-  EFI_DEVICE_PATH_PROTOCOL  **ConsistMappingTable;
-  HandleList  = NULL;
-  Status      = EFI_SUCCESS;
-  //
-  // remove mappings that represent removed devices.
-  //
-  //
-  // Find each handle with Simple File System
-  //
-  HandleList = GetHandleListByProtocol(&gEfiSimpleFileSystemProtocolGuid);
-  if (HandleList != NULL) {
-    //
-    // Do a count of the handles
-    //
-    for (Count = 0 ; HandleList[Count] != NULL ; Count++);
-    //
-    // Get all Device Paths
-    //
-    DevicePathList = AllocateZeroPool(sizeof(EFI_DEVICE_PATH_PROTOCOL*) * Count);
-    ASSERT(DevicePathList != NULL);
-    for (Count = 0 ; HandleList[Count] != NULL ; Count++) {
-      DevicePathList[Count] = DevicePathFromHandle(HandleList[Count]);
+    }
-    //
-    // Sort all DevicePaths
-    //
-    PerformQuickSort(DevicePathList, Count, sizeof(EFI_DEVICE_PATH_PROTOCOL*), DevicePathCompare);
-    ShellCommandConsistMappingInitialize(&ConsistMappingTable);
-    //
-    // Assign new Mappings to remainders
-    //
-    for (Count = 0 ; HandleList[Count] != NULL && !EFI_ERROR(Status); Count++) {
-      //
-      // Skip ones that already have
-      //
-      if (gEfiShellProtocol->GetMapFromDevicePath(&DevicePathList[Count]) != NULL) {
-        continue;
+      }
-      //
-      // Get default name
-      //
-      NewDefaultName = ShellCommandCreateNewMappingName(MappingTypeFileSystem);
-      ASSERT(NewDefaultName != NULL);
-      //
-      // Call shell protocol SetMap function now...
-      //
-      Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewDefaultName);
-      if (!EFI_ERROR(Status)) {
-        //
-        // Now do consistent name
-        //
-        NewConsistName = ShellCommandConsistMappingGenMappingName(DevicePathList[Count], ConsistMappingTable);
-        if (NewConsistName != NULL) {
-          Status = gEfiShellProtocol->SetMap(DevicePathList[Count], NewConsistName);
-          FreePool(NewConsistName);
+        }
+      }
-      FreePool(NewDefaultName);
+    }
-    ShellCommandConsistMappingUnInitialize(ConsistMappingTable);
-    SHELL_FREE_NON_NULL(HandleList);
-    SHELL_FREE_NON_NULL(DevicePathList);
-    HandleList = NULL;
-  } else {
-    Count = (UINTN)-1;
+  }
-  //
-  // Do it all over again for gEfiBlockIoProtocolGuid
-  //
-  return (Status);
+}
-/**
   Determine what type of device is represented and return it's string.  The
   string is in allocated memory and must be callee freed.  The HII is is listed below.
 …
   //
   if (Specific != NULL) {
     NewSpecific = AllocateZeroPool(StrSize(Specific) + sizeof(CHAR16));
+    NewSpecific = AllocateCopyPool(StrSize(Specific) + sizeof(CHAR16), Specific);
     if (NewSpecific == NULL){
       return FALSE;
+    }
-    StrCpy(NewSpecific, Specific);
     if (NewSpecific[StrLen(NewSpecific)-1] != L':') {
       StrCat(NewSpecific, L":");
+      StrnCat(NewSpecific, L":", 2);
+    }
 …
+  }
   if (  Consist
+    && Specific == NULL
     && (SearchList(MapList, L"HD*",  NULL, TRUE, TRUE, L";")
       ||SearchList(MapList, L"CD*",  NULL, TRUE, TRUE, L";")
 …
   if (  Normal
+    && Specific == NULL
     && (SearchList(MapList, L"FS",  NULL, FALSE, TRUE, L";")
       ||SearchList(MapList, L"BLK", NULL, FALSE, TRUE, L";"))){
 …
   CHAR16                    *DevPathString;
   CHAR16                    *TempSpot;
+  CHAR16                    *Alias;
   UINTN                     TempLen;
   BOOLEAN                   Removable;
   CONST CHAR16              *TempSpot2;
+  Alias       = NULL;
+  TempSpot2   = NULL;
+  CurrentName = NULL;
   DevPath = DevicePathFromHandle(Handle);
   DevPathCopy = DevPath;
 …
+  }
+  CurrentName = NULL;
+  CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
+  if (CurrentName == NULL) {
+    return (EFI_OUT_OF_RESOURCES);
+  }
+  TempSpot = StrStr(CurrentName, L";");
+  if (TempSpot != NULL) {
+    *TempSpot = CHAR_NULL;
+  }
+  DevPathString = gDevPathToText->ConvertDevicePathToText(DevPath, TRUE, FALSE);
+  if (Normal || !Consist) {
+    //
+    // need the Normal here since people can use both on command line.  otherwise unused.
+    //
+    //
+    // Allocate a name
+    //
+    CurrentName = NULL;
+    CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
+    if (CurrentName == NULL) {
+      return (EFI_OUT_OF_RESOURCES);
+    }
+    //
+    // Chop off the other names that become "Alias(s)"
+    // leaving just the normal name
+    //
+    TempSpot = StrStr(CurrentName, L";");
+    if (TempSpot != NULL) {
+      *TempSpot = CHAR_NULL;
+    }
+  } else {
+    CurrentName = NULL;
+    //
+    // Skip the first name.  This is the standard name.
+    //
+    TempSpot = StrStr(MapList, L";");
+    if (TempSpot != NULL) {
+      TempSpot++;
+    }
+    SearchList(TempSpot, L"HD*", &CurrentName, TRUE, FALSE, L";");
+    if (CurrentName == NULL) {
+      SearchList(TempSpot, L"CD*", &CurrentName, TRUE, FALSE, L";");
+    }
+    if (CurrentName == NULL) {
+      SearchList(TempSpot, L"FP*", &CurrentName, TRUE, FALSE, L";");
+    }
+    if (CurrentName == NULL) {
+      SearchList(TempSpot, L"F*",  &CurrentName, TRUE, FALSE, L";");
+    }
+    if (CurrentName == NULL) {
+      //
+      // We didnt find anything, so just the first one in the list...
+      //
+      CurrentName = StrnCatGrow(&CurrentName, 0, MapList, 0);
+      if (CurrentName == NULL) {
+        return (EFI_OUT_OF_RESOURCES);
+      }
+      TempSpot = StrStr(CurrentName, L";");
+      if (TempSpot != NULL) {
+        *TempSpot = CHAR_NULL;
+      }
+    } else {
+      Alias = StrnCatGrow(&Alias, 0, MapList, 0);
+      if (Alias == NULL) {
+        return EFI_OUT_OF_RESOURCES;
+      }
+      TempSpot = StrStr(Alias, CurrentName);
+      if (TempSpot != NULL) {
+        TempSpot2 = StrStr(TempSpot, L";");
+        if (TempSpot2 != NULL) {
+          TempSpot2++; // Move past ";" from CurrentName
+          CopyMem(TempSpot, TempSpot2, StrSize(TempSpot2));
+        } else {
+          *TempSpot = CHAR_NULL;
+        }
+      }
+      if (Alias[StrLen(Alias)-1] == L';') {
+        Alias[StrLen(Alias)-1] = CHAR_NULL;
+      }
+    }
+  }
+  DevPathString = ConvertDevicePathToText(DevPath, TRUE, FALSE);
+  TempLen = StrLen(CurrentName);
   if (!SFO) {
-    TempLen = StrLen(CurrentName);
     ShellPrintHiiEx (
       -1,
 …
       gShellLevel2HiiHandle,
       CurrentName,
       TempLen < StrLen(MapList)?MapList + TempLen+1:L"",
+      Alias!=NULL?Alias:(TempLen < StrLen(MapList)?MapList + TempLen+1:L""),
       DevPathString
      );
 …
          );
+      }
       FreePool(MediaType);
+      SHELL_FREE_NON_NULL(MediaType);
+    }
   } else {
-    TempLen = StrLen(CurrentName);
     ShellPrintHiiEx (
       -1,
 …
       CurrentName,
       DevPathString,
       TempLen < StrLen(MapList)?MapList + TempLen+1:L""
+      Consist?L"":(TempLen < StrLen(MapList)?MapList + TempLen+1:L"")
      );
+  }
+  FreePool(DevPathString);
+  FreePool(CurrentName);
+  SHELL_FREE_NON_NULL(DevPathString);
+  SHELL_FREE_NON_NULL(CurrentName);
+  SHELL_FREE_NON_NULL(Alias);
   return EFI_SUCCESS;
+}
 …
   CHAR16                          *NewSName;
   NewSName = AllocateZeroPool(StrSize(SName) + sizeof(CHAR16));
+  NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
   if (NewSName == NULL) {
     return (SHELL_OUT_OF_RESOURCES);
+  }
-  StrCpy(NewSName, SName);
   if (NewSName[StrLen(NewSName)-1] != L':') {
     StrCat(NewSName, L":");
+    StrnCat(NewSName, L":", 2);
+  }
 …
   CHAR16                    *NewSName;
   NewSName = AllocateZeroPool(StrSize(SName) + sizeof(CHAR16));
+  NewSName = AllocateCopyPool(StrSize(SName) + sizeof(CHAR16), SName);
   if (NewSName == NULL) {
     return (SHELL_OUT_OF_RESOURCES);
+  }
-  StrCpy(NewSName, SName);
   if (NewSName[StrLen(NewSName)-1] != L':') {
     StrCat(NewSName, L":");
+    StrnCat(NewSName, L":", 2);
+  }
 …
   CONST CHAR16  *Mapping;
   EFI_HANDLE    MapAsHandle;
-  CONST EFI_DEVICE_PATH_PROTOCOL *DevPath;
   SHELL_STATUS  ShellStatus;
   BOOLEAN       SfoMode;
 …
   Mapping       = NULL;
   SName         = NULL;
-  DevPath       = NULL;
   ShellStatus   = SHELL_SUCCESS;
   MapAsHandle = NULL;
 …
             Status = PerformMappingDelete(SName);
             if (EFI_ERROR(Status)) {
+              switch (Status) {
+                case EFI_ACCESS_DENIED:
+                  ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle);
+                  ShellStatus = SHELL_ACCESS_DENIED;
+                  break;
+                case EFI_NOT_FOUND:
+                  ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, SName);
+                  ShellStatus = SHELL_INVALID_PARAMETER;
+                  break;
+                default:
+                  ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, Status);
+                  ShellStatus = SHELL_UNSUPPORTED;
+              if (Status == EFI_ACCESS_DENIED) {
+                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_AD), gShellLevel2HiiHandle);
+                ShellStatus = SHELL_ACCESS_DENIED;
+              } else if (Status == EFI_NOT_FOUND) {
+                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MAP_NF), gShellLevel2HiiHandle, SName);
+                ShellStatus = SHELL_INVALID_PARAMETER;
+              } else {
+                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, Status);
+                ShellStatus = SHELL_UNSUPPORTED;
+              }
+            }
 …
           // Do the Update
           //
           Status = UpdateMapping();
+          Status = ShellCommandUpdateMapping ();
           if (EFI_ERROR(Status)) {
             ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, Status);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Mv.c

-              r48674
+              r58459
   Main file for mv shell level 2 function.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   @param DestPath [in]    The target location to move to
   @param Attribute[in]    The Attribute of the file
+  @param FileStatus[in]   The Status of the file when opened
   @retval TRUE        The move is valid
 …
 EFIAPI
 IsValidMove(
+  IN CONST CHAR16   *FullName,
+  IN CONST CHAR16   *Cwd,
+  IN CONST CHAR16   *DestPath,
+  IN CONST UINT64   Attribute
+  IN CONST CHAR16     *FullName,
+  IN CONST CHAR16     *Cwd,
+  IN CONST CHAR16     *DestPath,
+  IN CONST UINT64     Attribute,
+  IN CONST EFI_STATUS FileStatus
+  )
+{
 …
     return (FALSE);
+  }
   if ((Attribute & EFI_FILE_READ_ONLY) != 0) {
+  if (((Attribute & EFI_FILE_READ_ONLY) != 0) || (FileStatus == EFI_WRITE_PROTECTED)) {
     //
     // invalid to move read only
     //
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MV_INV_RO), gShellLevel2HiiHandle);
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_MV_INV_RO), gShellLevel2HiiHandle, FullName);
     return (FALSE);
+  }
 …
   EFI_SHELL_FILE_INFO       *DestList;
   EFI_SHELL_FILE_INFO       *Node;
-  EFI_STATUS                Status;
   CHAR16                    *DestPath;
-  CHAR16                    *TempLocation;
   UINTN                     NewSize;
+  UINTN                     CurrentSize;
   DestList = NULL;
 …
     StrCpy(DestPath, Cwd);
     while (PathRemoveLastItem(DestPath)) ;
+    //
+    // Append DestDir beyond '\' which may be present
+    //
+    CurrentSize = StrSize(DestPath);
+    StrnCatGrow(&DestPath, &CurrentSize, &DestDir[1], 0);
     *DestPathPointer =  DestPath;
     return (SHELL_SUCCESS);
 …
   // get the destination path
   //
   Status = ShellOpenFileMetaArg((CHAR16*)DestDir, EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ|EFI_FILE_MODE_CREATE, &DestList);
+  ShellOpenFileMetaArg((CHAR16*)DestDir, EFI_FILE_MODE_WRITE|EFI_FILE_MODE_READ|EFI_FILE_MODE_CREATE, &DestList);
   if (DestList == NULL || IsListEmpty(&DestList->Link)) {
     //
     // Not existing... must be renaming
     //
     if ((TempLocation = StrStr(DestDir, L":")) == NULL) {
+    if (StrStr(DestDir, L":") == NULL) {
       if (Cwd == NULL) {
         ShellCloseFileMetaArg(&DestList);
 …
   VOID                      *Response;
   SHELL_FILE_HANDLE         DestHandle;
+  CHAR16                    *CleanFilePathStr;
   ASSERT(FileList != NULL);
   ASSERT(DestDir  != NULL);
+  DestPath = NULL;
+  Cwd      = ShellGetCurrentDir(NULL);
+  Response = *Resp;
+  DestPath         = NULL;
+  Cwd              = ShellGetCurrentDir(NULL);
+  Response         = *Resp;
+  CleanFilePathStr = NULL;
+  Status = ShellLevel2StripQuotes (DestDir, &CleanFilePathStr);
+  if (EFI_ERROR (Status)) {
+    if (Status == EFI_OUT_OF_RESOURCES) {
+      return SHELL_OUT_OF_RESOURCES;
+    } else {
+      return SHELL_INVALID_PARAMETER;
+    }
+  }
+  ASSERT (CleanFilePathStr != NULL);
   //
   // Get and validate the destination location
   //
+  ShellStatus = GetDestinationLocation(DestDir, &DestPath, Cwd);
+  ShellStatus = GetDestinationLocation(CleanFilePathStr, &DestPath, Cwd);
+  FreePool (CleanFilePathStr);
   if (ShellStatus != SHELL_SUCCESS) {
     return (ShellStatus);
 …
   ASSERT  (HiiResultOk  != NULL);
   ASSERT  (HiiOutput    != NULL);
-//  ASSERT  (Cwd          != NULL);
   //
 …
       break;
+    }
+    //
+    // These should never be NULL
+    //
     ASSERT(Node->FileName != NULL);
     ASSERT(Node->FullName != NULL);
+    ASSERT(Node->Info     != NULL);
     //
 …
     // Validate that the move is valid
     //
     if (!IsValidMove(Node->FullName, Cwd, DestPath, Node->Info->Attribute)) {
+    if (!IsValidMove(Node->FullName, Cwd, DestPath, Node->Info->Attribute, Node->Status)) {
       ShellStatus = SHELL_INVALID_PARAMETER;
       continue;
 …
       if (EFI_ERROR(Status)) {
         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_ERR_UK), gShellLevel2HiiHandle, Status);
+        //
+        // move failed
+        //
+        switch(Status){
+          default:
+            ShellStatus = SHELL_INVALID_PARAMETER;
+          case EFI_SECURITY_VIOLATION:
+            ShellStatus = SHELL_SECURITY_VIOLATION;
+          case EFI_WRITE_PROTECTED:
+            ShellStatus = SHELL_WRITE_PROTECTED;
+          case EFI_OUT_OF_RESOURCES:
+            ShellStatus = SHELL_OUT_OF_RESOURCES;
+          case EFI_DEVICE_ERROR:
+            ShellStatus = SHELL_DEVICE_ERROR;
+          case EFI_ACCESS_DENIED:
+            ShellStatus = SHELL_ACCESS_DENIED;
+        } // switch
+        ShellStatus = SHELL_INVALID_PARAMETER;
+        if (Status == EFI_SECURITY_VIOLATION) {
+          ShellStatus = SHELL_SECURITY_VIOLATION;
+        } else if (Status == EFI_WRITE_PROTECTED) {
+          ShellStatus = SHELL_WRITE_PROTECTED;
+        } else if (Status == EFI_OUT_OF_RESOURCES) {
+          ShellStatus = SHELL_OUT_OF_RESOURCES;
+        } else if (Status == EFI_DEVICE_ERROR) {
+          ShellStatus = SHELL_DEVICE_ERROR;
+        } else if (Status == EFI_ACCESS_DENIED) {
+          ShellStatus = SHELL_ACCESS_DENIED;
+        }
       } else {
         ShellPrintEx(-1, -1, L"%s", HiiResultOk);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Parse.c

-              r48674
+              r58459
   Main file for Parse shell level 2 function.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_FILE_OPEN_FAIL), gShellLevel2HiiHandle, FileName);
     ShellStatus = SHELL_NOT_FOUND;
+  } else if (!EFI_ERROR (FileHandleIsDirectory (FileHandle))) {
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_NOT_FILE), gShellLevel2HiiHandle, FileName);
+    ShellStatus = SHELL_NOT_FOUND;
   } else {
     for (LoopVariable = 0 ; LoopVariable < ShellCommandInstance && !ShellFileHandleEof(FileHandle);) {
 …
         break;
+      }
+      if (StrStr(TempLine, L"ShellCommand, \"") == TempLine) {
+      //
+      // Search for "ShellCommand," in the file to start the SFO table
+      // for a given ShellCommand.  The UEFI Shell spec does not specify
+      // a space after the comma.
+      //
+      if (StrStr (TempLine, L"ShellCommand,") == TempLine) {
         LoopVariable++;
+      }
 …
       while(1) {
         TempLine = ShellFileHandleReturnLine(FileHandle, &Ascii);
+        if ( TempLine == NULL
+          || *TempLine == CHAR_NULL
+          || StrStr(TempLine, L"ShellCommand, \"") == TempLine
+         ){
+        if (TempLine == NULL
+            || *TempLine == CHAR_NULL
+            || StrStr (TempLine, L"ShellCommand,") == TempLine) {
           SHELL_FREE_NON_NULL(TempLine);
           break;
+        }
         if (StrStr(TempLine, TableName) == TempLine) {
+        if (StrStr (TempLine, TableName) == TempLine) {
           LoopVariable++;
+        }
+        if ( LoopVariable == TableNameInstance
+          || (TableNameInstance == (UINTN)-1 && StrStr(TempLine, TableName) == TempLine)
+         ){
+          for (ColumnLoop = 1, ColumnPointer = TempLine; ColumnLoop < ColumnIndex && ColumnPointer != NULL && *ColumnPointer != CHAR_NULL; ColumnLoop++) {
+            ColumnPointer = StrStr(ColumnPointer, L",");
+            if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL){
+              ColumnPointer++;
+          if (LoopVariable == TableNameInstance
+              || (TableNameInstance == (UINTN)-1)) {
+            for (ColumnLoop = 1, ColumnPointer = TempLine; ColumnLoop < ColumnIndex && ColumnPointer != NULL && *ColumnPointer != CHAR_NULL; ColumnLoop++) {
+              ColumnPointer = StrStr (ColumnPointer, L",");
+              if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL){
+                ColumnPointer++;
+              }
+            }
+          }
+          if (ColumnLoop == ColumnIndex) {
+            ASSERT(ColumnPointer != NULL);
+            TempSpot = StrStr(ColumnPointer, L",");
+            if (TempSpot != NULL) {
+              *TempSpot = CHAR_NULL;
+            if (ColumnLoop == ColumnIndex) {
+              if (ColumnPointer == NULL) {
+                ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellLevel2HiiHandle, L"Column Index");
+                ShellStatus = SHELL_INVALID_PARAMETER;
+              } else {
+                TempSpot = StrStr (ColumnPointer, L",");
+                if (TempSpot != NULL) {
+                  *TempSpot = CHAR_NULL;
+                }
+                while (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L' '){
+                  ColumnPointer++;
+                }
+                if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L'\"'){
+                  ColumnPointer++;
+                }
+                if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[StrLen (ColumnPointer) - 1] == L'\"'){
+                  ColumnPointer[StrLen (ColumnPointer) - 1] = CHAR_NULL;
+                }
+                ShellPrintEx (-1, -1, L"%s\r\n", ColumnPointer);
+              }
+            }
-            while (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L' '){
-              ColumnPointer++;
+            }
-            if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[0] == L'\"'){
-              ColumnPointer++;
+            }
-            if (ColumnPointer != NULL && *ColumnPointer != CHAR_NULL && ColumnPointer[StrLen(ColumnPointer)-1] == L'\"'){
-              ColumnPointer[StrLen(ColumnPointer)-1] = CHAR_NULL;
+            }
-            ShellPrintEx(-1, -1, L"%s\r\n", ColumnPointer);
+          }
+        }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Reset.c

-              r48674
+              r58459
   Main file for attrib shell level 2 function.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
           String = ShellCommandLineGetValue(Package, L"-w");
           if (String != NULL) {
             gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, StrSize(String), (VOID*)String);
+            gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, StrSize(String), (VOID*)String);
           } else {
             gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
+            gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
+          }
+        }
 …
         String = ShellCommandLineGetValue(Package, L"-c");
         if (String != NULL) {
           gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, StrSize(String), (VOID*)String);
+          gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, StrSize(String), (VOID*)String);
         } else {
           gRT->ResetSystem(EfiResetWarm, EFI_SUCCESS, 0, NULL);
+          gRT->ResetSystem(EfiResetCold, EFI_SUCCESS, 0, NULL);
+        }
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Rm.c

-              r48674
+              r58459
   Main file for attrib shell level 2 function.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
+  )
+{
-  EFI_STATUS      Status;
   EFI_FILE_INFO   *FileInfo;
   BOOLEAN         NoFile;
 …
   RetVal = TRUE;
   NoFile = FALSE;
+  for (Status = FileHandleFindFirstFile(FileHandle, &FileInfo)
+  FileInfo = NULL;
+  for (FileHandleFindFirstFile(FileHandle, &FileInfo)
     ;  !NoFile
     ;  Status = FileHandleFindNextFile(FileHandle, FileInfo, &NoFile)
+    ;  FileHandleFindNextFile(FileHandle, FileInfo, &NoFile)
    ){
     if (StrStr(FileInfo->FileName, L".") != FileInfo->FileName
 …
   EFI_STATUS            Status;
   SHELL_PROMPT_RESPONSE *Resp;
+  CHAR16                *TempName;
+  UINTN                 NewSize;
   Resp                  = NULL;
 …
         Status = ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN(STR_RM_LOG_DELETE_CONF), gShellLevel2HiiHandle, Node->FullName);
         Status = ShellPromptForResponse(ShellPromptResponseTypeYesNo, NULL, (VOID**)&Resp);
-        ASSERT_EFI_ERROR(Status);
         ASSERT(Resp != NULL);
         if (EFI_ERROR(Status) || *Resp != ShellPromptResponseYes) {
 …
+        }
         Node2->Status = gEfiShellProtocol->OpenFileByName (Node2->FullName, &Node2->Handle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE);
+        ShellStatus = CascadeDelete(Node2, Quiet);
+        if (EFI_ERROR(Node2->Status) && StrStr(Node2->FileName, L":") == NULL) {
+          //
+          // Update the node filename to have full path with file system identifier
+          //
+          NewSize = StrSize(Node->FullName) + StrSize(Node2->FullName);
+          TempName = AllocateZeroPool(NewSize);
+          if (TempName == NULL) {
+            ShellStatus = SHELL_OUT_OF_RESOURCES;
+          } else {
+            StrnCpy(TempName, Node->FullName, NewSize/sizeof(CHAR16) -1);
+            TempName[StrStr(TempName, L":")+1-TempName] = CHAR_NULL;
+            StrnCat(TempName, Node2->FullName, NewSize/sizeof(CHAR16) -1 - StrLen(TempName));
+            FreePool((VOID*)Node2->FullName);
+            Node2->FullName = TempName;
+            //
+            // Now try again to open the file
+            //
+            Node2->Status = gEfiShellProtocol->OpenFileByName (Node2->FullName, &Node2->Handle, EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE);
+          }
+        }
+        if (!EFI_ERROR(Node2->Status)) {
+          ShellStatus = CascadeDelete(Node2, Quiet);
+        } else if (ShellStatus == SHELL_SUCCESS) {
+          ShellStatus = (SHELL_STATUS)(Node2->Status&(~0x80000000));
+        }
         if (ShellStatus != SHELL_SUCCESS) {
           if (List!=NULL) {
 …
     // now delete the current node...
     //
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_RM_LOG_DELETE), gShellLevel2HiiHandle, Node->FullName);
+    if (!Quiet) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_RM_LOG_DELETE), gShellLevel2HiiHandle, Node->FullName);
+    }
     Status = gEfiShellProtocol->DeleteFile(Node->Handle);
     Node->Handle = NULL;
 …
     return (SHELL_ACCESS_DENIED);
   } else {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_RM_LOG_DELETE_COMP), gShellLevel2HiiHandle);
+    if (!Quiet) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_RM_LOG_DELETE_COMP), gShellLevel2HiiHandle);
+    }
     return (SHELL_SUCCESS);
+  }
 …
 /**
   Determins if a Node is a valid delete target.  Will prevent deleting the root directory.
+  Determines if a Node is a valid delete target.  Will prevent deleting the root directory.
   @param[in] List       RESERVED.  Not used.
 …
   Pattern       = StrnCatGrow(&Pattern     , NULL, TempLocation  , 0);
   SearchString  = StrnCatGrow(&SearchString, &Size, Node->FullName, 0);
+  SearchString  = StrnCatGrow(&SearchString, &Size, L"*", 0);
+  if (!EFI_ERROR(ShellIsDirectory(SearchString))) {
+    SearchString  = StrnCatGrow(&SearchString, &Size, L"\\", 0);
+    SearchString  = StrnCatGrow(&SearchString, &Size, L"*", 0);
+  }
   if (Pattern == NULL || SearchString == NULL) {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/TimeDate.c

-              r48674
+              r58459
   Main file for time, timezone, and date shell level 2 and shell level 3 functions.
+  (C) Copyright 2012-2014, Hewlett-Packard Development Company, L.P.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
         //
         Status = gRT->GetTime(&TheTime, NULL);
+        ASSERT_EFI_ERROR(Status);
+        if (EFI_ERROR(Status)) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
+          return (SHELL_DEVICE_ERROR);
+        }
         //
 …
         //
         if (ShellCommandLineGetFlag(Package, L"-sfo")) {
+          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DATE_SFO_FORMAT), gShellLevel2HiiHandle, TheTime.Month, TheTime.Day, TheTime.Year);
+          //
+          // Match UEFI Shell spec:
+          // ShellCommand,"date"
+          // Date,"DD","MM","YYYY"
+          //
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_SFO_HEADER), gShellLevel2HiiHandle, L"date");
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_DATE_SFO_FORMAT), gShellLevel2HiiHandle, TheTime.Day, TheTime.Month, TheTime.Year);
         } else {
           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_DATE_FORMAT), gShellLevel2HiiHandle, TheTime.Month, TheTime.Day, TheTime.Year);
 …
   Status = gRT->GetTime(&TheTime, NULL);
+  ASSERT_EFI_ERROR(Status);
+  if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
+    return (SHELL_DEVICE_ERROR);
+  }
   if (TimeString != NULL) {
 …
     if (Walker2 != NULL && *Walker2 == L':') {
       *Walker2 = CHAR_NULL;
+      TheTime.Second = (UINT8)0;
+    }
+    else if (Walker2 == NULL) {
+      TheTime.Second = (UINT8)0;
+    }
     if (Walker1 != NULL && Walker1[0] != CHAR_NULL) {
 …
       if (Walker2 != NULL) {
         Walker1 = Walker2 + 1;
+        if (Walker1 != NULL && Walker1[0] != CHAR_NULL) {
+          TheTime.Second = (UINT8)ShellStrToUintn (Walker1);
+        }
+      }
-      if (Walker1 != NULL && Walker1[0] != CHAR_NULL) {
-        TheTime.Second = (UINT8)ShellStrToUintn (Walker1);
+      }
+    }
     SHELL_FREE_NON_NULL(TimeStringCopy);
 …
+  if ((Tz >= -1440 && Tz <= 1440)||(Tz == 0x7FF)) {
+  if (Tz >= -1440 && Tz <= 1440) {
+    //
+    // EFI_TIME TimeZone is stored to meet the following calculation (see UEFI Spec):
+    // Localtime = UTC - TimeZone
+    // This means the sign must be changed for the user provided Tz.
+    // EX: User wants to set TimeZone to Pacific Standard Time, so runs
+    // time -tz -480 # set to UTC-08:00
+    // To meet the calculation, the sign must be changed.
+    //
+    TheTime.TimeZone = -Tz;
+  } else if (Tz == EFI_UNSPECIFIED_TIMEZONE) {
     TheTime.TimeZone = Tz;
+  }
 …
   EFI_STATUS    Status;
   LIST_ENTRY    *Package;
-  CHAR16        *Message;
   EFI_TIME      TheTime;
   CHAR16        *ProblemParam;
 …
   UINTN         TzMinutes;
+  //
+  // Initialize variables
+  //
   ShellStatus  = SHELL_SUCCESS;
   ProblemParam = NULL;
-  //
-  // Initialize variables
-  //
-  Message = NULL;
   //
 …
     //
     Status = gRT->GetTime(&TheTime, NULL);
+    ASSERT_EFI_ERROR(Status);
+    if (EFI_ERROR(Status)) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
+      return (SHELL_DEVICE_ERROR);
+    }
     if (ShellCommandLineGetFlag(Package, L"-?")) {
       ASSERT(FALSE);
 …
+        }
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN (STR_TIME_FORMAT),
+          gShellLevel2HiiHandle,
+          TheTime.Hour,
+          TheTime.Minute,
+          TheTime.Second,
+          TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?L" ":(TheTime.TimeZone > 0?L"-":L"+"),
+          TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(ABS(TheTime.TimeZone)) / 60,
+          TzMinutes
+         );
+         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CRLF), gShellLevel2HiiHandle);
+        if (TheTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_TIME_FORMAT),
+            gShellLevel2HiiHandle,
+            TheTime.Hour,
+            TheTime.Minute,
+            TheTime.Second,
+            (TheTime.TimeZone > 0?L"-":L"+"),
+            ((ABS(TheTime.TimeZone)) / 60),
+            TzMinutes
+            );
+        } else {
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_TIME_FORMAT_LOCAL),
+            gShellLevel2HiiHandle,
+            TheTime.Hour,
+            TheTime.Minute,
+            TheTime.Second
+            );
+        }
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_GEN_CRLF), gShellLevel2HiiHandle);
       } else if (ShellCommandLineGetFlag(Package, L"-d") && ShellCommandLineGetValue(Package, L"-d") == NULL) {
         if (TheTime.TimeZone == EFI_UNSPECIFIED_TIMEZONE) {
+          TzMinutes = 0;
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_TIME_FORMAT_LOCAL),
+            gShellLevel2HiiHandle,
+            TheTime.Hour,
+            TheTime.Minute,
+            TheTime.Second
+            );
         } else {
           TzMinutes = (ABS(TheTime.TimeZone)) % 60;
+        }
+        ShellPrintHiiEx (
+          -1,
+          -1,
+          NULL,
+          STRING_TOKEN (STR_TIME_FORMAT),
+          gShellLevel2HiiHandle,
+          TheTime.Hour,
+          TheTime.Minute,
+          TheTime.Second,
+          TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?L" ":(TheTime.TimeZone > 0?L"-":L"+"),
+          TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(ABS(TheTime.TimeZone)) / 60,
+          TzMinutes
+         );
+          ShellPrintHiiEx (
+            -1,
+            -1,
+            NULL,
+            STRING_TOKEN (STR_TIME_FORMAT),
+            gShellLevel2HiiHandle,
+            TheTime.Hour,
+            TheTime.Minute,
+            TheTime.Second,
+            (TheTime.TimeZone > 0?L"-":L"+"),
+            ((ABS(TheTime.TimeZone)) / 60),
+            TzMinutes
+           );
+        }
           switch (TheTime.Daylight) {
             case 0:
 …
           //
           if ((TempLocation = ShellCommandLineGetValue(Package, L"-tz")) != NULL) {
+            if (TempLocation[0] == L'-') {
+              Tz = (INT16)(0 - ShellStrToUintn(++TempLocation));
+            if (StrniCmp (TempLocation, L"_local", StrLen (TempLocation)) == NULL) {
+              Tz = EFI_UNSPECIFIED_TIMEZONE;
+            } else if (TempLocation[0] == L'-') {
+              Tz = (INT16) ShellStrToUintn (++TempLocation);
+              //
+              // When the argument of "time [-tz tz]" is not numeric, ShellStrToUintn() returns "-1".
+              // Here we can detect the argument error by checking the return of ShellStrToUintn().
+              //
+              if (Tz == -1) {
+                Tz = 1441; //make it to be out of bounds value
+              } else {
+                Tz *= (-1); //sign convert
+              }
             } else {
+              Tz = (INT16)ShellStrToUintn(TempLocation);
+              if (TempLocation[0] == L'+') {
+                Tz = (INT16)ShellStrToUintn (++TempLocation);
+              } else {
+                Tz = (INT16)ShellStrToUintn (TempLocation);
+              }
+              //
+              // Detect the return of ShellStrToUintn() to make sure the argument is valid.
+              //
+              if (Tz == -1) {
+                Tz = 1441; //make it to be out of bounds value
+              }
+            }
             if (!(Tz >= -1440 && Tz <= 1440) && Tz != EFI_UNSPECIFIED_TIMEZONE) {
 …
           if (TempLocation != NULL) {
             Daylight = (UINT8)ShellStrToUintn(TempLocation);
+            //
+            // The argument of "time [-d dl]" is unsigned, if the first character is '-',
+            // the argument is incorrect.  That's because ShellStrToUintn() will skip past
+            // any '-' sign and convert what's next, forgetting the sign is here.
+            //
+            if (TempLocation[0] == '-') {
+              Daylight = 0xff; //make it invalid = will not use
+            }
             if (Daylight != 0 && Daylight != 1 && Daylight != 3) {
               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM_VAL), gShellLevel2HiiHandle, L"-d");
 …
     {-720 , STRING_TOKEN (STR_TIMEZONE_P12)},
     {-780 , STRING_TOKEN (STR_TIMEZONE_P13)},
+    {-840 , STRING_TOKEN (STR_TIMEZONE_P14)}
+    {-840 , STRING_TOKEN (STR_TIMEZONE_P14)},
+    {EFI_UNSPECIFIED_TIMEZONE, STRING_TOKEN (STR_TIMEZONE_LOCAL)}
 };
 …
+  }
+  if (StrniCmp (TimeZoneString, L"_local", StrLen (TimeZoneString)) == NULL) {
+    Status = gRT->GetTime (&TheTime, NULL);
+    if (EFI_ERROR (Status)) {
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
+      return (SHELL_DEVICE_ERROR);
+    }
+    TheTime.TimeZone = EFI_UNSPECIFIED_TIMEZONE;
+    Status = gRT->SetTime (&TheTime);
+    if (!EFI_ERROR(Status)){
+      return (SHELL_SUCCESS);
+    }
+    return (SHELL_INVALID_PARAMETER);
+  }
   if (TimeZoneString != NULL && !InternalIsTimeLikeString(TimeZoneString, L':', 1, 1, TRUE)) {
     return (SHELL_INVALID_PARAMETER);
 …
   Status = gRT->GetTime(&TheTime, NULL);
   if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
     return (SHELL_DEVICE_ERROR);
+  }
 …
     TheTime.TimeZone = (INT16)((ShellStrToUintn (++Walker)) * 60);
   } else {
     TheTime.TimeZone = (INT16)((ShellStrToUintn (Walker)) * -60);
+    TheTime.TimeZone = (INT16)((INT16)(ShellStrToUintn (Walker)) * -60);
+  }
   if (Walker2 != NULL) {
 …
       //
       Status = gRT->GetTime(&TheTime, NULL);
+      ASSERT_EFI_ERROR(Status);
+      if (EFI_ERROR(Status)) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_UEFI_FUNC_WARN), gShellLevel2HiiHandle, L"gRT->GetTime", Status);
+        return (SHELL_DEVICE_ERROR);
+      }
       if (TheTime.TimeZone != EFI_UNSPECIFIED_TIMEZONE) {
 …
               // Print basic info only
               //
+              if (TheTime.TimeZone == EFI_UNSPECIFIED_TIMEZONE) {
+                TzMinutes = 0;
+              } else {
+                TzMinutes = (ABS(TheTime.TimeZone)) % 60;
+              }
+              TzMinutes = (ABS(TheTime.TimeZone)) % 60;
               ShellPrintHiiEx (
 …
                 STRING_TOKEN(STR_TIMEZONE_SIMPLE),
                 gShellLevel2HiiHandle,
                 TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(TheTime.TimeZone > 0?L"-":L"+"),
                 TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(ABS(TheTime.TimeZone)) / 60,
+                (TheTime.TimeZone > 0?L"-":L"+"),
+                (ABS(TheTime.TimeZone)) / 60,
                 TzMinutes);
+            }
 …
           // Print basic info only
           //
+          if (TheTime.TimeZone == EFI_UNSPECIFIED_TIMEZONE) {
+            TzMinutes = 0;
+          } else {
+            TzMinutes = (ABS(TheTime.TimeZone)) % 60;
+          }
+          TzMinutes = (ABS(TheTime.TimeZone)) % 60;
           ShellPrintHiiEx (
             -1,
 …
             STRING_TOKEN(STR_TIMEZONE_SIMPLE),
             gShellLevel2HiiHandle,
             TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(TheTime.TimeZone > 0?L"-":L"+"),
             TheTime.TimeZone==EFI_UNSPECIFIED_TIMEZONE?0:(ABS(TheTime.TimeZone)) / 60,
+            (TheTime.TimeZone > 0?L"-":L"+"),
+            (ABS(TheTime.TimeZone)) / 60,
             TzMinutes);
           if (ShellCommandLineGetFlag(Package, L"-f")) {
             ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN(STR_TIMEZONE_NI), gShellLevel2HiiHandle);
 …
       } else {
         //
         // TimeZone was EFI_UNSPECIFIED_TIMEZONE (unknown) from GetTime()
+        // TimeZone was EFI_UNSPECIFIED_TIMEZONE (local) from GetTime()
         //
+        if (ShellCommandLineGetFlag (Package, L"-f")) {
+          for ( LoopVar = 0
+              ; LoopVar < sizeof (TimeZoneList) / sizeof (TimeZoneList[0])
+              ; LoopVar++
+             ){
+            if (TheTime.TimeZone == TimeZoneList[LoopVar].TimeZone) {
+              //
+              //  Print all info about current time zone
+              //
+              ShellPrintHiiEx (-1, -1, NULL, TimeZoneList[LoopVar].StringId, gShellLevel2HiiHandle);
+              break;
+            }
+          }
+        } else {
+          //
+          // Print basic info only
+          //
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_TIMEZONE_SIMPLE_LOCAL), gShellLevel2HiiHandle);
+        }
+      }
+    }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.c

-              r48674
+              r58459
   * functions are non-interactive only
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2014 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   ShellCommandRegisterCommandName(L"parse",    ShellCommandRunParse   , ShellCommandGetManFileNameLevel2, 2, L"", TRUE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_PARSE)  );
   ShellCommandRegisterCommandName(L"reset",    ShellCommandRunReset   , ShellCommandGetManFileNameLevel2, 2, L"", TRUE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_RESET)  );
   ShellCommandRegisterCommandName(L"set",      ShellCommandRunSet     , ShellCommandGetManFileNameLevel2, 2, L"", TRUE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_SET)    );
+  ShellCommandRegisterCommandName(L"set",      ShellCommandRunSet     , ShellCommandGetManFileNameLevel2, 2, L"",FALSE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_SET)    );
   ShellCommandRegisterCommandName(L"ls",       ShellCommandRunLs      , ShellCommandGetManFileNameLevel2, 2, L"", TRUE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_LS)     );
   ShellCommandRegisterCommandName(L"rm",       ShellCommandRunRm      , ShellCommandGetManFileNameLevel2, 2, L"", TRUE, gShellLevel2HiiHandle, STRING_TOKEN(STR_GET_HELP_RM)     );
 …
   ShellCommandRegisterAlias(L"cd ..", L"cd..");
   ShellCommandRegisterAlias(L"cd \\", L"cd\\");
+  ShellCommandRegisterAlias(L"ren", L"mv");
+  ShellCommandRegisterAlias(L"mv", L"ren");
+  ShellCommandRegisterAlias(L"mv", L"move");
+  ShellCommandRegisterAlias(L"map", L"mount");
   //
   // These are installed in level 2 or 3...
 …
+}
+/**
+  Cleans off all the quotes in the string.
+  @param[in]     OriginalString   pointer to the string to be cleaned.
+  @param[out]   CleanString      The new string with all quotes removed.
+                                                  Memory allocated in the function and free
+                                                  by caller.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellLevel2StripQuotes (
+  IN  CONST CHAR16     *OriginalString,
+  OUT CHAR16           **CleanString
+  )
+{
+  CHAR16            *Walker;
+  if (OriginalString == NULL || CleanString == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  *CleanString = AllocateCopyPool (StrSize (OriginalString), OriginalString);
+  if (*CleanString == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  for (Walker = *CleanString; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
+    if (*Walker == L'\"') {
+      CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
+    }
+  }
+  return EFI_SUCCESS;
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.h

-              r48674
+              r58459
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Protocol/LoadedImage.h>
 #include <Protocol/UnicodeCollation.h>
-#include <Protocol/DevicePathToText.h>
 #include <Library/BaseLib.h>
 …
 /**
+  Cleans off all the quotes in the string.
+  @param[in]     OriginalString   pointer to the string to be cleaned.
+  @param[out]   CleanString      The new string with all quotes removed.
+                                                  Memory allocated in the function and free
+                                                  by caller.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellLevel2StripQuotes (
+  IN  CONST CHAR16     *OriginalString,
+  OUT CHAR16           **CleanString
+  );
+/**
   Function for 'Vol' command.

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.inf

-              r48674
+              r58459
 # Provides shell level 2 functions
+#
 # Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
+# Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   HandleParsingLib
   PathLib
+  DevicePathLib
 [Protocols]
+  gEfiUnicodeCollation2ProtocolGuid                       # ALWAYS_CONSUMED
+  gEfiShellProtocolGuid                                   # ALWAYS_CONSUMED
+  gEfiShellParametersProtocolGuid                         # ALWAYS_CONSUMED
+  gEfiDevicePathProtocolGuid                              # ALWAYS_CONSUMED
+  gEfiLoadedImageProtocolGuid                             # ALWAYS_CONSUMED
+  gEfiSimpleFileSystemProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiDevicePathToTextProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiUnicodeCollation2ProtocolGuid                       ## CONSUMES
+  gEfiShellProtocolGuid                                   ## CONSUMES
+  gEfiShellParametersProtocolGuid                         ## CONSUMES
+  gEfiDevicePathProtocolGuid                              ## CONSUMES
+  gEfiLoadedImageProtocolGuid                             ## CONSUMES
+  gEfiSimpleFileSystemProtocolGuid                        ## CONSUMES
 [Pcd.common]
   gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         # ALWAYS_CONSUMED
   gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize    # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize    ## CONSUMES
 [Guids]
   gEfiFileSystemInfoGuid
   gEfiFileInfoGuid
   gShellLevel2HiiGuid
+  gEfiFileSystemInfoGuid                                  ## CONSUMES ## GUID
+  gEfiFileInfoGuid                                        ## UNDEFINED
+  gShellLevel2HiiGuid                                     ## SOMETIMES_CONSUMES ## HII

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel2CommandsLib/Vol.c

-              r48674
+              r58459
   Main file for vol shell level 2 function.
   Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2011 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   if (Delete) {
     StrCpy ((CHAR16 *) SysInfo->VolumeLabel, L"");
+    *((CHAR16 *) SysInfo->VolumeLabel) = CHAR_NULL;
     SysInfo->Size = SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize(SysInfo->VolumeLabel);
     Status = EfiFpHandle->SetInfo(
 …
+    }
     if (SysInfo != NULL) {
       StrCpy ((CHAR16 *) SysInfo->VolumeLabel, Name);
+      StrnCpy ((CHAR16 *) SysInfo->VolumeLabel, Name, (Size1 > Size2?Size1/sizeof(CHAR16):Size2/sizeof(CHAR16))-1);
       SysInfo->Size = SIZE_OF_EFI_FILE_SYSTEM_INFO + Size1;
       Status = EfiFpHandle->SetInfo(

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Alias.c

-              r48674
+              r58459
   Main file for Alias shell level 3 function.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   CONST CHAR16        *Param1;
   CONST CHAR16        *Param2;
+  CHAR16              *CleanParam2;
   ProblemParam        = NULL;
   ShellStatus         = SHELL_SUCCESS;
+  CleanParam2         = NULL;
   //
 …
     Param1 = ShellCommandLineGetRawValue(Package, 1);
     Param2 = ShellCommandLineGetRawValue(Package, 2);
+    if (Param2 != NULL) {
+      CleanParam2 = AllocateCopyPool (StrSize(Param2), Param2);
+      if (CleanParam2 == NULL) {
+        return SHELL_OUT_OF_RESOURCES;
+      }
+      if (CleanParam2[0] == L'\"' && CleanParam2[StrLen(CleanParam2)-1] == L'\"') {
+        CleanParam2[StrLen(CleanParam2)-1] = L'\0';
+        CopyMem (CleanParam2, CleanParam2 + 1, StrSize(CleanParam2) - sizeof(CleanParam2[0]));
+      }
+    }
     //
     // check for "-?"
 …
       // must be adding an alias
       //
       Status = gEfiShellProtocol->SetAlias(Param2, Param1, FALSE, ShellCommandLineGetFlag(Package, L"-v"));
+      Status = gEfiShellProtocol->SetAlias(CleanParam2, Param1, FALSE, ShellCommandLineGetFlag(Package, L"-v"));
       if (EFI_ERROR(Status)) {
         if (Status == EFI_ACCESS_DENIED) {
 …
+  }
+  SHELL_FREE_NON_NULL (CleanParam2);
   return (ShellStatus);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Cls.c

-              r48674
+              r58459
   Main file for attrib shell level 2 function.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_STATUS    Status;
   LIST_ENTRY    *Package;
-  CHAR16        *Message;
   UINTN         Background;
   UINTN         ForeColor;
 …
   CONST CHAR16  *Param1;
+  //
+  // Initialize variables
+  //
   ShellStatus   = SHELL_SUCCESS;
   ProblemParam  = NULL;
   Background    = 0;
-  //
-  // Initialize variables
-  //
-  Message = NULL;
   //
 …
+          }
           ForeColor = (~ShellStrToUintn(Param1)) & 0xF;
           Status = gST->ConOut->SetAttribute (gST->ConOut, ForeColor | Background);
+          Status = gST->ConOut->SetAttribute (gST->ConOut, (ForeColor | Background) & 0x7F );
           ASSERT_EFI_ERROR(Status);
           Status = gST->ConOut->ClearScreen (gST->ConOut);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Echo.c

-              r48674
+              r58459
   Main file for Echo shell level 3 function.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   UINTN               ParamCount;
   CHAR16              *ProblemParam;
+  UINTN               Size;
+  CHAR16              *PrintString;
+  Size                = 0;
   ProblemParam        = NULL;
+  PrintString         = NULL;
   ShellStatus         = SHELL_SUCCESS;
 …
           ; ParamCount++
          ) {
+        StrnCatGrow(&PrintString, &Size, ShellCommandLineGetRawValue(Package, ParamCount), 0);
         if (ShellCommandLineGetRawValue(Package, ParamCount+1) != NULL) {
+          ShellPrintEx(-1, -1, L"%s ", ShellCommandLineGetRawValue(Package, ParamCount));
+        } else {
+          ShellPrintEx(-1, -1, L"%s", ShellCommandLineGetRawValue(Package, ParamCount));
+        }
+          StrnCatGrow(&PrintString, &Size, L" ", 0);
+        }
+      }
+      ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_CRLF), gShellLevel3HiiHandle);
+      ShellPrintEx(-1, -1, L"%s\r\n", PrintString);
+      SHELL_FREE_NON_NULL(PrintString);
+    }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/GetMtc.c

-              r48674
+              r58459
   Main file for GetMtc shell level 3 function.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2013, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
       //
       Status = gBS->GetNextMonotonicCount(&Mtc);
+      switch(Status) {
+        case EFI_DEVICE_ERROR:
+          ShellStatus = SHELL_DEVICE_ERROR;
+          break;
+        case EFI_SECURITY_VIOLATION:
+          ShellStatus = SHELL_SECURITY_VIOLATION;
+          break;
+        default:
+          if (EFI_ERROR(Status)) {
+            ShellStatus = SHELL_DEVICE_ERROR;
+          }
+      if (Status == EFI_DEVICE_ERROR) {
+        ShellStatus = SHELL_DEVICE_ERROR;
+      } else if (Status == EFI_SECURITY_VIOLATION) {
+        ShellStatus = SHELL_SECURITY_VIOLATION;
+      } else if (EFI_ERROR(Status)) {
+        ShellStatus = SHELL_DEVICE_ERROR;
+      }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Help.c

-              r48674
+              r58459
   Main file for Help shell level 3 function.
+  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2014, ARM Limited. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
 #include <Library/ShellLib.h>
+#include <Library/HandleParsingLib.h>
+#include <Protocol/EfiShellDynamicCommand.h>
+/**
+  Attempt to print help from a dynamically added command.
+  @param[in]  CommandToGetHelpOn  The unicode name of the command that help is
+                                  requested on.
+  @param[in]  SectionToGetHelpOn  Pointer to the section specifier(s).
+  @param[in]  PrintCommandText    Print the command followed by the help content
+                                  or just help.
+  @retval EFI_SUCCESS             The help was displayed
+  @retval EFI_NOT_FOUND           The command name could not be found
+  @retval EFI_DEVICE_ERROR        The help data format was incorrect.
+**/
+EFI_STATUS
+EFIAPI
+PrintDynamicCommandHelp(
+  IN CHAR16  *CommandToGetHelpOn,
+  IN CHAR16  *SectionToGetHelpOn,
+  IN BOOLEAN  PrintCommandText
+ )
+{
+  EFI_STATUS                          Status;
+  BOOLEAN                             Found;
+  EFI_HANDLE                          *CommandHandleList;
+  EFI_HANDLE                          *NextCommand;
+  EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL  *DynamicCommand;
+  Status = EFI_NOT_FOUND;
+  Found = FALSE;
+  CommandHandleList = NULL;
+  CommandHandleList = GetHandleListByProtocol(&gEfiShellDynamicCommandProtocolGuid);
+  if (CommandHandleList == NULL) {
+    //
+    // not found or out of resources
+    //
+    return Status;
+  }
+  for (NextCommand = CommandHandleList; *NextCommand != NULL; NextCommand++) {
+    Status = gBS->HandleProtocol(
+      *NextCommand,
+      &gEfiShellDynamicCommandProtocolGuid,
+      (VOID **)&DynamicCommand
+      );
+    if (EFI_ERROR(Status)) {
+      continue;
+    }
+    //
+    // Check execution break flag when printing multiple command help information.
+    //
+    if (ShellGetExecutionBreakFlag ()) {
+      break;
+    }
+    if ((gUnicodeCollation->MetaiMatch (gUnicodeCollation, (CHAR16 *)DynamicCommand->CommandName, CommandToGetHelpOn)) ||
+      (gEfiShellProtocol->GetAlias (CommandToGetHelpOn, NULL) != NULL && (gUnicodeCollation->MetaiMatch (gUnicodeCollation, (CHAR16 *)DynamicCommand->CommandName, (CHAR16*)(gEfiShellProtocol->GetAlias(CommandToGetHelpOn, NULL)))))) {
+      // Print as Shell Help if in ManPage format.
+      Status = ShellPrintHelp (DynamicCommand->CommandName, SectionToGetHelpOn,
+                              PrintCommandText);
+      if (Status == EFI_DEVICE_ERROR) {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HELP_INV),
+                        gShellLevel3HiiHandle, DynamicCommand->CommandName);
+      } else if (EFI_ERROR(Status)) {
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_HELP_NF),
+                        gShellLevel3HiiHandle, DynamicCommand->CommandName);
+      } else {
+        Found = TRUE;
+      }
+    }
+  }
+  return (Found ? EFI_SUCCESS : Status);
+}
 STATIC CONST SHELL_PARAM_ITEM ParamList[] = {
 …
   CHAR16              *ProblemParam;
   SHELL_STATUS        ShellStatus;
-  CHAR16              *OutText;
   CONST COMMAND_LIST  *CommandList;
   CONST COMMAND_LIST  *Node;
 …
   CHAR16              *HiiString;
   BOOLEAN             Found;
+  BOOLEAN             PrintCommandText;
+  PrintCommandText    = TRUE;
   ProblemParam        = NULL;
   ShellStatus         = SHELL_SUCCESS;
-  OutText             = NULL;
   CommandToGetHelpOn  = NULL;
   SectionToGetHelpOn  = NULL;
 …
         StrnCatGrow(&SectionToGetHelpOn, NULL, L"NAME", 0);
       } else {
+        PrintCommandText = FALSE;
         ASSERT(SectionToGetHelpOn == NULL);
         //
 …
         } else if (ShellCommandLineGetFlag(Package, L"-verbose") || ShellCommandLineGetFlag(Package, L"-v")) {
         } else {
+          StrnCatGrow(&SectionToGetHelpOn, NULL, L"NAME", 0);
+          //
+          // The output of help <command> will display NAME, SYNOPSIS, OPTIONS, DESCRIPTION, and EXAMPLES sections.
+          //
+          StrnCatGrow (&SectionToGetHelpOn, NULL, L"NAME,SYNOPSIS,OPTIONS,DESCRIPTION,EXAMPLES", 0);
+        }
+      }
 …
             ; Node = (COMMAND_LIST*)GetNextNode(&CommandList->Link, &Node->Link)
            ){
+          //
+          // Checking execution break flag when print multiple command help information.
+          //
+          if (ShellGetExecutionBreakFlag ()) {
+            break;
+          }
           if ((gUnicodeCollation->MetaiMatch(gUnicodeCollation, Node->CommandString, CommandToGetHelpOn)) ||
              (gEfiShellProtocol->GetAlias(CommandToGetHelpOn, NULL) != NULL && (gUnicodeCollation->MetaiMatch(gUnicodeCollation, Node->CommandString, (CHAR16*)(gEfiShellProtocol->GetAlias(CommandToGetHelpOn, NULL)))))) {
 …
             // We have a command to look for help on.
             //
+            Status = gEfiShellProtocol->GetHelpText(Node->CommandString, SectionToGetHelpOn, &OutText);
+            if (EFI_ERROR(Status) || OutText == NULL) {
+              if (Status == EFI_DEVICE_ERROR) {
+            Status = ShellPrintHelp(Node->CommandString, SectionToGetHelpOn, PrintCommandText);
+            if (Status == EFI_DEVICE_ERROR) {
                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, Node->CommandString);
               } else {
+            } else if (EFI_ERROR(Status)) {
                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, Node->CommandString);
+              }
-              ShellStatus = SHELL_NOT_FOUND;
             } else {
+              while (OutText[StrLen(OutText)-1] == L'\r' || OutText[StrLen(OutText)-1] == L'\n' || OutText[StrLen(OutText)-1] == L' ') {
+                OutText[StrLen(OutText)-1] = CHAR_NULL;
+              }
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_COMMAND), gShellLevel3HiiHandle, Node->CommandString, OutText);
+              FreePool(OutText);
+              OutText = NULL;
+              Found = TRUE;
+                Found = TRUE;
+            }
+          }
+        }
+      }
+      if (!Found && ShellStatus == SHELL_SUCCESS) {
+        ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);
+        //
+        // now try to match against the dynamic command list and print help
+        //
+        Status = PrintDynamicCommandHelp (CommandToGetHelpOn, SectionToGetHelpOn,
+                                          PrintCommandText);
+        if (!EFI_ERROR(Status)) {
+          Found = TRUE;
+        }
+        //
+        // Search the .man file for Shell applications (Shell external commands).
+        //
+        if (!Found) {
+          Status = ShellPrintHelp(CommandToGetHelpOn, SectionToGetHelpOn, FALSE);
+          if (Status == EFI_DEVICE_ERROR) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_INV), gShellLevel3HiiHandle, CommandToGetHelpOn);
+          } else if (EFI_ERROR(Status)) {
+              ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_NF), gShellLevel3HiiHandle, CommandToGetHelpOn);
+          } else {
+            Found = TRUE;
+          }
+        }
+      }
+      if (!Found) {
         ShellStatus = SHELL_NOT_FOUND;
+      }
 …
+    }
+  }
+  if (CommandToGetHelpOn != NULL && StrCmp(CommandToGetHelpOn, L"*") == 0){
+    //
+    // If '*' then the command entered was 'Help' without qualifiers, This footer
+    // provides additional info on help switches
+    //
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_HELP_FOOTER), gShellLevel3HiiHandle);
+  }
   if (CommandToGetHelpOn != NULL) {
     FreePool(CommandToGetHelpOn);
 …
   return (ShellStatus);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Pause.c

-              r48674
+              r58459
   Main file for Pause shell level 3 function.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved. <BR>
+  Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   ProblemParam        = NULL;
   ShellStatus         = SHELL_SUCCESS;
+  Resp                = NULL;
   //

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Touch.c

-              r48674
+              r58459
+  }
   Status = gRT->GetTime(&FileInfo->ModificationTime, NULL);
+  ASSERT_EFI_ERROR(Status);
+  if (EFI_ERROR(Status)) {
+    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel3HiiHandle, L"gRT->GetTime", Status);
+    return (SHELL_DEVICE_ERROR);
+  }
   CopyMem(&FileInfo->LastAccessTime, &FileInfo->ModificationTime, sizeof(EFI_TIME));

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Type.c

-              r48674
+              r58459
   Main file for Type shell level 3 function.
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
 …
 EFIAPI
 TypeFileByHandle (
   IN EFI_HANDLE Handle,
   BOOLEAN Ascii,
   BOOLEAN UCS2
+  IN SHELL_FILE_HANDLE Handle,
+  IN BOOLEAN Ascii,
+  IN BOOLEAN UCS2
+  )
+{
   UINTN       ReadSize;
   VOID        *Buffer;
+  VOID        *AllocatedBuffer;
   EFI_STATUS  Status;
   UINTN       LoopVar;
+  UINTN       LoopSize;
   CHAR16      AsciiChar;
+  ReadSize = PcdGet16(PcdShellFileOperationSize);
+  Buffer = AllocateZeroPool(ReadSize);
+  if (Buffer == NULL) {
+  CHAR16      Ucs2Char;
+  ReadSize = PcdGet32(PcdShellFileOperationSize);
+  AllocatedBuffer = AllocateZeroPool(ReadSize);
+  if (AllocatedBuffer == NULL) {
     return (EFI_OUT_OF_RESOURCES);
+  }
 …
   ASSERT_EFI_ERROR(Status);
+  while (ReadSize == ((UINTN)PcdGet16(PcdShellFileOperationSize))){
+  while (ReadSize == ((UINTN)PcdGet32(PcdShellFileOperationSize))) {
+    Buffer = AllocatedBuffer;
     ZeroMem(Buffer, ReadSize);
     Status = ShellReadFile(Handle, &ReadSize, Buffer);
 …
+    }
     if (!(Ascii|UCS2)){
+    if (!(Ascii|UCS2)) {
       if (*(UINT16*)Buffer == gUnicodeFileTag) {
         UCS2 = TRUE;
-        Buffer = ((UINT16*)Buffer) + 1;
       } else {
         Ascii = TRUE;
 …
+    }
+    //
+    // We want to use plain Print function here! (no color support for files)
+    //
+    if (Ascii){
+      for (LoopVar = 0 ; LoopVar < ReadSize ; LoopVar++) {
+      AsciiChar = CHAR_NULL;
+      AsciiChar = ((CHAR8*)Buffer)[LoopVar];
+      if (AsciiChar == CHAR_NULL) {
+        AsciiChar = '.';
+      }
+      Print(L"%c", AsciiChar);
+    if (Ascii) {
+      LoopSize = ReadSize;
+      for (LoopVar = 0 ; LoopVar < LoopSize ; LoopVar++) {
+        //
+        // The valid range of ASCII characters is 0x20-0x7E.
+        // Display "." when there is an invalid character.
+        //
+        AsciiChar = CHAR_NULL;
+        AsciiChar = ((CHAR8*)Buffer)[LoopVar];
+        if (AsciiChar == '\r' || AsciiChar == '\n') {
+          //
+          // Allow Line Feed (LF) (0xA) & Carriage Return (CR) (0xD)
+          // characters to be displayed as is.
+          //
+          if (AsciiChar == '\n' && ((CHAR8*)Buffer)[LoopVar-1] != '\r') {
+            //
+            // In case Line Feed (0xA) is encountered & Carriage Return (0xD)
+            // was not the previous character, print CR and LF. This is because
+            // Shell 2.0 requires carriage return with line feed for displaying
+            // each new line from left.
+            //
+            ShellPrintEx (-1, -1, L"\r\n");
+            continue;
+          }
+        } else {
+          //
+          // For all other characters which are not printable, display '.'
+          //
+          if (AsciiChar < 0x20 || AsciiChar >= 0x7F) {
+            AsciiChar = '.';
+          }
+        }
+        ShellPrintEx (-1, -1, L"%c", AsciiChar);
+      }
     } else {
+      Print(L"%s", Buffer);
+      if (*(UINT16*)Buffer == gUnicodeFileTag) {
+        //
+        // For unicode files, skip displaying the byte order marker.
+        //
+        Buffer = ((UINT16*)Buffer) + 1;
+        LoopSize = (ReadSize / (sizeof (CHAR16))) - 1;
+      } else {
+        LoopSize = ReadSize / (sizeof (CHAR16));
+      }
+      for (LoopVar = 0 ; LoopVar < LoopSize ; LoopVar++) {
+        //
+        // An invalid range of characters is 0x0-0x1F.
+        // Display "." when there is an invalid character.
+        //
+        Ucs2Char = CHAR_NULL;
+        Ucs2Char = ((CHAR16*)Buffer)[LoopVar];
+        if (Ucs2Char == '\r' || Ucs2Char == '\n') {
+          //
+          // Allow Line Feed (LF) (0xA) & Carriage Return (CR) (0xD)
+          // characters to be displayed as is.
+          //
+          if (Ucs2Char == '\n' && ((CHAR16*)Buffer)[LoopVar-1] != '\r') {
+            //
+            // In case Line Feed (0xA) is encountered & Carriage Return (0xD)
+            // was not the previous character, print CR and LF. This is because
+            // Shell 2.0 requires carriage return with line feed for displaying
+            // each new line from left.
+            //
+            ShellPrintEx (-1, -1, L"\r\n");
+            continue;
+          }
+        }
+        else if (Ucs2Char < 0x20) {
+          //
+          // For all other characters which are not printable, display '.'
+          //
+          Ucs2Char = L'.';
+        }
+        ShellPrintEx (-1, -1, L"%c", Ucs2Char);
+      }
+    }
+    if (ShellGetExecutionBreakFlag()) {
+      break;
+    }
+  }
+  Print(L"\r\n", Buffer);
+  FreePool (AllocatedBuffer);
+  ShellPrintEx (-1, -1, L"\r\n");
   return (Status);
+}
 …
                 ; Node = (EFI_SHELL_FILE_INFO*)GetNextNode(&FileList->Link, &Node->Link)
                ){
+              if (ShellGetExecutionBreakFlag()) {
+                break;
+              }
               //
               // make sure the file opened ok
 …
               // do it
               //
               Status = TypeFileByHandle(Node->Handle, AsciiMode, UnicodeMode);
+              Status = TypeFileByHandle (Node->Handle, AsciiMode, UnicodeMode);
               if (EFI_ERROR(Status)) {
                 ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_TYP_ERROR), gShellLevel3HiiHandle, Node->FileName, Status);

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.c

-              r48674
+              r58459
   Main file for NULL named library for level 3 shell command functions.
+  Copyright (c) 2014, Hewlett-Packard Development Company, L.P.<BR>
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
   This program and the accompanying materials
 …
   ShellCommandRegisterCommandName(L"help",    ShellCommandRunHelp   , ShellCommandGetManFileNameLevel3, 3, L"", TRUE , gShellLevel3HiiHandle, STRING_TOKEN(STR_GET_HELP_HELP));
+  ShellCommandRegisterAlias(L"type", L"cat");
   return (EFI_SUCCESS);
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.h

r48674	r58459
26	26	#include <Protocol/LoadedImage.h>
27	27	#include <Protocol/UnicodeCollation.h>
28		~~#include <Protocol/DevicePathToText.h>~~
29	28
30	29	#include <Library/BaseLib.h>

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/UefiShellLevel3CommandsLib.inf

-              r48674
+              r58459
 # Note that the interactive versions of the time, date, and timezone functions are handled in the level 2 library.
+#
+# Copyright (c) 2009-2011, Intel Corporation. All rights reserved. <BR>
+# Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
+# Copyright (c) 2009-2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   HiiLib
   FileHandleLib
+  HandleParsingLib
 [Guids]
   gEfiFileInfoGuid
   gShellLevel3HiiGuid
+  gEfiFileInfoGuid                                        ## UNDEFINED
+  gShellLevel3HiiGuid                                     ## SOMETIMES_CONSUMES ## HII
 [Pcd.common]
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel
+  gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupportLevel         ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize    ## SOMETIMES_CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupplier             ## SOMETIMES_CONSUMES
+[Protocols]
+  gEfiShellDynamicCommandProtocolGuid                     ## SOMETIMES_CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLevel3CommandsLib/Ver.c

-              r48674
+              r58459
   Main file for Ver shell level 3 function.
+  Copyright (c) 2013, Hewlett-Packard Development Company, L.P.
   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
             -1,
             NULL,
+            STRING_TOKEN (STR_VER_EXTRA_STRING),
+            gShellLevel3HiiHandle
+            STRING_TOKEN (STR_VER_OUTPUT_SUPPLIER),
+            gShellLevel3HiiHandle,
+            (CHAR16 *) PcdGetPtr (PcdShellSupplier)
            );

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLib/UefiShellLib.c

-              r48674
+              r58459
   Provides interface to shell functionality for shell commands and applications.
   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
   are licensed and made available under the terms and conditions of the BSD License
 …
   EFI_FILE_PROTOCOL               *Handle1;
   EFI_FILE_PROTOCOL               *Handle2;
+  CHAR16                          *FnafPathName;
+  UINTN                           PathLen;
   if (FilePath == NULL || FileHandle == NULL || DeviceHandle == NULL) {
 …
     //
+    // File Name Alignment Fix (FNAF)
+    // Handle2->Open may be incapable of handling a unaligned CHAR16 data.
+    // The structure pointed to by FilePath may be not CHAR16 aligned.
+    // This code copies the potentially unaligned PathName data from the
+    // FilePath structure to the aligned FnafPathName for use in the
+    // calls to Handl2->Open.
+    //
+    //
+    // Determine length of PathName, in bytes.
+    //
+    PathLen = DevicePathNodeLength (*FilePath) - SIZE_OF_FILEPATH_DEVICE_PATH;
+    //
+    // Allocate memory for the aligned copy of the string Extra allocation is to allow for forced alignment
+    // Copy bytes from possibly unaligned location to aligned location
+    //
+    FnafPathName = AllocateCopyPool(PathLen, (UINT8 *)((FILEPATH_DEVICE_PATH*)*FilePath)->PathName);
+    if (FnafPathName == NULL) {
+      return EFI_OUT_OF_RESOURCES;
+    }
+    //
     // Try to test opening an existing file
     //
 …
                           Handle2,
                           &Handle1,
                           ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
+                          FnafPathName,
                           OpenMode &~EFI_FILE_MODE_CREATE,
 …
                             Handle2,
                             &Handle1,
                             ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,
+                            FnafPathName,
                             OpenMode,
                             Attributes
                            );
+    }
+    //
+    // Free the alignment buffer
+    //
+    FreePool(FnafPathName);
     //
     // Close the last node
 …
   device.
   The EnvironmentVariables and Status parameters are ignored in a pre-UEFI Shell 2.0
+  The EnvironmentVariables pararemeter is ignored in a pre-UEFI Shell 2.0
   environment.  The values pointed to by the parameters will be unchanged by the
   ShellExecute() function.  The Output parameter has no effect in a
 …
+  )
+{
+  EFI_STATUS                CmdStatus;
   //
   // Check for UEFI Shell 2.0 protocols
 …
   if (mEfiShellEnvironment2 != NULL) {
     //
     // Call EFI Shell version (not using EnvironmentVariables or Status parameters)
+    // Call EFI Shell version.
     // Due to oddity in the EFI shell we want to dereference the ParentHandle here
     //
     return (mEfiShellEnvironment2->Execute(*ParentHandle,
+    CmdStatus = (mEfiShellEnvironment2->Execute(*ParentHandle,
                                           CommandLine,
                                           Output));
+    //
+    // No Status output parameter so just use the returned status
+    //
+    if (Status != NULL) {
+      *Status = CmdStatus;
+    }
+    //
+    // If there was an error, we can't tell if it was from the command or from
+    // the Execute() function, so we'll just assume the shell ran successfully
+    // and the error came from the command.
+    //
+    return EFI_SUCCESS;
+  }
   return (EFI_UNSUPPORTED);
+}
 /**
   Retreives the current directory path
 …
     // allocate new space to copy strings and structure
     //
     NewInfo->FullName     = AllocateZeroPool(StrSize(OldInfo->FullName));
     NewInfo->FileName     = AllocateZeroPool(StrSize(OldInfo->FileName));
     NewInfo->Info         = AllocateZeroPool((UINTN)OldInfo->Info->Size);
+    NewInfo->FullName     = AllocateCopyPool(StrSize(OldInfo->FullName), OldInfo->FullName);
+    NewInfo->FileName     = AllocateCopyPool(StrSize(OldInfo->FileName), OldInfo->FileName);
+    NewInfo->Info         = AllocateCopyPool((UINTN)OldInfo->Info->Size, OldInfo->Info);
     //
 …
     //
     if (NULL == NewInfo->FullName || NewInfo->FileName == NULL || NewInfo->Info == NULL) {
+      //
+      // Free the partially allocated new node
+      //
+      SHELL_FREE_NON_NULL(NewInfo->FullName);
+      SHELL_FREE_NON_NULL(NewInfo->FileName);
+      SHELL_FREE_NON_NULL(NewInfo->Info);
+      SHELL_FREE_NON_NULL(NewInfo);
+      //
+      // Free the previously converted stuff
+      //
       ShellCloseFileMetaArg((EFI_SHELL_FILE_INFO**)(&ListHead));
       ListHead = NULL;
 …
     //
-    // Copt the strings and structure
-    //
-    StrCpy(NewInfo->FullName, OldInfo->FullName);
-    StrCpy(NewInfo->FileName, OldInfo->FileName);
-    gBS->CopyMem (NewInfo->Info, OldInfo->Info, (UINTN)OldInfo->Info->Size);
-    //
     // add that to the list
     //
 …
   This function uses the Arg to open all the matching files. Each matched
   file has a SHELL_FILE_ARG structure to record the file information. These
   structures are placed on the list ListHead. Users can get the SHELL_FILE_ARG
+  file has a SHELL_FILE_INFO structure to record the file information. These
+  structures are placed on the list ListHead. Users can get the SHELL_FILE_INFO
   structures from ListHead to access each file. This function supports wildcards
   and will process '?' and '*' as such.  the list must be freed with a call to
 …
   EFI_STATUS                    Status;
   LIST_ENTRY                    mOldStyleFileList;
+  CHAR16                        *CleanFilePathStr;
   //
 …
   ASSERT(Arg      != NULL);
   ASSERT(ListHead != NULL);
+  CleanFilePathStr = NULL;
+  Status = InternalShellStripQuotes (Arg, &CleanFilePathStr);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
   //
 …
       *ListHead = (EFI_SHELL_FILE_INFO*)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
       if (*ListHead == NULL) {
+        FreePool(CleanFilePathStr);
         return (EFI_OUT_OF_RESOURCES);
+      }
       InitializeListHead(&((*ListHead)->Link));
+    }
     Status = gEfiShellProtocol->OpenFileList(Arg,
+    Status = gEfiShellProtocol->OpenFileList(CleanFilePathStr,
                                            OpenMode,
                                            ListHead);
 …
     if (*ListHead != NULL && IsListEmpty(&(*ListHead)->Link)) {
       FreePool(*ListHead);
+      FreePool(CleanFilePathStr);
       *ListHead = NULL;
       return (EFI_NOT_FOUND);
+    }
+    FreePool(CleanFilePathStr);
     return (Status);
+  }
 …
     // Get the EFI Shell list of files
     //
     Status = mEfiShellEnvironment2->FileMetaArg(Arg, &mOldStyleFileList);
+    Status = mEfiShellEnvironment2->FileMetaArg(CleanFilePathStr, &mOldStyleFileList);
     if (EFI_ERROR(Status)) {
       *ListHead = NULL;
+      FreePool(CleanFilePathStr);
       return (Status);
+    }
 …
       *ListHead = (EFI_SHELL_FILE_INFO    *)AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));
       if (*ListHead == NULL) {
+        FreePool(CleanFilePathStr);
         return (EFI_OUT_OF_RESOURCES);
+      }
 …
       Status = EFI_NOT_FOUND;
+    }
+    FreePool(CleanFilePathStr);
     return (Status);
+  }
+  FreePool(CleanFilePathStr);
   return (EFI_UNSUPPORTED);
+}
 …
       FreePool((EFI_SHELL_FILE_INFO_NO_CONST*)Node);
+    }
+    SHELL_FREE_NON_NULL(*ListHead);
     return EFI_SUCCESS;
+  }
 …
       return (NULL);
+    }
     StrCpy(TestPath, Path);
     StrCat(TestPath, FileName);
+    StrnCpy(TestPath, Path, Size/sizeof(CHAR16) - 1);
+    StrnCat(TestPath, FileName, Size/sizeof(CHAR16) - 1 - StrLen(TestPath));
     Status = ShellOpenFileByName(TestPath, &Handle, EFI_FILE_MODE_READ, 0);
     if (!EFI_ERROR(Status)){
 …
+        }
         if (TestPath[StrLen(TestPath)-1] != L'\\') {
           StrCat(TestPath, L"\\");
+          StrnCat(TestPath, L"\\", Size/sizeof(CHAR16) - 1 - StrLen(TestPath));
+        }
         if (FileName[0] == L'\\') {
           FileName++;
+        }
         StrCat(TestPath, FileName);
+        StrnCat(TestPath, FileName, Size/sizeof(CHAR16) - 1 - StrLen(TestPath));
         if (StrStr(Walker, L";") != NULL) {
           Walker = StrStr(Walker, L";") + 1;
 …
+  }
   for (ExtensionWalker = FileExtension, TempChar2 = (CHAR16*)FileExtension;  TempChar2 != NULL ; ExtensionWalker = TempChar2 + 1){
     StrCpy(TestPath, FileName);
+    StrnCpy(TestPath, FileName, Size/sizeof(CHAR16) - 1);
     if (ExtensionWalker != NULL) {
       StrCat(TestPath, ExtensionWalker);
+      StrnCat(TestPath, ExtensionWalker, Size/sizeof(CHAR16) - 1 - StrLen(TestPath));
+    }
     TempChar = StrStr(TestPath, L";");
 …
   // If we accept numbers then dont return TRUE. (they will be values)
   //
   if (((Name[0] == L'-' || Name[0] == L'+') && ShellIsHexaDecimalDigitCharacter(Name[1])) && AlwaysAllowNumbers) {
+  if (((Name[0] == L'-' || Name[0] == L'+') && InternalShellIsHexOrDecimalNumber(Name+1, FALSE, FALSE)) && AlwaysAllowNumbers) {
     return (FALSE);
+  }
 …
   UINTN                         Count;
   CONST CHAR16                  *TempPointer;
+  UINTN                         CurrentValueSize;
   CurrentItemPackage = NULL;
 …
         return (EFI_OUT_OF_RESOURCES);
+      }
       CurrentItemPackage->Name  = AllocateZeroPool(StrSize(Argv[LoopCounter]));
+      CurrentItemPackage->Name  = AllocateCopyPool(StrSize(Argv[LoopCounter]), Argv[LoopCounter]);
       if (CurrentItemPackage->Name == NULL) {
         ShellCommandLineFreeVarList(*CheckPackage);
 …
         return (EFI_OUT_OF_RESOURCES);
+      }
-      StrCpy(CurrentItemPackage->Name,  Argv[LoopCounter]);
       CurrentItemPackage->Type  = CurrentItemType;
       CurrentItemPackage->OriginalPosition = (UINTN)(-1);
 …
       // get the item VALUE for a previous flag
       //
+      CurrentItemPackage->Value = ReallocatePool(ValueSize, ValueSize + StrSize(Argv[LoopCounter]) + sizeof(CHAR16), CurrentItemPackage->Value);
+      ASSERT(CurrentItemPackage->Value != NULL);
+      if (ValueSize == 0) {
+        StrCpy(CurrentItemPackage->Value, Argv[LoopCounter]);
+      if (StrStr(Argv[LoopCounter], L" ") == NULL) {
+        CurrentValueSize = ValueSize + StrSize(Argv[LoopCounter]) + sizeof(CHAR16);
+        CurrentItemPackage->Value = ReallocatePool(ValueSize, CurrentValueSize, CurrentItemPackage->Value);
+        ASSERT(CurrentItemPackage->Value != NULL);
+        if (ValueSize == 0) {
+          StrnCpy(CurrentItemPackage->Value, Argv[LoopCounter], CurrentValueSize/sizeof(CHAR16) - 1);
+        } else {
+          StrnCat(CurrentItemPackage->Value, L" ", CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+          StrnCat(CurrentItemPackage->Value, Argv[LoopCounter], CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+        }
+        ValueSize += StrSize(Argv[LoopCounter]) + sizeof(CHAR16);
       } else {
+        StrCat(CurrentItemPackage->Value, L" ");
+        StrCat(CurrentItemPackage->Value, Argv[LoopCounter]);
+      }
+      ValueSize += StrSize(Argv[LoopCounter]) + sizeof(CHAR16);
+        //
+        // the parameter has spaces.  must be quoted.
+        //
+        CurrentValueSize =  ValueSize + StrSize(Argv[LoopCounter]) + sizeof(CHAR16) + sizeof(CHAR16) + sizeof(CHAR16);
+        CurrentItemPackage->Value = ReallocatePool(ValueSize, CurrentValueSize, CurrentItemPackage->Value);
+        ASSERT(CurrentItemPackage->Value != NULL);
+        if (ValueSize == 0) {
+          StrnCpy(CurrentItemPackage->Value, L"\"", CurrentValueSize/sizeof(CHAR16) - 1);
+          StrnCat(CurrentItemPackage->Value, Argv[LoopCounter], CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+          StrnCat(CurrentItemPackage->Value, L"\"", CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+        } else {
+          StrnCat(CurrentItemPackage->Value, L" ", CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+          StrnCat(CurrentItemPackage->Value, L"\"", CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+          StrnCat(CurrentItemPackage->Value, Argv[LoopCounter], CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+          StrnCat(CurrentItemPackage->Value, L"\"", CurrentValueSize/sizeof(CHAR16) - 1 - StrLen(CurrentItemPackage->Value));
+       }
+        ValueSize += StrSize(Argv[LoopCounter]) + sizeof(CHAR16);
+      }
       GetItemValue--;
       if (GetItemValue == 0) {
 …
       CurrentItemPackage->Name  = NULL;
       CurrentItemPackage->Type  = TypePosition;
       CurrentItemPackage->Value = AllocateZeroPool(StrSize(TempPointer));
+      CurrentItemPackage->Value = AllocateCopyPool(StrSize(TempPointer), TempPointer);
       if (CurrentItemPackage->Value == NULL) {
         ShellCommandLineFreeVarList(*CheckPackage);
 …
         return (EFI_OUT_OF_RESOURCES);
+      }
-      StrCpy(CurrentItemPackage->Value, TempPointer);
       CurrentItemPackage->OriginalPosition = Count++;
       InsertHeadList(*CheckPackage, &CurrentItemPackage->Link);
 …
       //
       if (ProblemParam != NULL) {
+        *ProblemParam = AllocateZeroPool(StrSize(Argv[LoopCounter]));
+        if (*ProblemParam != NULL) {
+          StrCpy(*ProblemParam, Argv[LoopCounter]);
+        }
+        *ProblemParam = AllocateCopyPool(StrSize(Argv[LoopCounter]), Argv[LoopCounter]);
+      }
       ShellCommandLineFreeVarList(*CheckPackage);
 …
 /**
   Determins if a parameter is duplicated.
+  Determines if a parameter is duplicated.
   If Param is not NULL then it will point to a callee allocated string buffer
 …
     return (EFI_OUT_OF_RESOURCES);
+  }
   NewString = SetMem16(NewString, NewSize, CHAR_NULL);
+  NewString = ZeroMem(NewString, NewSize);
   while (*SourceString != CHAR_NULL) {
     //
 …
         return (EFI_BUFFER_TOO_SMALL);
+      }
       StrCat(NewString, Replace);
+      StrnCat(NewString, Replace, NewSize/sizeof(CHAR16) - 1 - StrLen(NewString));
     } else {
       Size = StrSize(NewString);
 …
+  }
   if (mEfiShellInterface          != NULL) {
+    if (mEfiShellInterface->RedirArgc == 0) {
     //
     // Divide in half for old shell.  Must be string length not size.
+    //
+    Size /= 2;
+      //
+      Size /=2;  // Divide in half only when no redirection.
+    }
     return (mEfiShellInterface->StdOut->Write(mEfiShellInterface->StdOut,          &Size, (VOID*)String));
+  }
 …
     if (ResumeLocation != NULL) {
       if (*(ResumeLocation-1) == L'^') {
+        //
+        // Move cursor back 1 position to overwrite the ^
+        //
+        gST->ConOut->SetCursorPosition(gST->ConOut, gST->ConOut->Mode->CursorColumn - 1, gST->ConOut->Mode->CursorRow);
         //
         // Print a simple '%' symbol
 …
 /**
+  Function return the number converted from a hex representation of a number.
+  Note: this function cannot be used when (UINTN)(-1), (0xFFFFFFFF) may be a valid
+  result.  Use ShellConvertStringToUint64 instead.
+  @param[in] String   String representation of a number.
+  @return             The unsigned integer result of the conversion.
+  @retval (UINTN)(-1) An error occured.
+**/
+UINTN
+EFIAPI
+ShellHexStrToUintn(
+  IN CONST CHAR16 *String
+  )
+{
+  UINT64        RetVal;
+  if (!EFI_ERROR(ShellConvertStringToUint64(String, &RetVal, TRUE, TRUE))) {
+    return ((UINTN)RetVal);
+  }
+  return ((UINTN)(-1));
+}
+/**
   Function to determine whether a string is decimal or hex representation of a number
   and return the number converted from the string.
+  and return the number converted from the string.  Spaces are always skipped.
   @param[in] String   String representation of a number
 …
   if (CurrentSize != NULL) {
     NewSize = *CurrentSize;
+    while (NewSize < (DestinationStartSize + (Count*sizeof(CHAR16)))) {
+      NewSize += 2 * Count * sizeof(CHAR16);
+    }
+    *Destination = ReallocatePool(*CurrentSize, NewSize, *Destination);
+    *CurrentSize = NewSize;
+    if (NewSize < DestinationStartSize + (Count * sizeof(CHAR16))) {
+      while (NewSize < (DestinationStartSize + (Count*sizeof(CHAR16)))) {
+        NewSize += 2 * Count * sizeof(CHAR16);
+      }
+      *Destination = ReallocatePool(*CurrentSize, NewSize, *Destination);
+      *CurrentSize = NewSize;
+    }
   } else {
     *Destination = AllocateZeroPool((Count+1)*sizeof(CHAR16));
 …
       gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
       Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+      ASSERT_EFI_ERROR(Status);
+      if (EFI_ERROR(Status)) {
+        break;
+      }
       ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
       if (Key.UnicodeChar == L'Q' || Key.UnicodeChar ==L'q') {
 …
       *Resp = ShellPromptResponseMax;
       while (*Resp == ShellPromptResponseMax) {
+        if (ShellGetExecutionBreakFlag()) {
+          Status = EFI_ABORTED;
+          break;
+        }
         gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+        ASSERT_EFI_ERROR(Status);
+        if (EFI_ERROR(Status)) {
+          break;
+        }
         ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
         switch (Key.UnicodeChar) {
 …
       *Resp = ShellPromptResponseMax;
       while (*Resp == ShellPromptResponseMax) {
+        if (ShellGetExecutionBreakFlag()) {
+          Status = EFI_ABORTED;
+          break;
+        }
         gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+        ASSERT_EFI_ERROR(Status);
+        if (EFI_ERROR(Status)) {
+          break;
+        }
         ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
         switch (Key.UnicodeChar) {
 …
       *Resp = ShellPromptResponseMax;
       while (*Resp == ShellPromptResponseMax) {
+        if (ShellGetExecutionBreakFlag()) {
+          Status = EFI_ABORTED;
+          break;
+        }
         gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
         if (Type == ShellPromptResponseTypeEnterContinue) {
           Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+          ASSERT_EFI_ERROR(Status);
+          if (EFI_ERROR(Status)) {
+            break;
+          }
           ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
           if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 …
       *Resp = ShellPromptResponseMax;
       while (*Resp == ShellPromptResponseMax) {
+        if (ShellGetExecutionBreakFlag()) {
+          Status = EFI_ABORTED;
+          break;
+        }
         gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+        ASSERT_EFI_ERROR(Status);
+        if (EFI_ERROR(Status)) {
+          break;
+        }
         ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
         switch (Key.UnicodeChar) {
 …
+      }
       while(1) {
+        if (ShellGetExecutionBreakFlag()) {
+          Status = EFI_ABORTED;
+          break;
+        }
         gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &EventIndex);
         Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
+        ASSERT_EFI_ERROR(Status);
+        if (EFI_ERROR(Status)) {
+          break;
+        }
         ShellPrintEx(-1, -1, L"%c", Key.UnicodeChar);
         if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {
 …
     //
     // This is the location to add new prompt types.
+    // If your new type loops remember to add ExecutionBreak support.
     //
     default:
 …
     //
     // Skip spaces if requested
     //
     while (StopAtSpace && *String == L' ') {
       String++;
+    // stop at spaces if requested
+    //
+    if (StopAtSpace && *String == L' ') {
+      break;
+    }
+  }
 …
   return (Status);
+}
+/**
+  Function to print help file / man page content in the spec from the UEFI Shell protocol GetHelpText function.
+  @param[in] CommandToGetHelpOn  Pointer to a string containing the command name of help file to be printed.
+  @param[in] SectionToGetHelpOn  Pointer to the section specifier(s).
+  @param[in] PrintCommandText    If TRUE, prints the command followed by the help content, otherwise prints
+                                 the help content only.
+  @retval EFI_DEVICE_ERROR       The help data format was incorrect.
+  @retval EFI_NOT_FOUND          The help data could not be found.
+  @retval EFI_SUCCESS            The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+ShellPrintHelp (
+  IN CONST CHAR16     *CommandToGetHelpOn,
+  IN CONST CHAR16     *SectionToGetHelpOn,
+  IN BOOLEAN          PrintCommandText
+  )
+{
+        EFI_STATUS          Status;
+        CHAR16              *OutText;
+        OutText = NULL;
+  //
+  // Get the string to print based
+  //
+        Status = gEfiShellProtocol->GetHelpText (CommandToGetHelpOn, SectionToGetHelpOn, &OutText);
+  //
+  // make sure we got a valid string
+  //
+  if (EFI_ERROR(Status)){
+    return Status;
+        }
+  if (OutText == NULL || StrLen(OutText) == 0) {
+    return EFI_NOT_FOUND;
+        }
+  //
+  // Chop off trailing stuff we dont need
+  //
+  while (OutText[StrLen(OutText)-1] == L'\r' || OutText[StrLen(OutText)-1] == L'\n' || OutText[StrLen(OutText)-1] == L' ') {
+    OutText[StrLen(OutText)-1] = CHAR_NULL;
+  }
+  //
+  // Print this out to the console
+  //
+  if (PrintCommandText) {
+    ShellPrintEx(-1, -1, L"%H%-14s%N- %s\r\n", CommandToGetHelpOn, OutText);
+  } else {
+    ShellPrintEx(-1, -1, L"%N%s\r\n", OutText);
+  }
+  SHELL_FREE_NON_NULL(OutText);
+        return EFI_SUCCESS;
+}
+/**
+  Function to delete a file by name
+  @param[in]       FileName       Pointer to file name to delete.
+  @retval EFI_SUCCESS             the file was deleted sucessfully
+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not
+                                  deleted
+  @retval EFI_INVALID_PARAMETER   One of the parameters has an invalid value.
+  @retval EFI_NOT_FOUND           The specified file could not be found on the
+                                  device or the file system could not be found
+                                  on the device.
+  @retval EFI_NO_MEDIA            The device has no medium.
+  @retval EFI_MEDIA_CHANGED       The device has a different medium in it or the
+                                  medium is no longer supported.
+  @retval EFI_DEVICE_ERROR        The device reported an error.
+  @retval EFI_VOLUME_CORRUPTED    The file system structures are corrupted.
+  @retval EFI_WRITE_PROTECTED     The file or medium is write protected.
+  @retval EFI_ACCESS_DENIED       The file was opened read only.
+  @retval EFI_OUT_OF_RESOURCES    Not enough resources were available to open the
+                                  file.
+  @retval other                   The file failed to open
+**/
+EFI_STATUS
+EFIAPI
+ShellDeleteFileByName(
+  IN CONST CHAR16               *FileName
+  )
+{
+  EFI_STATUS                Status;
+  SHELL_FILE_HANDLE         FileHandle;
+  Status = ShellFileExists(FileName);
+  if (Status == EFI_SUCCESS){
+    Status = ShellOpenFileByName(FileName, &FileHandle, EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE, 0x0);
+    if (Status == EFI_SUCCESS){
+      Status = ShellDeleteFile(&FileHandle);
+    }
+  }
+  return(Status);
+}
+/**
+  Cleans off all the quotes in the string.
+  @param[in]     OriginalString   pointer to the string to be cleaned.
+  @param[out]   CleanString      The new string with all quotes removed.
+                                                  Memory allocated in the function and free
+                                                  by caller.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+InternalShellStripQuotes (
+  IN  CONST CHAR16     *OriginalString,
+  OUT CHAR16           **CleanString
+  )
+{
+  CHAR16            *Walker;
+  if (OriginalString == NULL || CleanString == NULL) {
+    return EFI_INVALID_PARAMETER;
+  }
+  *CleanString = AllocateCopyPool (StrSize (OriginalString), OriginalString);
+  if (*CleanString == NULL) {
+    return EFI_OUT_OF_RESOURCES;
+  }
+  for (Walker = *CleanString; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {
+    if (*Walker == L'\"') {
+      CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));
+    }
+  }
+  return EFI_SUCCESS;
+}

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLib/UefiShellLib.h

-              r48674
+              r58459
   );
+/**
+  Cleans off all the quotes in the string.
+  @param[in]     OriginalString   pointer to the string to be cleaned.
+  @param[out]   CleanString      The new string with all quotes removed.
+                                                  Memory allocated in the function and free
+                                                  by caller.
+  @retval EFI_SUCCESS   The operation was successful.
+**/
+EFI_STATUS
+EFIAPI
+InternalShellStripQuotes (
+  IN  CONST CHAR16     *OriginalString,
+  OUT CHAR16           **CleanString
+  );
 #endif

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellLib/UefiShellLib.inf

-              r48674
+              r58459
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = ShellLib|UEFI_APPLICATION UEFI_DRIVER
+  LIBRARY_CLASS                  = ShellLib|UEFI_APPLICATION UEFI_DRIVER DXE_RUNTIME_DRIVER DXE_DRIVER
   CONSTRUCTOR                    = ShellLibConstructor
   DESTRUCTOR                     = ShellLibDestructor
 …
 [Protocols]
   gEfiSimpleFileSystemProtocolGuid              # ALWAYS_CONSUMED
+  gEfiSimpleFileSystemProtocolGuid              ## CONSUMES
   # shell 2.0
   gEfiShellProtocolGuid                         # SOMETIMES_CONSUMED
   gEfiShellParametersProtocolGuid               # SOMETIMES_CONSUMED
+  gEfiShellProtocolGuid                         ## SOMETIMES_CONSUMES
+  gEfiShellParametersProtocolGuid               ## SOMETIMES_CONSUMES
   # 'old' shell
   gEfiShellEnvironment2Guid                     # SOMETIMES_CONSUMED
   gEfiShellInterfaceGuid                        # SOMETIMES_CONSUMED
+  gEfiShellEnvironment2Guid                     ## SOMETIMES_CONSUMES
+  gEfiShellInterfaceGuid                        ## SOMETIMES_CONSUMES
 [Guids]
   gEfiFileInfoGuid                              # ALWAYS_CONSUMED
   gEfiShellEnvironment2ExtGuid                  # ALWAYS_CONSUMED
+  gEfiFileInfoGuid                              ## CONSUMES ## GUID
+  gEfiShellEnvironment2ExtGuid                  ## CONSUMES ## GUID
 [Pcd.common]
   gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize     # ALWAYS_CONSUMED
   gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize       # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize     ## CONSUMES
+  gEfiShellPkgTokenSpaceGuid.PcdShellPrintBufferSize       ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellNetwork1CommandsLib/Ifconfig.c

-              r48674
+              r58459
   The implementation for ifcommand shell command.
+  Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2013 Hewlett-Packard Development Company, L.P.
+  Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
   OriString = String;
   StrCpy (String, L"&OFFSET=");
+  StrnCpy (String, L"&OFFSET=", 9);
   String += StrLen (L"&OFFSET=");
   String += UnicodeSPrint (String, 20, L"%x", Offset);
   StrCpy (String,L"&WIDTH=");
+  StrnCpy (String,L"&WIDTH=", 8);
   String += StrLen (L"&WIDTH=");
   String += UnicodeSPrint (String, 20, L"%x", Width);
   if (Block != NULL) {
     StrCpy (String,L"&VALUE=");
+    StrnCpy (String,L"&VALUE=", 8);
     String += StrLen (L"&VALUE=");
     while ((Width--) != 0) {
 …
   String = ConfigHdr;
   StrCpy (String, L"GUID=");
+  StrnCpy (String, L"GUID=", 6);
   String += StrLen (L"GUID=");
 …
   // Append L"&NAME="
   //
   StrCpy (String, L"&NAME=");
+  StrnCpy (String, L"&NAME=", 7);
   String += StrLen (L"&NAME=");
   for (Index = 0; Index < NameLength ; Index++) {
 …
   // Append L"&PATH="
   //
   StrCpy (String, L"&PATH=");
+  StrnCpy (String, L"&PATH=", 7);
   String += StrLen (L"&PATH=");
   for (Index = 0, Buffer = (UINT8 *) DevicePath; Index < DevicePathLength; Index++) {
 …
+    }
     if (ConfigHdr != NULL) {
       StrCpy (ConfigResp, ConfigHdr);
+      StrnCpy (ConfigResp, ConfigHdr, Length + NIC_ITEM_CONFIG_SIZE * 2 + 100 - 1);
+    }
 …
+  }
   if (ConfigHdr != NULL) {
     StrCpy (ConfigResp, ConfigHdr);
+    StrnCpy (ConfigResp, ConfigHdr, Length + NIC_ITEM_CONFIG_SIZE * 2 + 100 - 1);
+  }
 …
 /**
   Create an IP child, use it to start the auto configuration, then destory it.
+  Create an IP child, use it to start the auto configuration, then destroy it.
   @param[in] NicInfo    The pointer to the NIC_INFO of the Nic to be configured.
 …
     Status  = gBS->CreateEvent (
                     EVT_NOTIFY_SIGNAL | EVT_TIMER,
                     TPL_CALLBACK - 1,
+                    TPL_CALLBACK,
                     TimeoutToGetMap,
                     NULL,
 …
   if (StringNoCaseCompare(&Temp, &DhcpTemp) == 0) {
     //
     // Validate the parameter for DHCP, two valid forms: eth0 DHCP and eth0 DHCP perment
+    // Validate the parameter for DHCP, two valid forms: eth0 DHCP and eth0 DHCP permanent
     //
     if ((Argc != 2) && (Argc!= 3)) {
 …
     if ((OldConfig != NULL) && (OldConfig->Source == IP4_CONFIG_SOURCE_DHCP) &&
         (OldConfig->Perment == Permanent)) {
+        (OldConfig->Permanent == Permanent)) {
       ShellPrintHiiEx(-1, -1, NULL,STRING_TOKEN (STR_IFCONFIG_INTERFACE_CONFIGURED), gShellNetwork1HiiHandle, Info->Name);
 …
     //
     // validate the parameter, two forms: eth0 static IP NETMASK GATEWAY and
     // eth0 static IP NETMASK GATEWAY perment
+    // eth0 static IP NETMASK GATEWAY permanent
     //
     if ((Argc != 5) && (Argc != 6)) {
 …
   CopyMem (&Config->NicAddr, &Info->NicAddress, sizeof (NIC_ADDR));
   Config->Perment = Permanent;
+  Config->Permanent = Permanent;
   //
 …
     ShellPrintHiiEx(-1, -1, NULL,
       STRING_TOKEN (STR_IFCONFIG_PERMENT_STATUS),
+      STRING_TOKEN (STR_IFCONFIG_PERMANENT_STATUS),
       gShellNetwork1HiiHandle,
       (NicInfo->ConfigInfo->Perment? L"TRUE":L"FALSE")
+      (NicInfo->ConfigInfo->Permanent? L"TRUE":L"FALSE")
       );
 …
     //
     // The correct command line arguments for setting address are:
     // IfConfig -s eth0 DHCP [perment]
     // IfConfig -s eth0 static ip netmask gateway [perment]
+    // IfConfig -s eth0 DHCP [permanent]
+    // IfConfig -s eth0 static ip netmask gateway [permanent]
     //
     if (Item == NULL || (CountSubItems(Item) < 2) || (CountSubItems(Item) > 6) || (CountSubItems(Item) == 4)) {

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellNetwork1CommandsLib/Ping.c

-              r48674
+              r58459
   The implementation for Ping shell command.
   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+  Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   This program and the accompanying materials
 …
 /**
   Destory the IP instance.
+  Destroy the IP instance.
   @param[in]    Private    The pointer of PING_PRIVATE_DATA.
 …
 VOID
 EFIAPI
 Ping6DestoryIp6Instance (
+Ping6DestroyIp6Instance (
   IN PING_PRIVATE_DATA    *Private
+  )
 …
     if (Private->IpChildHandle != NULL) {
       Ping6DestoryIp6Instance (Private);
+      Ping6DestroyIp6Instance (Private);
+    }

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiShellNetwork1CommandsLib/UefiShellNetwork1CommandsLib.inf

-              r48674
+              r58459
 # Provides shell network1 functions
+#
 # Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved. <BR>
+# Copyright (c) 2010 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
 [Pcd]
   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask # ALWAYS_CONSUMED
+  gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask ## CONSUMES
 [Protocols]
   gEfiCpuArchProtocolGuid                       # ALWAYS_CONSUMED
   gEfiIp6ProtocolGuid                           # SOMETIMES_CONSUMED
   gEfiIp6ServiceBindingProtocolGuid             # SOMETIMES_CONSUMED
   gEfiIp6ConfigProtocolGuid                     # SOMETIMES_CONSUMED
+  gEfiCpuArchProtocolGuid                       ## CONSUMES
+  gEfiIp6ProtocolGuid                           ## SOMETIMES_CONSUMES
+  gEfiIp6ServiceBindingProtocolGuid             ## SOMETIMES_CONSUMES
+  gEfiIp6ConfigProtocolGuid                     ## SOMETIMES_CONSUMES
   gEfiIp6ProtocolGuid                           # SOMETIMES_CONSUMED
   gEfiIp6ServiceBindingProtocolGuid             # SOMETIMES_CONSUMED
   gEfiIp6ConfigProtocolGuid                     # SOMETIMES_CONSUMED
+  gEfiIp6ProtocolGuid                           ## SOMETIMES_CONSUMES
+  gEfiIp6ServiceBindingProtocolGuid             ## SOMETIMES_CONSUMES
+  gEfiIp6ConfigProtocolGuid                     ## SOMETIMES_CONSUMES
 [Guids]
   gShellNetwork1HiiGuid
+  gShellNetwork1HiiGuid                         ## SOMETIMES_CONSUMES ## HII

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiSortLib/UefiSortLib.c

-              r48674
+              r58459
 #include <Protocol/UnicodeCollation.h>
 #include <Protocol/DevicePath.h>
-#include <Protocol/DevicePathToText.h>
 #include <Library/UefiBootServicesTableLib.h>
 …
 #include <Library/MemoryAllocationLib.h>
 #include <Library/SortLib.h>
+STATIC EFI_DEVICE_PATH_TO_TEXT_PROTOCOL *mDevicePathToText = NULL;
+#include <Library/DevicePathLib.h>
 STATIC EFI_UNICODE_COLLATION_PROTOCOL   *mUnicodeCollation = NULL;
 …
+  }
-  if (mDevicePathToText == NULL) {
-    Status = gBS->LocateProtocol(
-      &gEfiDevicePathToTextProtocolGuid,
-      NULL,
-      (VOID**)&mDevicePathToText);
-    ASSERT_EFI_ERROR(Status);
+  }
   if (mUnicodeCollation == NULL) {
     Status = gBS->LocateProtocol(
 …
+  }
   TextPath1 = mDevicePathToText->ConvertDevicePathToText(
+  TextPath1 = ConvertDevicePathToText(
     DevicePath1,
     FALSE,
     FALSE);
   TextPath2 = mDevicePathToText->ConvertDevicePathToText(
+  TextPath2 = ConvertDevicePathToText(
     DevicePath2,
     FALSE,

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/Library/UefiSortLib/UefiSortLib.inf

-              r48674
+              r58459
 #   Library used for sorting routines.
+#
 #  Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved. <BR>
+#  Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved. <BR>
+#
 #  This program and the accompanying materials
 …
   MODULE_TYPE                    = UEFI_DRIVER
   VERSION_STRING                 = 1.0
   LIBRARY_CLASS                  = SortLib|UEFI_APPLICATION UEFI_DRIVER UEFI_DRIVER
+  LIBRARY_CLASS                  = SortLib|UEFI_APPLICATION UEFI_DRIVER UEFI_DRIVER DXE_RUNTIME_DRIVER DXE_DRIVER
+#
 …
   DebugLib
   UefiBootServicesTableLib
+  DevicePathLib
 [Protocols]
+  gEfiUnicodeCollation2ProtocolGuid                       # ALWAYS_CONSUMED
+  gEfiDevicePathProtocolGuid                              # ALWAYS_CONSUMED
+  gEfiDevicePathToTextProtocolGuid                        # ALWAYS_CONSUMED
+  gEfiUnicodeCollation2ProtocolGuid                       ## CONSUMES
+  gEfiDevicePathProtocolGuid                              ## CONSUMES

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/ShellPkg.dec

-              r48674
+              r58459
 ## @file ShellPkg.dec
+#
 # This Package provides all definitions for EFI and UEFI Shell
+#
+# Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
+# (C) Copyright 2013-2014, Hewlett-Packard Development Company, L.P.
+# Copyright (c) 2009 - 2015, Intel Corporation. All rights reserved.<BR>
+#
 # This program and the accompanying materials are licensed and made available under
 …
   PathLib|Include/Library/PathLib.h
+  ## @libraryclass   provides BCFG command
+  BcfgCommandLib|Include/Library/BcfgCommandLib.h
 [Guids]
   gEfiShellEnvironment2ExtGuid    = {0xd2c18636, 0x40e5, 0x4eb5, {0xa3, 0x1b, 0x36, 0x69, 0x5f, 0xd4, 0x2c, 0x87}}
   gEfiShellPkgTokenSpaceGuid        = {0x171e9188, 0x31d3, 0x40f5, {0xb1, 0x0c, 0x53, 0x9b, 0x2d, 0xb9, 0x40, 0xcd}}
+  gEfiShellPkgTokenSpaceGuid      = {0x171e9188, 0x31d3, 0x40f5, {0xb1, 0x0c, 0x53, 0x9b, 0x2d, 0xb9, 0x40, 0xcd}}
   gShellVariableGuid              = {0x158def5a, 0xf656, 0x419c, {0xb0, 0x27, 0x7a, 0x31, 0x92, 0xc0, 0x79, 0xd2}}
   gShellMapGuid                   = {0x51271e13, 0x7de3, 0x43af, {0x8b, 0xc2, 0x71, 0xad, 0x3b, 0x82, 0x43, 0x25}}
 …
   gShellLevel3HiiGuid             = {0x4344558d, 0x4ef9, 0x4725, {0xb1, 0xe4, 0x33, 0x76, 0xe8, 0xd6, 0x97, 0x4f}}
   gShellNetwork1HiiGuid           = {0xf3d301bb, 0xf4a5, 0x45a8, {0xb0, 0xb7, 0xfa, 0x99, 0x9c, 0x62, 0x37, 0xae}}
+  gShellBcfgHiiGuid               = {0x5f5f605d, 0x1583, 0x4a2d, {0xa6, 0xb2, 0xeb, 0x12, 0xda, 0xb4, 0xa2, 0xb6}}
 [Protocols]
+  gEfiShellProtocolGuid           = {0x6302d008, 0x7f9b, 0x4f30, {0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e}}
+  gEfiShellParametersProtocolGuid = {0x752f3136, 0x4e16, 0x4fdc, {0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca}}
+  gEfiShellEnvironment2Guid       = {0x47c7b221, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+  gEfiShellInterfaceGuid          = {0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+  gEfiShellProtocolGuid               = {0x6302d008, 0x7f9b, 0x4f30, {0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e}}
+  gEfiShellParametersProtocolGuid     = {0x752f3136, 0x4e16, 0x4fdc, {0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca}}
+  gEfiShellEnvironment2Guid           = {0x47c7b221, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+  gEfiShellInterfaceGuid              = {0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}
+  gEfiShellDynamicCommandProtocolGuid = {0x3c7200e9, 0x005f, 0x4ea4, {0x87, 0xde, 0xa3, 0xdf, 0xac, 0x8a, 0x27, 0xc3}}
 [PcdsFeatureFlag]
 …
   gEfiShellPkgTokenSpaceGuid.PcdShellMapNameLength|50|UINT8|0x00000009
   ## This determins how many bytes are read out of files at a time for file operations (type, copy, etc...)
   gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize|1000|UINT16|0x0000000A
+  ## This determines how many bytes are read out of files at a time for file operations (type, copy, etc...)
+  gEfiShellPkgTokenSpaceGuid.PcdShellFileOperationSize|1000|UINT32|0x0000000A
 [PcdsFixedAtBuild, PcdsPatchableInModule, PcdsDynamic, PcdsDynamicEx]
 …
   gEfiShellPkgTokenSpaceGuid.PcdShellSupportOldProtocols|FALSE|BOOLEAN|0x00000002
   ## this flag determins whether Page Break (-b) defaults to on or off in the shell
+  ## this flag determines whether Page Break (-b) defaults to on or off in the shell
   gEfiShellPkgTokenSpaceGuid.PcdShellPageBreakDefault|FALSE|BOOLEAN|0x00000006
   ## this flag determins whether insert mode for typing is default (FALSE means typeover)
+  ## this flag determines whether insert mode for typing is default (FALSE means typeover)
   gEfiShellPkgTokenSpaceGuid.PcdShellInsertModeDefault|TRUE|BOOLEAN|0x00000007
   ## this flag determins the default number of screens kept for history log.
+  ## this flag determines the default number of screens kept for history log.
   #  the spec defines 3 as the minimum
   gEfiShellPkgTokenSpaceGuid.PcdShellScreenLogCount|3|UINT8|0x00000008
+  ## Unicode string of the shell supplier
+  gEfiShellPkgTokenSpaceGuid.PcdShellSupplier|L"EDK II"|VOID*|0x00000010

trunk/src/VBox/Devices/EFI/Firmware/ShellPkg/ShellPkg.dsc

-              r48674
+              r58459
 # Shell Package
+#
 # Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
+#
 #    This program and the accompanying materials
 …
   DSC_SPECIFICATION              = 0x00010006
   OUTPUT_DIRECTORY               = Build/Shell
   SUPPORTED_ARCHITECTURES        = IA32|IPF|X64|EBC|ARM
+  SUPPORTED_ARCHITECTURES        = IA32|IPF|X64|EBC|ARM|AARCH64
   BUILD_TARGETS                  = DEBUG|RELEASE
   SKUID_IDENTIFIER               = DEFAULT
 …
   UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf
   UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf
   DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf
+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLibOptionalDevicePathProtocol.inf
   DebugLib|MdePkg/Library/UefiDebugLibConOut/UefiDebugLibConOut.inf
   DebugPrintErrorLevelLib|MdePkg/Library/BaseDebugPrintErrorLevelLib/BaseDebugPrintErrorLevelLib.inf
 …
   PeCoffGetEntryPointLib|MdePkg/Library/BasePeCoffGetEntryPointLib/BasePeCoffGetEntryPointLib.inf
   PathLib|ShellPkg/Library/BasePathLib/BasePathLib.inf
+  BcfgCommandLib|ShellPkg/Library/UefiShellBcfgCommandLib/UefiShellBcfgCommandLib.inf
 [LibraryClasses.ARM]
 …
   NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
+  # Add support for GCC stack protector
+  NULL|MdePkg/Library/BaseStackCheckLib/BaseStackCheckLib.inf
+[LibraryClasses.AARCH64]
+  NULL|ArmPkg/Library/CompilerIntrinsicsLib/CompilerIntrinsicsLib.inf
 [PcdsFixedAtBuild]
   gEfiMdePkgTokenSpaceGuid.PcdDebugPropertyMask|0xFF
 …
 !ifdef $(NO_SHELL_PROFILES)
   gEfiShellPkgTokenSpaceGuid.PcdShellProfileMask|0x00
 !endif
+!endif #$(NO_SHELL_PROFILES)
 [Components]
 …
   ShellPkg/Library/UefiShellLevel2CommandsLib/UefiShellLevel2CommandsLib.inf
   ShellPkg/Library/UefiHandleParsingLib/UefiHandleParsingLib.inf
+  ShellPkg/Library/UefiDpLib/UefiDpLib.inf {
+    <LibraryClasses>
+      TimerLib|MdePkg/Library/BaseTimerLibNullTemplate/BaseTimerLibNullTemplate.inf
+      PerformanceLib|MdePkg/Library/BasePerformanceLibNull/BasePerformanceLibNull.inf
+      DxeServicesLib|MdePkg/Library/DxeServicesLib/DxeServicesLib.inf
+  }
   ShellPkg/Application/Shell/Shell.inf {
 …
       NULL|ShellPkg/Library/UefiShellDebug1CommandsLib/UefiShellDebug1CommandsLib.inf
       NULL|ShellPkg/Library/UefiShellNetwork1CommandsLib/UefiShellNetwork1CommandsLib.inf
+!endif
+!ifdef $(INCLUDE_DP)
+      NULL|ShellPkg/Library/UefiDpLib/UefiDpLib.inf
+!endif #$(INCLUDE_DP)
+!endif #$(NO_SHELL_PROFILES)
+  }

Changeset 58459 in vbox for trunk/src/VBox/Devices/EFI/Firmware/ShellPkg

Legend:

Download in other formats: