First (Alpha) release of ShellPkg
authorjcarsey <jcarsey@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 7 May 2009 18:46:18 +0000 (18:46 +0000)
committerjcarsey <jcarsey@6f19259b-4bc3-4df7-8a09-765794883524>
Thu, 7 May 2009 18:46:18 +0000 (18:46 +0000)
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@8256 6f19259b-4bc3-4df7-8a09-765794883524

13 files changed:
ShellPkg/Application/ShellExecTestApp/SA.C [new file with mode: 0644]
ShellPkg/Application/ShellExecTestApp/SA.inf [new file with mode: 0644]
ShellPkg/Application/ShellLibTestApp/SA3.inf [new file with mode: 0644]
ShellPkg/Application/ShellLibTestApp/sa3.c [new file with mode: 0644]
ShellPkg/Include/Library/ShellLib.h [new file with mode: 0644]
ShellPkg/Include/Protocol/EfiShell.h [new file with mode: 0644]
ShellPkg/Include/Protocol/EfiShellEnvironment2.h [new file with mode: 0644]
ShellPkg/Include/Protocol/EfiShellInterface.h [new file with mode: 0644]
ShellPkg/Include/Protocol/EfiShellParameters.h [new file with mode: 0644]
ShellPkg/Library/BaseShellLib/BaseShellLib.c [new file with mode: 0644]
ShellPkg/Library/BaseShellLib/BaseShellLib.inf [new file with mode: 0644]
ShellPkg/ShellPkg.dec [new file with mode: 0644]
ShellPkg/ShellPkg.dsc [new file with mode: 0644]

diff --git a/ShellPkg/Application/ShellExecTestApp/SA.C b/ShellPkg/Application/ShellExecTestApp/SA.C
new file mode 100644 (file)
index 0000000..7db28f6
--- /dev/null
@@ -0,0 +1,38 @@
+/** @file\r
+  This is a simple shell application\r
+\r
+  Copyright (c) 2008, Intel Corporation                                                         \r
+  All rights reserved. This program and the accompanying materials                          \r
+  are licensed and made available under the terms and conditions of the BSD License         \r
+  which accompanies this distribution.  The full text of the license may be found at        \r
+  http://opensource.org/licenses/bsd-license.php                                            \r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+**/\r
+\r
+#include <Uefi.h>\r
+#include <Library/UefiApplicationEntryPoint.h>\r
+#include <Library/UefiLib.h>\r
+\r
+/**\r
+  as the real entry point for the application.\r
+\r
+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  \r
+  @param[in] SystemTable    A pointer to the EFI System Table.\r
+  \r
+  @retval EFI_SUCCESS       The entry point is executed successfully.\r
+  @retval other             Some error occurs when executing this entry point.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+UefiMain (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+{\r
+  Print(L"ShellExecute - Pass"); \r
+  return EFI_SUCCESS;\r
+}
\ No newline at end of file
diff --git a/ShellPkg/Application/ShellExecTestApp/SA.inf b/ShellPkg/Application/ShellExecTestApp/SA.inf
new file mode 100644 (file)
index 0000000..0384eaa
--- /dev/null
@@ -0,0 +1,50 @@
+#/** @file\r
+#  Sample UEFI Application Reference EDKII Module\r
+#\r
+#  This is a simple shell application\r
+#\r
+#  Copyright (c) 2009, Intel Corporation.\r
+#\r
+#  All rights reserved. This program and the accompanying materials\r
+#  are licensed and made available under the terms and conditions of the BSD License\r
+#  which accompanies this distribution. The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.php\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#\r
+#**/\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = EmptyApplication\r
+  FILE_GUID                      = 8F7D7B1D-0E1C-4c98-B12E-4EC99C4081AC\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 1.0\r
+  ENTRY_POINT                    = UefiMain\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources]\r
+  SA.C\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  \r
+[LibraryClasses]\r
+  UefiApplicationEntryPoint\r
+  UefiLib\r
+  \r
+[Guids]\r
+\r
+[Ppis]\r
+\r
+[Protocols]\r
+\r
+[FeaturePcd]\r
+\r
+[Pcd]\r
diff --git a/ShellPkg/Application/ShellLibTestApp/SA3.inf b/ShellPkg/Application/ShellLibTestApp/SA3.inf
new file mode 100644 (file)
index 0000000..dbfa783
--- /dev/null
@@ -0,0 +1,54 @@
+#/** @file\r
+#  Sample UEFI Application Reference EDKII Module\r
+#\r
+#  This is a simple shell application\r
+#\r
+#  Copyright (c) 2009, Intel Corporation.\r
+#\r
+#  All rights reserved. This program and the accompanying materials\r
+#  are licensed and made available under the terms and conditions of the BSD License\r
+#  which accompanies this distribution. The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.php\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#\r
+#**/\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010005\r
+  BASE_NAME                      = SimpleApplication\r
+  FILE_GUID                      = 10C75C00-3052-4467-9ED8-7196CAAF610F\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 1.0\r
+  ENTRY_POINT                    = UefiMain\r
+\r
+#\r
+# The following information is for reference only and not required by the build tools.\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources]\r
+  sa3.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  ShellPkg/ShellPkg.dec\r
+  \r
+[LibraryClasses]\r
+  UefiApplicationEntryPoint\r
+  UefiLib\r
+  ShellLib\r
+  MemoryAllocationLib\r
+  DebugLib\r
+  \r
+[Guids]\r
+\r
+[Ppis]\r
+\r
+[Protocols]\r
+\r
+[FeaturePcd]\r
+\r
+[Pcd]\r
diff --git a/ShellPkg/Application/ShellLibTestApp/sa3.c b/ShellPkg/Application/ShellLibTestApp/sa3.c
new file mode 100644 (file)
index 0000000..ae677b4
--- /dev/null
@@ -0,0 +1,336 @@
+/** @file\r
+  This is a simple shell application\r
+\r
+  This should be executed with "/Param2 Val1" and "/Param1" as the 2 command line options!\r
+\r
+  Copyright (c) 2008, Intel Corporation                                                         \r
+  All rights reserved. This program and the accompanying materials                          \r
+  are licensed and made available under the terms and conditions of the BSD License         \r
+  which accompanies this distribution.  The full text of the license may be found at        \r
+  http://opensource.org/licenses/bsd-license.php                                            \r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+**/\r
+\r
+#include <Uefi.h>\r
+#include <Library/UefiApplicationEntryPoint.h>\r
+#include <Library/UefiLib.h>\r
+#include <Library/ShellLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+\r
+SHELL_PARAM_ITEM ParamList[] = {\r
+  {L"/Param1", TypeFlag},\r
+  {L"/Param2", TypeValue},\r
+  {NULL, TypeMax}};\r
+\r
+/**\r
+  as the real entry point for the application.\r
+\r
+  @param[in] ImageHandle    The firmware allocated handle for the EFI image.  \r
+  @param[in] SystemTable    A pointer to the EFI System Table.\r
+  \r
+  @retval EFI_SUCCESS       The entry point is executed successfully.\r
+  @retval other             Some error occurs when executing this entry point.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+UefiMain (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+{\r
+  EFI_FILE_HANDLE     FileHandle;\r
+  EFI_STATUS          Status;\r
+  CHAR16              FileName[100];\r
+  UINTN               BufferSize;\r
+  UINT64              Position;\r
+  UINT8               Buffer[200];\r
+  EFI_FILE_INFO       *pFileInfo;\r
+  UINT64              Size;\r
+  BOOLEAN             NoFile;\r
+  EFI_SHELL_FILE_INFO *pShellFileInfo, *pShellFileInfo2;\r
+  LIST_ENTRY          *List;\r
+  \r
+  FileHandle = NULL;\r
+  StrCpy(FileName, L"testfile.txt");\r
+  Position = 0;\r
+  pFileInfo = NULL;\r
+  Size = 0;\r
+  NoFile = FALSE;\r
+  pShellFileInfo = NULL;\r
+  List = NULL;\r
+\r
+  ASSERT(ShellGetExecutionBreakFlag() == FALSE);\r
+  ASSERT(StrCmp(ShellGetCurrentDir(NULL), L"f8:\\") == 0);\r
+  Print(L"execution break and get cur dir - pass\r\n");\r
+\r
+  ShellSetPageBreakMode(TRUE);\r
+\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+\r
+  BufferSize = StrSize(FileName);\r
+  Status = ShellWriteFile(FileHandle, &BufferSize, FileName);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellGetFilePosition(FileHandle, &Position);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(Position == 0x1A);\r
+  Status = ShellSetFilePosition(FileHandle, 0);\r
+  ASSERT_EFI_ERROR(Status);\r
+  BufferSize = sizeof(Buffer) * sizeof(Buffer[0]);\r
+  Status = ShellReadFile(FileHandle, &BufferSize, Buffer);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(BufferSize == 0x1A);\r
+  ASSERT(StrCmp((CHAR16*)Buffer, FileName) == 0);\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  ASSERT(StrCmp(pFileInfo->FileName, FileName) == 0);\r
+  ASSERT(pFileInfo->FileSize == 0x1A);\r
+  FreePool(pFileInfo);\r
+  pFileInfo = NULL;\r
+  Status = ShellCloseFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"read, write, create, getinfo - pass\r\n");\r
+\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  pFileInfo->FileSize = 0x20;\r
+  Status = ShellSetFileInfo(FileHandle, pFileInfo);\r
+  FreePool(pFileInfo);\r
+  pFileInfo = NULL; \r
+  ASSERT_EFI_ERROR(Status);\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  ASSERT(StrCmp(pFileInfo->FileName, FileName) == 0);\r
+  ASSERT(pFileInfo->PhysicalSize == 0x20);\r
+  ASSERT(pFileInfo->FileSize == 0x20);\r
+  ASSERT((pFileInfo->Attribute&EFI_FILE_DIRECTORY)==0);\r
+  FreePool(pFileInfo);\r
+  Status = ShellGetFileSize(FileHandle, &Size);\r
+  ASSERT(Size == 0x20);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellCloseFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"setinfo and change size, getsize - pass\r\n");\r
+  \r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  ASSERT(StrCmp(pFileInfo->FileName, FileName) == 0);\r
+  ASSERT(pFileInfo->PhysicalSize == 0x20);\r
+  ASSERT(pFileInfo->FileSize == 0x20);\r
+  ASSERT((pFileInfo->Attribute&EFI_FILE_DIRECTORY)==0);\r
+  FreePool(pFileInfo);\r
+  pFileInfo = NULL;   \r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"reopen file - pass\r\n");\r
+\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  ASSERT(StrCmp(pFileInfo->FileName, FileName) == 0);\r
+  ASSERT(pFileInfo->PhysicalSize == 0x0);\r
+  ASSERT(pFileInfo->FileSize == 0x0);\r
+  ASSERT((pFileInfo->Attribute&EFI_FILE_DIRECTORY)==0);\r
+  FreePool(pFileInfo);\r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"size of empty - pass\r\n");\r
+\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT(Status == EFI_NOT_FOUND);\r
+  ASSERT(FileHandle == NULL);\r
+\r
+  Status = ShellCreateDirectory(FileName, &FileHandle);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(FileHandle != NULL);\r
+  pFileInfo = ShellGetFileInfo(FileHandle);\r
+  ASSERT(pFileInfo != NULL);\r
+  ASSERT(StrCmp(pFileInfo->FileName, FileName) == 0);\r
+  ASSERT(pFileInfo->Attribute&EFI_FILE_DIRECTORY);\r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"Directory create - pass\r\n");\r
+  \r
+  // FindFirst and FindNext\r
+  StrCpy(FileName, L"testDir");\r
+  Status = ShellCreateDirectory(FileName, &FileHandle);\r
+  Status = ShellCloseFile(&FileHandle);\r
+  StrCat(FileName, L"\\File.txt");\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellCloseFile(&FileHandle);\r
+  StrCpy(FileName, L"testDir");\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellFindFirstFile(FileHandle, pFileInfo);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellFindNextFile(FileHandle, pFileInfo, &NoFile);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(NoFile == FALSE);\r
+  Status = ShellFindNextFile(FileHandle, pFileInfo, &NoFile);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(NoFile == FALSE);\r
+  Status = ShellFindNextFile(FileHandle, pFileInfo, &NoFile);\r
+  ASSERT_EFI_ERROR(Status);\r
+  /// @todo - why is NoFile never set? limitation of NT32 file system?\r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT(Status == RETURN_WARN_DELETE_FAILURE);\r
+  Print(L"FindFirst - pass\r\n");\r
+  Print(L"FindNext - Verify with real EFI system.  Cant verify NoFile under NT32\r\n");\r
+\r
+  // open and close meta arg\r
+  Status = ShellOpenFileMetaArg(L"testDir\\*.*", EFI_FILE_MODE_READ, &pShellFileInfo);\r
+  ASSERT_EFI_ERROR(Status);\r
+  ASSERT(pShellFileInfo->Status == 0);\r
+  ASSERT(StrCmp(pShellFileInfo->FileName, L"File.txt") == 0);\r
+  ASSERT(pShellFileInfo->Handle);\r
+  ASSERT(pShellFileInfo->Info);\r
+  ASSERT(pShellFileInfo->Info->FileSize == 0);\r
+  ASSERT(StrCmp(pShellFileInfo->Info->FileName, L"File.txt") == 0);\r
+  ASSERT(pShellFileInfo->Info->Attribute == 0);\r
+  pShellFileInfo2 = (EFI_SHELL_FILE_INFO*)0x12345678;\r
+  Status = ShellOpenFileMetaArg(L"testDir\\*.*", EFI_FILE_MODE_READ, &pShellFileInfo2);\r
+  ASSERT(pShellFileInfo2 == NULL);\r
+  ASSERT(Status == EFI_UNSUPPORTED);\r
+  Status = ShellCloseFileMetaArg(&pShellFileInfo);\r
+  ASSERT_EFI_ERROR(Status);\r
+  Print(L"Open/Close Meta Arg - pass\r\n");\r
+\r
+  // now delete that file and that directory\r
+  StrCat(FileName, L"\\File.txt");\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  StrCpy(FileName, L"testDir");\r
+  ASSERT_EFI_ERROR(Status);\r
+  Status = ShellOpenFileByName(FileName, \r
+                               &FileHandle, \r
+                               EFI_FILE_MODE_CREATE|EFI_FILE_MODE_READ|EFI_FILE_MODE_WRITE, \r
+                               0\r
+                               );\r
+  Status = ShellDeleteFile(&FileHandle);\r
+  ASSERT(FileHandle == NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+\r
+  // get environment variable\r
+  // made for testing under nt32\r
+  ASSERT(StrCmp(ShellGetEnvironmentVariable(L"path"), L".;f8:\\efi\\tools;f8:\\efi\\boot;f8:\\;f9:\\efi\\tools;f9:\\efi\\boot;f9:\\") == 0);\r
+  Print(L"ShellGetEnvironmentVariable - pass\r\n");\r
+\r
+  // set environment variable\r
+  Status = ShellSetEnvironmentVariable(L"", L"", FALSE);\r
+  ASSERT(Status == EFI_UNSUPPORTED);\r
+  Print(L"ShellSetEnvironmentVariable - pass\r\n");\r
+\r
+  // ShellExecute\r
+  Status = ShellExecute(&ImageHandle, L"EmptyApplication.efi", TRUE, NULL, NULL);\r
+  ASSERT_EFI_ERROR(Status);\r
+  // the pass printout for this is performed by EmptyApplication\r
+  Print(L"\r\n");\r
+    \r
+  // command line param functions\r
+  Status = ShellCommandLineParse(ParamList, &List, NULL, FALSE);\r
+  // if you put an invalid parameter you SHOULD hit this assert.\r
+  ASSERT_EFI_ERROR(Status);\r
+  if (List) {\r
+    ASSERT(ShellCommandLineGetFlag(List, L"/Param5") == FALSE);\r
+    ASSERT(ShellCommandLineGetFlag(List, L"/Param1") != FALSE);\r
+    ASSERT(StrCmp(ShellCommandLineGetValue(List, L"/Param2"), L"Val1")==0);\r
+    ASSERT(StrCmp(ShellCommandLineGetRawValue(List, 0), L"SimpleApplication")==0);\r
+\r
+    ShellCommandLineFreeVarList(List);\r
+  } else {\r
+    Print(L"param checking skipped.\r\n");\r
+  }\r
+\r
+  // page break mode (done last so we can see the results)\r
+  // we set this true at the begining of the program\r
+  // this is enough lines to trigger the page...\r
+  Print(L"1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n");\r
+  ShellSetPageBreakMode(FALSE);\r
+  Print(L"1\r\n2\r\n3\r\n4\r\n5\r\n6\r\n7\r\n8\r\n9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35\r\n36\r\n37\r\n38\r\n39\r\n40\r\n41\r\n42\r\n43\r\n44\r\n45\r\n46\r\n47\r\n48\r\n49\r\n50\r\n51\r\n52\r\n53\r\n54\r\n55\r\n56\r\n57\r\n58\r\n59\r\n60\r\n");\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/*\r
+done - ShellGetFileInfo\r
+done - ShellSetFileInfo\r
+done - ShellOpenFileByDevicePath\r
+done - ShellOpenFileByName\r
+done - ShellCreateDirectory\r
+done - ShellReadFile\r
+done - ShellWriteFile\r
+done - ShellCloseFile\r
+done - ShellDeleteFile\r
+done - ShellSetFilePosition\r
+done - ShellGetFilePosition\r
+???? - ShellFlushFile\r
+done - ShellFindFirstFile\r
+done - ShellFindNextFile\r
+done - ShellGetFileSize\r
+done - ShellGetExecutionBreakFlag\r
+done - ShellGetEnvironmentVariable\r
+done - ShellSetEnvironmentVariable\r
+done - ShellExecute\r
+done - ShellGetCurrentDir\r
+done - ShellSetPageBreakMode\r
+done - ShellOpenFileMetaArg\r
+done - ShellCloseFileMetaArg\r
+done - ShellCommandLineParse\r
+done - ShellCommandLineFreeVarList\r
+done - ShellCommandLineGetFlag\r
+done - ShellCommandLineGetValue\r
+done - ShellCommandLineGetRawValue\r
+*/
\ No newline at end of file
diff --git a/ShellPkg/Include/Library/ShellLib.h b/ShellPkg/Include/Library/ShellLib.h
new file mode 100644 (file)
index 0000000..f5e5ba6
--- /dev/null
@@ -0,0 +1,729 @@
+/** @file\r
+  Provides interface to shell functionality for shell commands and applications.\r
+\r
+Copyright (c) 2006 - 2009, Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#if !defined(__SHELL_LIB__)\r
+#define __SHELL_LIB__\r
+\r
+#include <Protocol/SimpleFileSystem.h>\r
+#include <Guid/FileInfo.h>\r
+#include <Protocol/EfiShell.h>\r
+\r
+/**\r
+  This function will retrieve the information about the file for the handle \r
+  specified and store it in allocated pool memory.\r
+\r
+  This function allocates a buffer to store the file\92s information. It is the \r
+  caller\92s responsibility to free the buffer\r
+\r
+  @param  FileHandle  The file handle of the file for which information is \r
+                      being requested.\r
+\r
+  @retval NULL information could not be retrieved.\r
+\r
+  @return the information about the file\r
+**/\r
+EFI_FILE_INFO*\r
+EFIAPI\r
+ShellGetFileInfo (\r
+  IN EFI_FILE_HANDLE            FileHandle\r
+  );\r
+\r
+/**\r
+  This function will set the information about the file for the opened handle \r
+  specified.\r
+\r
+  @param  FileHandle            The file handle of the file for which information \r
+                                is being set\r
+\r
+  @param  FileInfo              The infotmation to set.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_UNSUPPORTED       The InformationType is not known.\r
+  @retval EFI_NO_MEDIA               The device has no medium.\r
+  @retval EFI_DEVICE_ERROR         The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED        The file was opened read only.\r
+  @retval EFI_VOLUME_FULL            The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetFileInfo (\r
+  IN EFI_FILE_HANDLE           FileHandle,\r
+  IN EFI_FILE_INFO              *FileInfo\r
+  );\r
+\r
+/**\r
+  This function will open a file or directory referenced by DevicePath.\r
+\r
+  This function opens a file with the open mode according to the file path. The \r
+  Attributes is valid only for EFI_FILE_MODE_CREATE.\r
+\r
+  @param  FilePath                 on input the device path to the file.  On output \r
+                          the remaining device path.\r
+  @param  DeviceHandle         pointer to the system device handle.\r
+  @param  FileHandle             pointer to the file handle.\r
+  @param  OpenMode             the mode to open the file with.\r
+  @param  Attributes           the file's file attributes.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED            Could not open the file path.     \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found on \r
+                                the device.\r
+  @retval EFI_NO_MEDIA               The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED        The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR         The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED    The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED        The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL            The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileByDevicePath(\r
+  IN OUT EFI_DEVICE_PATH_PROTOCOL        **FilePath,\r
+  OUT EFI_HANDLE                       *DeviceHandle,\r
+  OUT EFI_FILE_HANDLE                  *FileHandle,\r
+  IN UINT64                            OpenMode,\r
+  IN UINT64                            Attributes\r
+  );\r
+\r
+/**\r
+  This function will open a file or directory referenced by filename.\r
+\r
+  If return is EFI_SUCCESS, the Filehandle is the opened file\92s handle; \r
+  otherwise, the Filehandle is NULL. The Attributes is valid only for \r
+  EFI_FILE_MODE_CREATE.\r
+\r
+  @param  FileName               pointer to file name\r
+  @param  FileHandle           pointer to the file handle.\r
+  @param  OpenMode               the mode to open the file with.\r
+  @param  Attributes           the file's file attributes.\r
+\r
+  @retval EFI_SUCCESS          The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED      Could not open the file path.   \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found \r
+                                on the device.\r
+  @retval EFI_NO_MEDIA         The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR     The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED  The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED    The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL      The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileByName(\r
+  IN CHAR16                              *FilePath,\r
+  OUT EFI_FILE_HANDLE           *FileHandle,\r
+  IN UINT64                     OpenMode,\r
+  IN UINT64                            Attributes\r
+  );\r
+\r
+/**\r
+  This function create a directory\r
+\r
+  If return is EFI_SUCCESS, the Filehandle is the opened directory's handle; \r
+  otherwise, the Filehandle is NULL. If the directory already existed, this \r
+  function opens the existing directory.\r
+\r
+  @param  DirectoryName         pointer to Directory name\r
+  @param  FileHandle                   pointer to the file handle.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED      Could not open the file path.   \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found \r
+                                on the device.\r
+  @retval EFI_NO_MEDIA         The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED    The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR     The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED  The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED    The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL      The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCreateDirectory(\r
+  IN CHAR16                   *DirectoryName,\r
+  OUT EFI_FILE_HANDLE         *FileHandle\r
+  );\r
+\r
+/**\r
+  This function reads information from an opened file.\r
+\r
+  If FileHandle is not a directory, the function reads the requested number of \r
+  bytes from the file at the file\92s current position and returns them in Buffer. \r
+  If the read goes beyond the end of the file, the read length is truncated to the\r
+  end of the file. The file\92s current position is increased by the number of bytes \r
+  returned.  If FileHandle is a directory, the function reads the directory entry \r
+  at the file\92s current position and returns the entry in Buffer. If the Buffer \r
+  is not large enough to hold the current directory entry, then \r
+  EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated. \r
+  BufferSize is set to be the size of the buffer needed to read the entry. On \r
+  success, the current position is updated to the next directory entry. If there \r
+  are no more directory entries, the read returns a zero-length buffer. \r
+  EFI_FILE_INFO is the structure returned as the directory entry.\r
+\r
+  @param FileHandle             the opened file handle\r
+  \r
+  @param ReadSize               on input the size of buffer in bytes.  on return \r
+                                the number of bytes written.\r
+\r
+  @param Buffer                 the buffer to put read data into.\r
+\r
+ @retval EFI_SUCCESS           Data was read.\r
+ @retval EFI_NO_MEDIA          The device has no media.\r
+ @retval EFI_DEVICE_ERROR      The device reported an error.\r
+ @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+ @retval EFI_BUFFER_TO_SMALL   Buffer is too small. ReadSize contains required \r
+                                size.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellReadFile(\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  IN OUT UINTN                  *ReadSize,\r
+  OUT VOID                      *Buffer\r
+  );\r
+\r
+/**\r
+  Write data to a file.\r
+\r
+  This function writes the specified number of bytes to the file at the current \r
+  file position. The current file position is advanced the actual number of bytes \r
+  written, which is returned in BufferSize. Partial writes only occur when there \r
+  has been a data error during the write attempt (such as \93volume space full\94). \r
+  The file is automatically grown to hold the data if required. Direct writes to \r
+  opened directories are not supported.\r
+\r
+  @param FileHandle             The opened file for writing\r
+\r
+  @param BufferSize             on input the number of bytes in Buffer.  On output\r
+                                the number of bytes written.\r
+\r
+  @param Buffer                 the buffer containing data to write is stored.\r
+\r
+ @retval EFI_SUCCESS           Data was written.\r
+ @retval EFI_UNSUPPORTED       Writes to an open directory are not supported.\r
+ @retval EFI_NO_MEDIA          The device has no media.\r
+ @retval EFI_DEVICE_ERROR      The device reported an error.\r
+ @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+ @retval EFI_WRITE_PROTECTED   The device is write-protected.\r
+ @retval EFI_ACCESS_DENIED     The file was open for read only.\r
+ @retval EFI_VOLUME_FULL       The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellWriteFile(\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  IN OUT UINTN                  *BufferSize,\r
+  IN CONST VOID                 *Buffer\r
+  );\r
+\r
+/** \r
+  Close an open file handle.\r
+\r
+  This function closes a specified file handle. All \93dirty\94 cached file data is \r
+  flushed to the device, and the file is closed. In all cases the handle is \r
+  closed.\r
+\r
+@param FileHandle               the file handle to close.\r
+\r
+@retval EFI_SUCCESS             the file handle was closed sucessfully.\r
+@retval INVALID_PARAMETER              One of the parameters has an invalid value.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCloseFile (\r
+  IN EFI_FILE_HANDLE            *FileHandle\r
+  );\r
+\r
+/**\r
+  Delete a file and close the handle\r
+\r
+  This function closes and deletes a file. In all cases the file handle is closed.\r
+  If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is \r
+  returned, but the handle is still closed.\r
+\r
+  @param FileHandle             the file handle to delete\r
+\r
+  @retval EFI_SUCCESS           the file was closed sucessfully\r
+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not \r
+                                deleted\r
+  @retval INVALID_PARAMETER            One of the parameters has an invalid value.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellDeleteFile (\r
+  IN EFI_FILE_HANDLE           *FileHandle\r
+  );\r
+\r
+/**\r
+  Set the current position in a file.\r
+\r
+  This function sets the current file position for the handle to the position \r
+  supplied. With the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only\r
+  absolute positioning is supported, and seeking past the end of the file is \r
+  allowed (a subsequent write would grow the file). Seeking to position \r
+  0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.\r
+  If FileHandle is a directory, the only position that may be set is zero. This \r
+  has the effect of starting the read process of the directory entries over.\r
+\r
+  @param FileHandle             The file handle on which the position is being set\r
+\r
+  @param Position               Byte position from begining of file\r
+\r
+  @retval EFI_SUCCESS           Operation completed sucessfully.\r
+  @retval EFI_UNSUPPORTED       the seek request for non-zero is not valid on \r
+                                directories.\r
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetFilePosition (\r
+  IN EFI_FILE_HANDLE           FileHandle,\r
+  IN UINT64            Position\r
+  );\r
+\r
+/** \r
+  Gets a file's current position\r
+\r
+  This function retrieves the current file position for the file handle. For \r
+  directories, the current file position has no meaning outside of the file \r
+  system driver and as such the operation is not supported. An error is returned\r
+  if FileHandle is a directory.\r
+\r
+  @param FileHandle             The open file handle on which to get the position.\r
+  @param Position               Byte position from begining of file.\r
+\r
+  @retval EFI_SUCCESS           the operation completed sucessfully.\r
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED       the request is not valid on directories.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellGetFilePosition (\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  OUT UINT64                    *Position\r
+  );\r
+\r
+/**\r
+  Flushes data on a file\r
+  \r
+  This function flushes all modified data associated with a file to a device.\r
+\r
+  @param FileHandle             The file handle on which to flush data\r
+\r
+  @retval EFI_SUCCESS           The data was flushed.\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED     The file was opened for read only.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFlushFile (\r
+  IN EFI_FILE_HANDLE            FileHandle\r
+  );\r
+\r
+/**\r
+  Retrieves the first file from a directory\r
+\r
+  This function takes an open directory handle and gets the first file \r
+  in the directory's info. Caller can use ShellFindNextFile() to get \r
+  subsequent files.\r
+\r
+  @param DirHandle              The file handle of the directory to search\r
+  @param Buffer                 Pointer to buffer for file's information\r
+\r
+  @retval EFI_SUCCESS           Found the first file.\r
+  @retval EFI_NOT_FOUND         Cannot find the directory.\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @return ShellReadFile\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFindFirstFile (\r
+  IN EFI_FILE_HANDLE            DirHandle,\r
+  OUT EFI_FILE_INFO             *Buffer\r
+  );\r
+\r
+/**\r
+  Retrieves the next file in a directory.\r
+\r
+  To use this function, caller must call the ShellFindFirstFile() to get the \r
+  first file, and then use this function get other files. This function can be \r
+  called for several times to get each file's information in the directory. If \r
+  the call of ShellFindNextFile() got the last file in the directory, the next \r
+  call of this function has no file to get. *NoFile will be set to TRUE and the \r
+  data in Buffer is meaningless. \r
+\r
+  @param DirHandle              the file handle of the directory\r
+  @param Buffer                                    pointer to buffer for file's information\r
+  @param NoFile                                    pointer to boolean when last file is found\r
+\r
+  @retval EFI_SUCCESS           Found the next file.\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFindNextFile(\r
+  IN EFI_FILE_HANDLE             DirHandle,\r
+  OUT EFI_FILE_INFO              *Buffer,\r
+  OUT BOOLEAN                    *NoFile\r
+  );\r
+\r
+/**\r
+  Retrieve the size of a file.\r
+\r
+  This function extracts the file size info from the FileHandle\92s EFI_FILE_INFO \r
+  data.\r
+\r
+  @param FileHandle             file handle from which size is retrieved\r
+  @param Size                   pointer to size\r
+\r
+  @retval EFI_SUCCESS           operation was completed sucessfully\r
+  @retval EFI_DEVICE_ERROR      cannot access the file\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellGetFileSize (\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  OUT UINT64                    *Size\r
+  );\r
+\r
+/**\r
+  Retrieves the status of the break execution flag\r
+\r
+  this function is useful to check whether the application is being asked to halt by the shell.\r
+\r
+  @retval TRUE                  the execution break is enabled\r
+  @retval FALSE                 the execution break is not enabled\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+ShellGetExecutionBreakFlag(\r
+  VOID\r
+  );\r
+\r
+/**\r
+  return the value of an environment variable\r
+\r
+  this function gets the value of the environment variable set by the \r
+  ShellSetEnvironmentVariable function\r
+\r
+  @param EnvKey                 The key name of the environment variable.\r
+\r
+  @retval NULL                  the named environment variable does not exist.\r
+  @return != NULL               pointer to the value of the environment variable\r
+**/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellGetEnvironmentVariable (\r
+  IN CHAR16                     *EnvKey\r
+  );\r
+\r
+/**\r
+  set the value of an environment variable\r
+\r
+This function changes the current value of the specified environment variable. If the\r
+environment variable exists and the Value is an empty string, then the environment\r
+variable is deleted. If the environment variable exists and the Value is not an empty\r
+string, then the value of the environment variable is changed. If the environment\r
+variable does not exist and the Value is an empty string, there is no action. If the\r
+environment variable does not exist and the Value is a non-empty string, then the\r
+environment variable is created and assigned the specified value.\r
+\r
+  This is not supported pre-UEFI Shell 2.0.\r
+\r
+  @param EnvKey                 The key name of the environment variable.\r
+  @param EnvVal                 The Value of the environment variable\r
+  @param Volatile               Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).\r
+\r
+  @retval EFI_SUCCESS           the operation was completed sucessfully\r
+  @retval EFI_UNSUPPORTED       This operation is not allowed in pre UEFI 2.0 Shell environments\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetEnvironmentVariable (\r
+  IN CONST CHAR16               *EnvKey,\r
+  IN CONST CHAR16               *EnvVal,\r
+  IN BOOLEAN                    Volatile\r
+  );\r
+\r
+/**\r
+  cause the shell to parse and execute a command line.\r
+\r
+  This function creates a nested instance of the shell and executes the specified\r
+command (CommandLine) with the specified environment (Environment). Upon return,\r
+the status code returned by the specified command is placed in StatusCode.\r
+If Environment is NULL, then the current environment is used and all changes made\r
+by the commands executed will be reflected in the current environment. If the\r
+Environment is non-NULL, then the changes made will be discarded.\r
+The CommandLine is executed from the current working directory on the current\r
+device.\r
+\r
+EnvironmentVariables and Status are only supported for UEFI Shell 2.0.\r
+Output is only supported for pre-UEFI Shell 2.0\r
+\r
+  @param ImageHandle            Parent image that is starting the operation\r
+  @param CommandLine            pointer to null terminated command line.\r
+  @param Output                 true to display debug output.  false to hide it.\r
+  @param EnvironmentVariables   optional pointer to array of environment variables\r
+                                in the form "x=y".  if NULL current set is used.\r
+  @param Status                 the status of the run command line.\r
+\r
+  @retval EFI_SUCCESS           the operation completed sucessfully.  Status\r
+                                contains the status code returned.\r
+  @retval EFI_INVALID_PARAMETER a parameter contains an invalid value\r
+  @retval EFI_OUT_OF_RESOURCES  out of resources\r
+  @retval EFI_UNSUPPORTED       the operation is not allowed.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellExecute (\r
+  IN EFI_HANDLE                 *ParentHandle,\r
+  IN CHAR16                     *CommandLine,\r
+  IN BOOLEAN                    Output,\r
+  IN CHAR16                     **EnvironmentVariables,\r
+  OUT EFI_STATUS                *Status\r
+  );\r
+\r
+/**\r
+  Retreives the current directory path\r
+\r
+  If the DeviceName is NULL, it returns the current device\92s current directory \r
+  name. If the DeviceName is not NULL, it returns the current directory name \r
+  on specified drive.\r
+\r
+  @param DeviceName             the name of the drive to get directory on\r
+\r
+  @retval NULL                  the directory does not exist\r
+  @return != NULL               the directory\r
+**/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellGetCurrentDir (\r
+  IN CHAR16                     *DeviceName OPTIONAL\r
+  );\r
+\r
+/**\r
+  sets (enabled or disabled) the page break mode\r
+\r
+  when page break mode is enabled the screen will stop scrolling \r
+  and wait for operator input before scrolling a subsequent screen.\r
+\r
+  @param CurrentState           TRUE to enable and FALSE to disable\r
+**/\r
+VOID \r
+EFIAPI\r
+ShellSetPageBreakMode (\r
+  IN BOOLEAN                    CurrentState\r
+  );\r
+\r
+/**\r
+  Opens a group of files based on a path.\r
+\r
+  This function uses the Arg to open all the matching files. Each matched \r
+  file has a SHELL_FILE_ARG structure to record the file information. These \r
+  structures are placed on the list ListHead. Users can get the SHELL_FILE_ARG \r
+  structures from ListHead to access each file. This function supports wildcards\r
+  and will process '?' and '*' as such.  the list must be freed with a call to \r
+  ShellCloseFileMetaArg().\r
+\r
+  This function will fail if called sequentially without freeing the list in the middle.\r
+\r
+  @param Arg                    pointer to path string\r
+  @param OpenMode               mode to open files with\r
+  @param ListHead               head of linked list of results\r
+\r
+  @retval EFI_SUCCESS           the operation was sucessful and the list head \r
+                                contains the list of opened files\r
+  #retval EFI_UNSUPPORTED       a previous ShellOpenFileMetaArg must be closed first.\r
+                                *ListHead is set to NULL.\r
+  @return != EFI_SUCCESS        the operation failed\r
+\r
+  @sa InternalShellConvertFileListType\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileMetaArg (\r
+  IN CHAR16                     *Arg,\r
+  IN UINT64                     OpenMode,\r
+  IN OUT EFI_SHELL_FILE_INFO    **ListHead\r
+  );\r
+\r
+/**\r
+  Free the linked list returned from ShellOpenFileMetaArg\r
+\r
+  @param ListHead               the pointer to free\r
+\r
+  @retval EFI_SUCCESS           the operation was sucessful\r
+  @retval EFI_INVALID_PARAMETER A parameter was invalid\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCloseFileMetaArg (\r
+  IN OUT EFI_SHELL_FILE_INFO    **ListHead\r
+  );\r
+\r
+typedef enum {\r
+  TypeFlag  = 0,\r
+  TypeValue,\r
+  TypePosition,\r
+  TypeMax,\r
+} ParamType;\r
+\r
+typedef struct {\r
+  CHAR16      *Name;\r
+  ParamType   Type;\r
+} SHELL_PARAM_ITEM;\r
+\r
+/**\r
+  Checks the command line arguments passed against the list of valid ones.  \r
+  Optionally removes NULL values first.\r
+  \r
+  If no initialization is required, then return RETURN_SUCCESS.\r
+  \r
+  @param CheckList              pointer to list of parameters to check\r
+  @param CheckPackage           Package of checked values\r
+  @param ProblemParam           optional pointer to pointer to unicode string for \r
+                                the paramater that caused failure.\r
+  @param AutoPageBreak          will automatically set PageBreakEnabled\r
+\r
+  @retval EFI_SUCCESS           The operation completed sucessfully.\r
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed\r
+  @retval EFI_INVALID_PARAMETER A parameter was invalid\r
+  @retval EFI_VOLUME_CORRUPTED  the command line was corrupt.  an argument was \r
+                                duplicated.  the duplicated command line argument \r
+                                was returned in ProblemParam if provided.\r
+  @retval EFI_DEVICE_ERROR      the commands contained 2 opposing arguments.  one\r
+                                of the command line arguments was returned in \r
+                                ProblemParam if provided.\r
+  @retval EFI_NOT_FOUND         a argument required a value that was missing.  \r
+                                the invalid command line argument was returned in\r
+                                ProblemParam if provided.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCommandLineParse (\r
+  IN CONST SHELL_PARAM_ITEM     *CheckList,\r
+  OUT LIST_ENTRY                **CheckPackage,\r
+  OUT CHAR16                    **ProblemParam OPTIONAL,\r
+  IN BOOLEAN                    AutoPageBreak\r
+  );\r
+\r
+/**\r
+  Frees shell variable list that was returned from ShellCommandLineParse.\r
+\r
+  This function will free all the memory that was used for the CheckPackage\r
+  list of postprocessed shell arguments.\r
+\r
+  this function has no return value.\r
+\r
+  if CheckPackage is NULL, then return\r
+\r
+  @param CheckPackage           the list to de-allocate\r
+  **/\r
+VOID\r
+EFIAPI\r
+ShellCommandLineFreeVarList (\r
+  IN LIST_ENTRY                 *CheckPackage\r
+  );\r
+\r
+/**\r
+  Checks for presence of a flag parameter\r
+\r
+  flag arguments are in the form of "-<Key>" or "/<Key>", but do not have a value following the key\r
+\r
+  if CheckPackage is NULL then return FALSE.\r
+  if KeyString is NULL then ASSERT()\r
+  \r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param KeyString              the Key of the command line argument to check for\r
+\r
+  @retval TRUE                  the flag is on the command line\r
+  @retval FALSE                 the flag is not on the command line\r
+  **/\r
+BOOLEAN\r
+EFIAPI\r
+ShellCommandLineGetFlag (\r
+  IN CONST LIST_ENTRY              *CheckPackage,\r
+  IN CHAR16                        *KeyString\r
+  );\r
+\r
+/**\r
+  returns value from command line argument\r
+\r
+  value parameters are in the form of "-<Key> value" or "/<Key> value"\r
+  \r
+  if CheckPackage is NULL, then return NULL;\r
+\r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param KeyString              the Key of the command line argument to check for\r
+\r
+  @retval NULL                  the flag is not on the command line\r
+  @return !=NULL                pointer to unicode string of the value\r
+  **/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellCommandLineGetValue (\r
+  IN CONST LIST_ENTRY              *CheckPackage,\r
+  IN CHAR16                        *KeyString\r
+  );\r
+\r
+/**\r
+  returns raw value from command line argument\r
+\r
+  raw value parameters are in the form of "value" in a specific position in the list\r
+  \r
+  if CheckPackage is NULL, then return NULL;\r
+\r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param Position               the position of the value \r
+\r
+  @retval NULL                  the flag is not on the command line\r
+  @return !=NULL                pointer to unicode string of the value\r
+  **/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellCommandLineGetRawValue (\r
+  IN CONST LIST_ENTRY              *CheckPackage,\r
+  IN UINT32                        Position\r
+  );\r
+\r
+#endif // __SHELL_LIB__
\ No newline at end of file
diff --git a/ShellPkg/Include/Protocol/EfiShell.h b/ShellPkg/Include/Protocol/EfiShell.h
new file mode 100644 (file)
index 0000000..8421056
--- /dev/null
@@ -0,0 +1,949 @@
+/** @file\r
+  EFI Shell protocol as defined in the UEFI Shell 2.0 specification.\r
+  \r
+  Copyright (c) 2006 - 2009, Intel Corporation                                                         \r
+  All rights reserved. This program and the accompanying materials                          \r
+  are licensed and made available under the terms and conditions of the BSD License         \r
+  which accompanies this distribution.  The full text of the license may be found at        \r
+  http://opensource.org/licenses/bsd-license.php                                            \r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+**/\r
+\r
+#ifndef __EFI_SHELL_PROTOCOL__\r
+#define __EFI_SHELL_PROTOCOL__\r
+\r
+#include <Protocol/SimpleFileSystem.h>\r
+#include <Guid/FileInfo.h>\r
+\r
+#define EFI_SHELL_PROTOCOL_GUID \\r
+  { \\r
+  0x6302d008, 0x7f9b, 0x4f30, { 0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e } \\r
+  }\r
+\r
+typedef struct _EFI_LIST_ENTRY {\r
+  struct _EFI_LIST_ENTRY *Flink;\r
+  struct _EFI_LIST_ENTRY *Blink;\r
+} EFI_LIST_ENTRY;\r
+\r
+typedef struct {\r
+  EFI_LIST_ENTRY Link;\r
+  EFI_STATUS Status;\r
+  CONST CHAR16 *FullName;\r
+  CONST CHAR16 *FileName;\r
+  EFI_FILE_HANDLE Handle;\r
+  EFI_FILE_INFO *Info;\r
+} EFI_SHELL_FILE_INFO;\r
+/**\r
+  Returns whether any script files are currently being processed.\r
+\r
+  @retval TRUE                 There is at least one script file active.\r
+  @retval FALSE                No script files are active now.\r
+\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *EFI_SHELL_BATCH_IS_ACTIVE) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  Closes the file handle.\r
+\r
+  This function closes a specified file handle. All 'dirty' cached file data is \r
+  flushed to the device, and the file is closed. In all cases, the handle is \r
+  closed.\r
+\r
+  @param FileHandle             The file handle to be closed\r
+\r
+  @retval EFI_SUCCESS           the file closed sucessfully\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_CLOSE_FILE)(\r
+  IN EFI_FILE_HANDLE FileHandle\r
+  );\r
+\r
+/**\r
+  Creates a file or directory by name.\r
+\r
+  This function creates an empty new file or directory with the specified attributes and\r
+  returns the new file's handle. If the file already exists and is read-only, then\r
+  EFI_INVALID_PARAMETER will be returned.\r
+  \r
+  If the file already existed, it is truncated and its attributes updated. If the file is\r
+  created successfully, the FileHandle is the file's handle, else, the FileHandle is NULL.\r
+  \r
+  If the file name begins with >v, then the file handle which is returned refers to the\r
+  shell environment variable with the specified name. If the shell environment variable\r
+  already exists and is non-volatile then EFI_INVALID_PARAMETER is returned.\r
+\r
+  @param FileName           Pointer to null-terminated file path\r
+  @param FileAttribs        The new file's attrbiutes.  the different attributes are\r
+                            described in EFI_FILE_PROTOCOL.Open().\r
+  @param FileHandle         On return, points to the created file handle or directory's handle\r
+\r
+  @retval EFI_SUCCESS       The file was opened.  FileHandle points to the new file's handle.\r
+  @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED   could not open the file path\r
+  @retval EFI_NOT_FOUND     the specified file could not be found on the devide, or could not\r
+                            file the file system on the device.\r
+  @retval EFI_NO_MEDIA      the device has no medium.\r
+  @retval EFI_MEDIA_CHANGED The device has a different medium in it or the medium is no\r
+                            longer supported.\r
+  @retval EFI_DEVICE_ERROR The device reported an error or can't get the file path according\r
+                            the DirName.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED An attempt was made to create a file, or open a file for write\r
+                            when the media is write-protected.\r
+  @retval EFI_ACCESS_DENIED The service denied access to the file.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the file.\r
+  @retval EFI_VOLUME_FULL   The volume is full.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_CREATE_FILE)(\r
+  IN CONST CHAR16 *FileName,\r
+  IN UINT64 FileAttribs,\r
+  OUT EFI_FILE_HANDLE *FileHandle\r
+  );\r
+\r
+/**\r
+  Deletes the file specified by the file handle.\r
+\r
+  This function closes and deletes a file. In all cases, the file handle is closed. If the file\r
+  cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is returned, but the\r
+  handle is still closed.\r
+\r
+  @param FileHandle           The file handle to delete.\r
+\r
+  @retval EFI_SUCCESS         The file was closed and deleted, and the handle was closed.\r
+  @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_DELETE_FILE)(\r
+  IN EFI_FILE_HANDLE FileHandle\r
+  );\r
+\r
+/**\r
+  Deletes the file specified by the file name.\r
+\r
+  This function deletes a file.\r
+\r
+  @param FileName             Points to the null-terminated file name.\r
+\r
+  @retval EFI_SUCCESS         The file was closed and deleted, and the handle was closed.\r
+  @retval EFI_WARN_DELETE_FAILURE The handle was closed but the file was not deleted.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_DELETE_FILE_BY_NAME)(\r
+  IN CONST CHAR16 *FileName\r
+  );\r
+\r
+/**\r
+  Disables the page break output mode.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *EFI_SHELL_DISABLE_PAGE_BREAK) (\r
+VOID\r
+);\r
+\r
+/**\r
+  Enables the page break output mode.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *EFI_SHELL_ENABLE_PAGE_BREAK) (\r
+VOID\r
+);\r
+\r
+/**\r
+  Execute the command line.\r
+\r
+  This function creates a nested instance of the shell and executes the specified\r
+  command (CommandLine) with the specified environment (Environment). Upon return,\r
+  the status code returned by the specified command is placed in StatusCode.\r
+  \r
+  If Environment is NULL, then the current environment is used and all changes made\r
+  by the commands executed will be reflected in the current environment. If the\r
+  Environment is non-NULL, then the changes made will be discarded.\r
+  \r
+  The CommandLine is executed from the current working directory on the current\r
+  device.\r
+\r
+  @param ParentImageHandle  A handle of the image that is executing the specified \r
+                            command line.  \r
+  @param CommandLine        Points to the null-terminated UCS-2 encoded string \r
+                            containing the command line. If NULL then the command-\r
+                            line will be empty.\r
+  @param Environment        Points to a null-terminated array of environment \r
+                            variables with the format 'x=y', where x is the \r
+                            environment variable name and y is the value. If this\r
+                            is NULL, then the current shell environment is used.\r
+  @param ErrorCode          Points to the status code returned by the command.\r
+\r
+  @retval EFI_SUCCESS       The command executed successfully. The  status code \r
+                            returned by the command is pointed to by StatusCode.\r
+  @retval EFI_INVALID_PARAMETER The parameters are invalid.\r
+  @retval EFI_OUT_OF_RESOURCES Out of resources.\r
+  @retval EFI_UNSUPPORTED   Nested shell invocations are not allowed.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_EXECUTE) (\r
+  IN EFI_HANDLE *ParentImageHandle,\r
+  IN CHAR16 *CommandLine OPTIONAL,\r
+  IN CHAR16 **Environment OPTIONAL,\r
+  OUT EFI_STATUS *StatusCode OPTIONAL\r
+  );\r
+\r
+/**\r
+  Find files that match a specified pattern.\r
+\r
+  This function searches for all files and directories that match the specified\r
+  FilePattern. The FilePattern can contain wild-card characters. The resulting file\r
+  information is placed in the file list FileList.\r
+\r
+  The files in the file list are not opened. The OpenMode field is set to 0 and the FileInfo\r
+  field is set to NULL.\r
+\r
+  @param FilePattern      Points to a null-terminated shell file path, including wildcards.\r
+  @param FileList         On return, points to the start of a file list containing the names \r
+                          of all matching files or else points to NULL if no matching files \r
+                          were found.\r
+\r
+  @retval EFI_SUCCESS     Files found.\r
+  @retval EFI_NOT_FOUND   No files found.\r
+  @retval EFI_NO_MEDIA    The device has no media\r
+  @retval EFI_DEVICE_ERROR The device reported an error\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_FIND_FILES)(\r
+  IN CONST CHAR16 *FilePattern,\r
+  OUT EFI_SHELL_FILE_INFO **FileList\r
+  );\r
+\r
+/**\r
+  Find all files in a specified directory.\r
+\r
+  @param FileDirHandle     Handle of the directory to search.\r
+  @param FileList          On return, points to the list of files in the directory \r
+                           or NULL if there are no files in the directory.\r
+\r
+  @retval EFI_SUCCESS      File information was returned successfully.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures have been corrupted.\r
+  @retval EFI_DEVICE_ERROR The device reported an error.\r
+  @retval EFI_NO_MEDIA     The device media is not present.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_FIND_FILES_IN_DIR)(\r
+IN EFI_FILE_HANDLE FileDirHandle,\r
+OUT EFI_SHELL_FILE_INFO **FileList\r
+);\r
+\r
+/**\r
+  Flushes data back to a device\r
+  \r
+  This function flushes all modified data associated with a file to a device.\r
+\r
+  @param FileHandle             The handle of the file to flush\r
+\r
+  @retval EFI_SUCCESS           The data was flushed.\r
+  @retval EFI_NO_MEDIA          The device has no medium.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED   The file or medium is write-protected.\r
+  @retval EFI_ACCESS_DENIED     The file was opened read-only.\r
+  @retval EFI_VOLUME_FULL       The volume is full.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_FLUSH_FILE)(\r
+  IN EFI_FILE_HANDLE FileHandle\r
+  );\r
+\r
+/**\r
+  Frees the file list.\r
+  \r
+  This function cleans up the file list and any related data structures. It has no\r
+  impact on the files themselves.\r
+\r
+  @param FileList               The file list to free. Type EFI_SHELL_FILE_INFO is \r
+                                defined in OpenFileList()\r
+\r
+  @retval EFI_SUCCESS           Free the file list successfully.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_FREE_FILE_LIST) (\r
+  IN EFI_SHELL_FILE_INFO **FileList\r
+  );\r
+\r
+/**\r
+  Returns the current directory on the specified device.\r
+\r
+  If FileSystemMapping is NULL, it returns the current working directory. If the\r
+  FileSystemMapping is not NULL, it returns the current directory associated with the\r
+  FileSystemMapping. In both cases, the returned name includes the file system\r
+  mapping (i.e. fs0:\current-dir).\r
+\r
+  @param FileSystemMapping      A pointer to the file system mapping. If NULL, \r
+                                then the current working directory is returned.\r
+  \r
+  @retval !=NULL                The current directory.\r
+  @retval NULL                  Current directory does not exist.\r
+**/\r
+typedef\r
+CONST CHAR16 *\r
+(EFIAPI *EFI_SHELL_GET_CUR_DIR) (\r
+  IN CONST CHAR16 *FileSystemMapping OPTIONAL\r
+  );\r
+\r
+typedef UINT32 EFI_SHELL_DEVICE_NAME_FLAGS;\r
+#define EFI_DEVICE_NAME_USE_COMPONENT_NAME  0x00000001\r
+#define EFI_DEVICE_NAME_USE_DEVICE_PATH     0x00000002\r
+/**\r
+  Gets the name of the device specified by the device handle.\r
+\r
+  This function gets the user-readable name of the device specified by the device\r
+  handle. If no user-readable name could be generated, then *BestDeviceName will be\r
+  NULL and EFI_NOT_FOUND will be returned.\r
+\r
+  @param DeviceHandle           The handle of the device.\r
+  @param Flags                  Determines the possible sources of component names. \r
+  @param Language               A pointer to the language specified for the device \r
+                                name, in the same format as described in the UEFI \r
+                                specification, Appendix M \r
+  @param BestDeviceName         On return, points to the callee-allocated null-\r
+                                terminated name of the device. If no device name \r
+                                could be found, points to NULL. The name must be \r
+                                freed by the caller...\r
+\r
+  @retval EFI_SUCCESS           Get the name successfully.\r
+  @retval EFI_NOT_FOUND         Fail to get the device name.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(*EFI_SHELL_GET_DEVICE_NAME) (\r
+  IN EFI_HANDLE DeviceHandle,\r
+  IN EFI_SHELL_DEVICE_NAME_FLAGS Flags,\r
+  IN CHAR8 *Language,\r
+  OUT CHAR16 **BestDeviceName\r
+  );\r
+\r
+/**\r
+  Gets the device path from the mapping.\r
+\r
+  This function gets the device path associated with a mapping.\r
+\r
+  @param Mapping                A pointer to the mapping\r
+\r
+  @retval !=NULL                Pointer to the device path that corresponds to the \r
+                                device mapping. The returned pointer does not need \r
+                                to be freed.\r
+  @retval NULL                  There is no device path associated with the \r
+                                specified mapping.\r
+**/\r
+typedef\r
+CONST EFI_DEVICE_PATH_PROTOCOL *\r
+(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_MAP) (\r
+  IN CONST CHAR16 *Mapping\r
+  );\r
+\r
+/**\r
+  Converts a file system style name to a device path.\r
+\r
+  This function converts a file system style name to a device path, by replacing any\r
+  mapping references to the associated device path.\r
+\r
+  @param Path                   the pointer to the path\r
+\r
+  @return all                   The pointer of the file path. The file path is callee \r
+                                allocated and should be freed by the caller.\r
+**/\r
+typedef\r
+EFI_DEVICE_PATH_PROTOCOL *\r
+(EFIAPI *EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH) (\r
+  IN CONST CHAR16 *Path\r
+  );\r
+\r
+/**\r
+  Gets the environment variable.\r
+\r
+  This function returns the current value of the specified environment variable.\r
+\r
+  @param Name                   A pointer to the environment variable name\r
+\r
+  @return !=NULL                The environment variable's value. The returned \r
+                                pointer does not need to be freed by the caller.\r
+  @retval NULL                  The environment variable doesn't exist.\r
+**/\r
+typedef\r
+CONST CHAR16 *\r
+(EFIAPI *EFI_SHELL_GET_ENV) (\r
+  IN CONST CHAR16 *Name\r
+  );\r
+\r
+/**\r
+  Gets the file information from an open file handle.\r
+\r
+  This function allocates a buffer to store the file's information. It's the caller's\r
+  responsibility to free the buffer.\r
+\r
+  @param FileHandle             A File Handle\r
+\r
+  @return !=NULL                Cannot get the file info.\r
+  @return NULL                  A pointer to a buffer with file information.\r
+**/\r
+typedef\r
+EFI_FILE_INFO *\r
+(EFIAPI *EFI_SHELL_GET_FILE_INFO)(\r
+  IN EFI_FILE_HANDLE FileHandle\r
+  );\r
+\r
+/**\r
+  Converts a device path to a file system-style path.\r
+\r
+  This function converts a device path to a file system path by replacing part, or all, of\r
+  the device path with the file-system mapping. If there are more than one application\r
+  file system mappings, the one that most closely matches Path will be used.\r
+\r
+  @param Path                   The pointer to the device path\r
+\r
+  @return all                   The pointer of the null-terminated file path. The path \r
+                                is callee-allocated and should be freed by the caller.\r
+**/\r
+typedef\r
+CHAR16 *\r
+(EFIAPI *EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH) (\r
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *Path\r
+  );\r
+\r
+/**\r
+  Gets a file's current position\r
+\r
+  This function returns the current file position for the file handle. For directories, the\r
+  current file position has no meaning outside of the file system driver and as such, the\r
+  operation is not supported.\r
+\r
+  @param FileHandle             The file handle on which to get the current position.\r
+  @param Position               Byte position from the start of the file\r
+\r
+  @retval EFI_SUCCESS           Data was accessed.\r
+  @retval EFI_UNSUPPORTED       The request is not valid on open directories.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_GET_FILE_POSITION)(\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  OUT UINT64 *Position\r
+  );\r
+\r
+/**\r
+  Gets the size of a file.\r
+\r
+  This function returns the size of the file specified by FileHandle.\r
+\r
+  @param FileHandle             The handle of the file.\r
+  @param Size                   The size of this file.\r
+\r
+  @retval EFI_SUCCESS           Get the file's size.\r
+  @retval EFI_DEVICE_ERROR      Can't access the file.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_GET_FILE_SIZE)(\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  OUT UINT64 *Size\r
+  );\r
+\r
+/**\r
+  Return help information about a specific command.\r
+\r
+  This function returns the help information for the specified command. The help text\r
+  can be internal to the shell or can be from a UEFI Shell manual page.\r
+  \r
+  If Sections is specified, then each section name listed will be compared in a casesensitive\r
+  manner, to the section names described in Appendix B. If the section exists,\r
+  it will be appended to the returned help text. If the section does not exist, no\r
+  information will be returned. If Sections is NULL, then all help text information\r
+  available will be returned.\r
+\r
+  @param Command                Points to the null-terminated UEFI Shell command name.\r
+  @param Sections               Points to the null-terminated comma-delimited \r
+                                section names to return. If NULL, then all \r
+                                sections will be returned.\r
+  @param HelpText               On return, points to a callee-allocated buffer \r
+                                containing all specified help text.\r
+\r
+  @retval EFI_SUCCESS           The help text was returned.\r
+  @retval EFI_OUT_OF_RESOURCES  The necessary buffer could not be allocated to hold the \r
+                                returned help text.\r
+  @retval EFI_INVALID_PARAMETER HelpText is NULL\r
+  @retval EFI_NOT_FOUND         There is no help text available for Command.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_GET_HELP_TEXT) (\r
+  IN CONST CHAR16 *Command,\r
+  IN CONST CHAR16 *Sections,\r
+  OUT CHAR16 **HelpText\r
+  );\r
+\r
+/**\r
+  Gets the mapping that most closely matches the device path.\r
+\r
+  This function gets the mapping which corresponds to the device path *DevicePath. If\r
+  there is no exact match, then the mapping which most closely matches *DevicePath\r
+  is returned, and *DevicePath is updated to point to the remaining portion of the\r
+  device path. If there is an exact match, the mapping is returned and *DevicePath\r
+  points to the end-of-device-path node.\r
+\r
+  @param DevicePath             On entry, points to a device path pointer. On \r
+                                exit, updates the pointer to point to the \r
+                                portion of the device path after the mapping.\r
+\r
+  @retval NULL                  No mapping was found.\r
+  @return !=NULL                Pointer to null-terminated mapping. The buffer \r
+                                is callee allocated and should be freed by the caller.\r
+**/\r
+typedef\r
+CONST CHAR16 *\r
+(EFIAPI *EFI_SHELL_GET_MAP_FROM_DEVICE_PATH) (\r
+  IN OUT EFI_DEVICE_PATH_PROTOCOL **DevicePath\r
+  );\r
+\r
+/**\r
+  Gets the enable status of the page break output mode.\r
+\r
+  User can use this function to determine current page break mode.\r
+\r
+  @retval TRUE                  The page break output mode is enabled\r
+  @retval FALSE                 The page break output mode is disabled\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *EFI_SHELL_GET_PAGE_BREAK) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  Judges whether the active shell is the root shell.\r
+\r
+  This function makes the user to know that whether the active Shell is the root shell.\r
+\r
+  @retval TRUE                  The active Shell is the root Shell.\r
+  @retval FALSE                 The active Shell is NOT the root Shell.\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *EFI_SHELL_IS_ROOT_SHELL) (\r
+VOID\r
+);\r
+\r
+/**\r
+  Opens a file or a directory by file name.\r
+\r
+  This function opens the specified file in the specified OpenMode and returns a file\r
+  handle.\r
+  If the file name begins with >v, then the file handle which is returned refers to the\r
+  shell environment variable with the specified name. If the shell environment variable\r
+  exists, is non-volatile and the OpenMode indicates EFI_FILE_MODE_WRITE, then\r
+  EFI_INVALID_PARAMETER is returned.\r
+\r
+  If the file name is >i, then the file handle which is returned refers to the standard\r
+  input. If the OpenMode indicates EFI_FILE_MODE_WRITE, then EFI_INVALID_PARAMETER\r
+  is returned.\r
+\r
+  If the file name is >o, then the file handle which is returned refers to the standard\r
+  output. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER\r
+  is returned.\r
+\r
+  If the file name is >e, then the file handle which is returned refers to the standard\r
+  error. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER\r
+  is returned.\r
+\r
+  If the file name is NUL, then the file handle that is returned refers to the standard NUL\r
+  file. If the OpenMode indicates EFI_FILE_MODE_READ, then EFI_INVALID_PARAMETER is\r
+  returned.\r
+\r
+  If return EFI_SUCCESS, the FileHandle is the opened file's handle, else, the\r
+  FileHandle is NULL.\r
+\r
+  @param FileName               Points to the null-terminated UCS-2 encoded file name.\r
+  @param FileHandle             On return, points to the file handle.\r
+  @param OpenMode               File open mode. Either EFI_FILE_MODE_READ or \r
+                                EFI_FILE_MODE_WRITE from section 12.4 of the UEFI \r
+                                Specification.\r
+  @retval EFI_SUCCESS           The file was opened. FileHandle has the opened file's handle.\r
+  @retval EFI_INVALID_PARAMETER One of the parameters has an invalid value. FileHandle is NULL.\r
+  @retval EFI_UNSUPPORTED       Could not open the file path. FileHandle is NULL.\r
+  @retval EFI_NOT_FOUND         The specified file could not be found on the device or the file\r
+                                system could not be found on the device. FileHandle is NULL.\r
+  @retval EFI_NO_MEDIA          The device has no medium. FileHandle is NULL.\r
+  @retval EFI_MEDIA_CHANGED     The device has a different medium in it or the medium is no\r
+                                longer supported. FileHandle is NULL.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error or can't get the file path according\r
+                                the FileName. FileHandle is NULL.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted. FileHandle is NULL.\r
+  @retval EFI_WRITE_PROTECTED   An attempt was made to create a file, or open a file for write\r
+                                when the media is write-protected. FileHandle is NULL.\r
+  @retval EFI_ACCESS_DENIED     The service denied access to the file. FileHandle is NULL.\r
+  @retval EFI_OUT_OF_RESOURCES  Not enough resources were available to open the file. FileHandle\r
+                                is NULL.\r
+  @retval EFI_VOLUME_FULL       The volume is full. FileHandle is NULL.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_OPEN_FILE_BY_NAME) (\r
+  IN CONST CHAR16 *FileName,\r
+  OUT EFI_FILE_HANDLE *FileHandle,\r
+  IN UINT64 OpenMode\r
+  );\r
+\r
+/**\r
+  Opens the files that match the path specified.\r
+\r
+  This function opens all of the files specified by Path. Wildcards are processed\r
+  according to the rules specified in UEFI Shell 2.0 spec section 3.7.1. Each \r
+  matching file has an EFI_SHELL_FILE_INFO structure created in a linked list.\r
+\r
+  @param Path                   A pointer to the path string.\r
+  @param OpenMode               Specifies the mode used to open each file, EFI_FILE_MODE_READ or\r
+                                EFI_FILE_MODE_WRITE.\r
+  @param FileList               Points to the start of a list of files opened.\r
+\r
+  @retval EFI_SUCCESS           Create the file list successfully.\r
+  @return Others                Can't create the file list.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_OPEN_FILE_LIST) (\r
+  IN CHAR16 *Path,\r
+  IN UINT64 OpenMode,\r
+  IN OUT EFI_SHELL_FILE_INFO **FileList\r
+  );\r
+\r
+/**\r
+  Opens the root directory of a device.\r
+\r
+  This function opens the root directory of a device and returns a file handle to it.\r
+\r
+  @param DevicePath             Points to the device path corresponding to the device where the\r
+                                EFI_SIMPLE_FILE_SYSTEM_PROTOCOL is installed.\r
+  @param FileHandle             On exit, points to the file handle corresponding to the root directory on the\r
+                                device.\r
+\r
+  @retval EFI_SUCCESS           Root opened successfully.\r
+  @retval EFI_NOT_FOUND         EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory\r
+                                could not be opened.\r
+  @retval EFI_VOLUME_CORRUPTED  The data structures in the volume were corrupted.\r
+  @retval EFI_DEVICE_ERROR      The device had an error\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_OPEN_ROOT)(\r
+  IN EFI_DEVICE_PATH_PROTOCOL *DevicePath,\r
+  OUT EFI_FILE_HANDLE *FileHandle\r
+  );\r
+\r
+/**\r
+  Opens the root directory of a device on a handle\r
+\r
+  This function opens the root directory of a device and returns a file handle to it.\r
+\r
+  @param DeviceHandle           The handle of the device that contains the volume.\r
+  @param FileHandle             On exit, points to the file handle corresponding to the root directory on the\r
+                                device.\r
+\r
+  @retval EFI_SUCCESS           Root opened successfully.\r
+  @retval EFI_NOT_FOUND         EFI_SIMPLE_FILE_SYSTEM could not be found or the root directory\r
+                                could not be opened.\r
+  @retval EFI_VOLUME_CORRUPTED  The data structures in the volume were corrupted.\r
+  @retval EFI_DEVICE_ERROR      The device had an error\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_OPEN_ROOT_BY_HANDLE)(\r
+  IN EFI_HANDLE DeviceHandle,\r
+  OUT EFI_FILE_HANDLE *FileHandle\r
+  );\r
+\r
+/**\r
+  Reads data from the file.\r
+\r
+  If FileHandle is not a directory, the function reads the requested number of bytes\r
+  from the file at the file's current position and returns them in Buffer. If the read goes\r
+  beyond the end of the file, the read length is truncated to the end of the file. The file's\r
+  current position is increased by the number of bytes returned.\r
+  If FileHandle is a directory, then an error is returned.\r
+\r
+  @param FileHandle             The opened file handle for read\r
+  @param ReadSize               On input, the size of Buffer, in bytes. On output, the amount of data read.\r
+  @param Buffer                 The buffer in which data is read.\r
+\r
+  @retval EFI_SUCCESS           Data was read.\r
+  @retval EFI_NO_MEDIA          The device has no media\r
+  @retval EFI_DEVICE_ERROR      The device reported an error\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted\r
+  @retval EFI_BUFFER_TO_SMALL   Buffer is too small. ReadSize contains required size\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_READ_FILE) (\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  IN OUT UINTN *ReadSize,\r
+  OUT VOID *Buffer\r
+  );\r
+\r
+/**\r
+  Deletes the duplicate file names files in the given file list.\r
+\r
+  This function deletes the reduplicate files in the given file list.\r
+\r
+  @param FileList               A pointer to the first entry in the file list.\r
+\r
+  @retval EFI_SUCCESS           Always success.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_REMOVE_DUP_IN_FILE_LIST) (\r
+  IN EFI_SHELL_FILE_INFO **FileList\r
+  );\r
+\r
+/**\r
+  Changes a shell command alias.\r
+\r
+  This function creates an alias for a shell command.\r
+\r
+  @param Command                Points to the null-terminated shell command or existing alias.\r
+  @param Alias                  Points to the null-terminated alias for the shell command. If this is NULL, and\r
+                                Command refers to an alias, that alias will be deleted.\r
+  @param Replace                If TRUE and the alias already exists, then the existing alias will be replaced. If\r
+                                FALSE and the alias already exists, then the existing alias is unchanged and\r
+                                EFI_ACCESS_DENIED is returned.\r
+\r
+  @retval EFI_SUCCESS           Alias created or deleted successfully.\r
+  @retval EFI_ACCESS_DENIED     The alias is a built-in alias or already existed and Replace was set to\r
+                                FALSE.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_ALIAS)(\r
+  IN CONST CHAR16 *Command,\r
+  IN CONST CHAR16 *Alias,\r
+  IN BOOLEAN Replace\r
+  );\r
+\r
+/**\r
+  Changes the current directory on the specified device.\r
+\r
+  If the FileSystem is NULL, and the directory Dir does not contain a file system's\r
+  mapped name, this function changes the current working directory. If FileSystem is\r
+  NULL and the directory Dir contains a mapped name, then the current file system and\r
+  the current directory on that file system are changed.\r
+\r
+  If FileSystem is not NULL, and Dir is NULL, then this changes the current working file\r
+  system.\r
+\r
+  If FileSystem is not NULL and Dir is not NULL, then this function changes the current\r
+  directory on the specified file system.\r
+\r
+  If the current working directory or the current working file system is changed then the\r
+  %cwd% environment variable will be updated\r
+\r
+  @param FileSystem             A pointer to the file system's mapped name. If NULL, then the current working\r
+                                directory is changed.\r
+  @param Dir                    Points to the null-terminated directory on the device specified by FileSystem.\r
+\r
+  @return !=NULL                The current directory.\r
+  @retval NULL                  Current directory does not exist.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_CUR_DIR) (\r
+  IN CONST CHAR16 *FileSystem OPTIONAL,\r
+  IN CONST CHAR16 *Dir\r
+  );\r
+\r
+/**\r
+  Sets the environment variable.\r
+\r
+  This function changes the current value of the specified environment variable. If the\r
+  environment variable exists and the Value is an empty string, then the environment\r
+  variable is deleted. If the environment variable exists and the Value is not an empty\r
+  string, then the value of the environment variable is changed. If the environment\r
+  variable does not exist and the Value is an empty string, there is no action. If the\r
+  environment variable does not exist and the Value is a non-empty string, then the\r
+  environment variable is created and assigned the specified value.\r
+  \r
+  For a description of volatile and non-volatile environment variables, see UEFI Shell \r
+  2.0 specification section 3.6.1.\r
+\r
+  @param Name                   Points to the null-terminated environment variable name.\r
+  @param Value                  Points to the null-terminated environment variable value. If the value is an\r
+                                empty string then the environment variable is deleted.\r
+  @param Volatile               Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).\r
+\r
+  @retval EFI_SUCCESS           The environment variable was successfully updated.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_ENV) (\r
+  IN CONST CHAR16 *Name,\r
+  IN CONST CHAR16 *Value,\r
+  IN BOOLEAN Volatile\r
+  );\r
+\r
+/**\r
+  Sets the file information to an opened file handle.\r
+\r
+  This function changes file information.\r
+\r
+  @param FileHandle             A file handle\r
+  @param FileInfo               Points to new file information.\r
+\r
+  @retval EFI_SUCCESS           The information was set.\r
+  @retval EFI_NO_MEDIA          The device has no medium.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED   The file or medium is write-protected.\r
+  @retval EFI_ACCESS_DENIED     The file was opened read-only.\r
+  @retval EFI_VOLUME_FULL       The volume is full.\r
+  @retval EFI_BAD_BUFFER_SIZE   BufferSize is smaller than the size of EFI_FILE_INFO.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_FILE_INFO)(\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  IN CONST EFI_FILE_INFO *FileInfo\r
+  );\r
+\r
+/**\r
+  Sets a file's current position\r
+\r
+  This function sets the current file position for the handle to the position supplied. With\r
+  the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only absolute positioning is\r
+  supported, and seeking past the end of the file is allowed (a subsequent write would\r
+  grow the file). Seeking to position 0xFFFFFFFFFFFFFFFF causes the current position\r
+  to be set to the end of the file.\r
+\r
+  @param FileHandle             The file handle on which requested position will be set.\r
+  @param Position               Byte position from the start of the file\r
+\r
+  @retval EFI_SUCCESS           Data was written.\r
+  @retval EFI_UNSUPPORTED       The seek request for nonzero is not valid on open directories.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_FILE_POSITION)(\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  IN UINT64 Position\r
+  );\r
+\r
+/**\r
+  This function creates a mapping for a device path.\r
+\r
+  @param DevicePath             Points to the device path. If this is NULL and Mapping points to a valid mapping,\r
+                                then the mapping will be deleted.\r
+  @param Mapping                Points to the null-terminated mapping for the device path.\r
+\r
+  @retval EFI_SUCCESS           Mapping created or deleted successfully.\r
+  @retval EFI_NO_MAPPING        There is no handle that corresponds exactly to DevicePath. See the\r
+                                boot service function LocateDevicePath().\r
+  @retval EFI_ACCESS_DENIED     The mapping is a built-in alias.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_SET_MAP)(\r
+  IN CONST EFI_DEVICE_PATH_PROTOCOL *DevicePath,\r
+  IN CONST CHAR16 *Mapping\r
+  );\r
+\r
+/**\r
+  Writes data to the file.\r
+\r
+  This function writes the specified number of bytes to the file at the current file position.\r
+  The current file position is advanced the actual number of bytes written, which is\r
+  returned in BufferSize. Partial writes only occur when there has been a data error\r
+  during the write attempt (such as "volume space full"). The file automatically grows to\r
+  hold the data, if required.\r
+\r
+  Direct writes to opened directories are not supported.\r
+\r
+  @param FileHandle             The opened file handle for writing.\r
+  @param BufferSize             On input, size of Buffer.\r
+  @param Buffer                 The buffer in which data to write.\r
+\r
+  @retval EFI_SUCCESS Data was written.\r
+  @retval EFI_UNSUPPORTED Writes to open directory are not supported\r
+  @retval EFI_NO_MEDIA The device has no media\r
+  @retval EFI_DEVICE_ERROR The device reported an error\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted\r
+  @retval EFI_WRITE_PROTECTED The device is write-protected\r
+  @retval EFI_ACCESS_DENIED The file was open for read only\r
+  @retval EFI_VOLUME_FULL The volume is full\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *EFI_SHELL_WRITE_FILE)(\r
+  IN EFI_FILE_HANDLE FileHandle,\r
+  IN OUT UINTN *BufferSize,\r
+  OUT VOID *Buffer\r
+  );\r
+\r
+typedef struct _EFI_SHELL_PROTOCOL {\r
+  EFI_SHELL_EXECUTE                         Execute;\r
+  EFI_SHELL_GET_ENV                         GetEnv;\r
+  EFI_SHELL_SET_ENV                         SetEnv;\r
+  EFI_SHELL_SET_ALIAS                       SetAlias;\r
+  EFI_SHELL_GET_HELP_TEXT                   GetHelpText;\r
+  EFI_SHELL_GET_DEVICE_PATH_FROM_MAP        GetDevicePathFromMap;\r
+  EFI_SHELL_GET_MAP_FROM_DEVICE_PATH        GetMapFromDevicePath;\r
+  EFI_SHELL_GET_DEVICE_PATH_FROM_FILE_PATH  GetDevicePathFromFilePath;\r
+  EFI_SHELL_GET_FILE_PATH_FROM_DEVICE_PATH  GetFilePathFromDevicePath;\r
+  EFI_SHELL_SET_MAP                         SetMap;\r
+  EFI_SHELL_GET_CUR_DIR                     GetCurDir;\r
+  EFI_SHELL_SET_CUR_DIR                     SetCurDir;\r
+  EFI_SHELL_OPEN_FILE_LIST                  OpenFileList;\r
+  EFI_SHELL_FREE_FILE_LIST                  FreeFileList;\r
+  EFI_SHELL_REMOVE_DUP_IN_FILE_LIST         RemoveDupInFileList;\r
+  EFI_SHELL_BATCH_IS_ACTIVE                 BatchIsActive;\r
+  EFI_SHELL_IS_ROOT_SHELL                   IsRootShell;\r
+  EFI_SHELL_ENABLE_PAGE_BREAK               EnablePageBreak;\r
+  EFI_SHELL_DISABLE_PAGE_BREAK              DisablePageBreak;\r
+  EFI_SHELL_GET_PAGE_BREAK                  GetPageBreak;\r
+  EFI_SHELL_GET_DEVICE_NAME                 GetDeviceName;\r
+  EFI_SHELL_GET_FILE_INFO                   GetFileInfo;\r
+  EFI_SHELL_SET_FILE_INFO                   SetFileInfo;\r
+  EFI_SHELL_OPEN_FILE_BY_NAME               OpenFileByName;\r
+  EFI_SHELL_CLOSE_FILE                      CloseFile;\r
+  EFI_SHELL_CREATE_FILE                     CreateFile;\r
+  EFI_SHELL_READ_FILE                       ReadFile;\r
+  EFI_SHELL_WRITE_FILE                      WriteFile;\r
+  EFI_SHELL_DELETE_FILE                     DeleteFile;\r
+  EFI_SHELL_DELETE_FILE_BY_NAME             DeleteFileByName;\r
+  EFI_SHELL_GET_FILE_POSITION               GetFilePosition;\r
+  EFI_SHELL_SET_FILE_POSITION               SetFilePosition;\r
+  EFI_SHELL_FLUSH_FILE                      FlushFile;\r
+  EFI_SHELL_FIND_FILES                      FindFiles;\r
+  EFI_SHELL_FIND_FILES_IN_DIR               FindFilesInDir;\r
+  EFI_SHELL_GET_FILE_SIZE                   GetFileSize;\r
+  EFI_SHELL_OPEN_ROOT                       OpenRoot;\r
+  EFI_SHELL_OPEN_ROOT_BY_HANDLE             OpenRootByHandle;\r
+  EFI_EVENT                                 ExecutionBreak;\r
+  UINT32                                    MajorVersion;\r
+  UINT32                                    MinorVersion;\r
+} EFI_SHELL_PROTOCOL;\r
+\r
+extern EFI_GUID gEfiShellProtocolGuid;\r
+\r
+#endif\r
diff --git a/ShellPkg/Include/Protocol/EfiShellEnvironment2.h b/ShellPkg/Include/Protocol/EfiShellEnvironment2.h
new file mode 100644 (file)
index 0000000..537b916
--- /dev/null
@@ -0,0 +1,976 @@
+/** @file\r
+  Defines for EFI shell environment 2 ported to EDK II build environment.\r
+\r
+Copyright (c) 2005, 2009 Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+  \r
+#ifndef _SHELLENV2_H_\r
+#define _SHELLENV2_H_\r
+\r
+#include <Protocol\SimpleTextIn.h>\r
+#include <Protocol\SimpleTextOut.h>\r
+#include <Protocol\EfiShellInterface.h>\r
+\r
+#define DEFAULT_INIT_ROW    1\r
+#define DEFAULT_AUTO_LF     FALSE\r
+\r
+\r
+/**\r
+  this function is a prototype for a function that dumps information on a protocol \r
+  to a given location.  the location is dependant on the implementation.  This is \r
+  used when programatically adding shell commands.\r
+\r
+  @param Handle                 the handle the protocol is on\r
+  @param Interface              the interface to the protocol\r
+\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_DUMP_PROTOCOL_INFO) (\r
+  IN EFI_HANDLE                   Handle,\r
+  IN VOID                         *Interface\r
+  );\r
+\r
+/**\r
+  this function is a prototype foe each command internal to the EFI shell \r
+  implementation.  the specific command depends on the implementation.  This is \r
+  used when programatically adding shell commands.\r
+\r
+  @param ImageHandle            The handle to the binary shell\r
+  @param SystemTable            pointer to the system table.\r
+\r
+  @retval EFI_SUCCESS           the command ran to completion\r
+  @return other                 an error ocurred.  any error is possible \r
+                                depending on the implementation of the shell \r
+                                command.\r
+\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_INTERNAL_COMMAND) (\r
+  IN EFI_HANDLE                   ImageHandle,\r
+  IN EFI_SYSTEM_TABLE             *SystemTable\r
+  );\r
+\r
+/**\r
+  This function is a prototype for one that gets a help string for a given command. \r
+  This is used when programatically adding shell commands.  Upon successful return \r
+  the memory allocated is up to the caller to free.\r
+\r
+  @param Str                      pointer to pointer to string to display for help.\r
+\r
+  @retval EFI_SUCCESS             the help string is in the parameter Str.\r
+\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLCMD_GET_LINE_HELP) (\r
+  IN OUT CHAR16                 **Str\r
+  );\r
+\r
+/**\r
+* Structure returned from functions that open multiple files\r
+**/\r
+typedef struct {\r
+  UINT32                    Signature;            ///< SHELL_FILE_ARG_SIGNATURE\r
+  EFI_LIST_ENTRY            Link;                 ///< linked list helper\r
+  EFI_STATUS                Status;               ///< File's status\r
+\r
+  EFI_FILE_HANDLE           Parent;               ///< what is the Parent file of this file\r
+  UINT64                    OpenMode;             ///< how was the file opened\r
+  CHAR16                    *ParentName;          ///< string representation of parent\r
+  EFI_DEVICE_PATH_PROTOCOL  *ParentDevicePath;    ///< DevicePath for Parent\r
+\r
+  CHAR16                    *FullName;            ///< path and file name for this file\r
+  CHAR16                    *FileName;            ///< file name for this file\r
+\r
+  EFI_FILE_HANDLE           Handle;               ///< handle to this file\r
+  EFI_FILE_INFO             *Info;                ///< pointer to file info for this file\r
+} SHELL_FILE_ARG;\r
+\r
+/// signature for SHELL_FILE_ARG\r
+#define SHELL_FILE_ARG_SIGNATURE  SIGNATURE_32 ('g', 'r', 'a', 'f') \r
+\r
+/**\r
+*  GUID for the shell environment2 and shell environment\r
+**/\r
+#define SHELL_ENVIRONMENT_PROTOCOL_GUID \\r
+  { \\r
+    0x47c7b221, 0xc42a, 0x11d2, 0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b \\r
+  }\r
+\r
+/**\r
+*  GUID for the shell environment2 extension (main GUID same as shell environment)\r
+**/\r
+#define EFI_SE_EXT_SIGNATURE_GUID \\r
+  { \\r
+    0xd2c18636, 0x40e5, 0x4eb5, {0xa3, 0x1b, 0x36, 0x69, 0x5f, 0xd4, 0x2c, 0x87} \\r
+  }\r
+\r
+#define EFI_SHELL_MAJOR_VER 0x00000001 ///< Major version of the EFI_SHELL_ENVIRONMENT2\r
+#define EFI_SHELL_MINOR_VER 0x00000000 ///< Minor version of the EFI_SHELL_ENVIRONMENT2\r
+\r
+/**\r
+  execute a command line\r
+\r
+  this function will run the CommandLine.  This includes loading any required images, \r
+  parsing any requires scripts, and it DebugOutput is TRUE printing errors \r
+  encountered directly to the screen.\r
+  \r
+  @param ParentImageHandle      Handle of image executing this operation\r
+  @param CommandLine            string command line to execute\r
+  @param DebugOutput            TRUE indicates that errors should be printed directly.\r
+                                FALSE supresses error messages.\r
+\r
+  @retval EFI_SUCCESS           the command line executed and completed.\r
+  @retval EFI_ABORTED           the operation did not complete due to abort.\r
+  @retval EFI_INVALID_PARAMETER A parameter did not have a valid value.\r
+  @retval EFI_OUT_OF_RESOURCES  A required memory allocation failed.\r
+\r
+@sa HandleProtocol\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_EXECUTE) (\r
+  IN EFI_HANDLE   *ParentImageHandle,\r
+  IN CHAR16       *CommandLine,\r
+  IN BOOLEAN      DebugOutput\r
+  );\r
+\r
+/**\r
+  this function returns a shell environment variable value.\r
+\r
+  @param Name                   pointer to the string with the shell environment \r
+                                variables name\r
+\r
+  @retval NULL                  the shell environment variable's value could not be found\r
+  @retval !NULL                 the value of the shell environment variable Name\r
+\r
+**/\r
+typedef \r
+CHAR16 * \r
+(EFIAPI *SHELLENV_GET_ENV) (\r
+  IN CHAR16 *Name\r
+  );\r
+\r
+/**\r
+  this function returns a shell environment map value.\r
+\r
+  @param Name                   pointer to the string with the shell environment \r
+                                map name\r
+\r
+  @retval NULL                  the shell environment map's value could not be found\r
+  @retval !NULL                 the value of the shell environment map Name\r
+\r
+**/\r
+typedef \r
+CHAR16 * \r
+(EFIAPI *SHELLENV_GET_MAP) (\r
+  IN CHAR16 *Name\r
+  );\r
+\r
+/**\r
+  This function will add an internal command to the shell interface.\r
+\r
+  This will allocate all required memory, put the new command on the command\r
+  list in the correct location.\r
+\r
+  @param Handler                the handler function to call when the command gets called\r
+  @param CmdStr                 The command name\r
+  @param GetLineHelp            function to call of get help for this command\r
+\r
+  @retval EFI_SUCCESS           the command is now part of the command list\r
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.\r
+  @sa SHELLENV_INTERNAL_COMMAND\r
+  @sa SHELLCMD_GET_LINE_HELP\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_ADD_CMD) (\r
+  IN SHELLENV_INTERNAL_COMMAND    Handler,\r
+  IN CHAR16                       *Cmd,\r
+  IN SHELLCMD_GET_LINE_HELP       GetLineHelp\r
+  );\r
+\r
+/**\r
+  Internal interface to add protocol handlers.\r
+\r
+  This function is for internal shell use only.  This is how protocol handlers are added.\r
+  This will get the current protocol info and add the new info or update existing info\r
+  and then resave the info.\r
+\r
+  @param SaveId                 save this change as an EFI variable\r
+  @param Protocol               the protocol's GUID\r
+  @param DumpToken              The function pointer to dump token function or \r
+                                NULL\r
+  @param DumpInfo               The function pointer to dump infomation function \r
+                                or NULL\r
+  @param IdString               The english name of the protocol\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_ADD_PROT) (\r
+  IN EFI_GUID                     *Protocol,\r
+  IN SHELLENV_DUMP_PROTOCOL_INFO  DumpToken OPTIONAL,\r
+  IN SHELLENV_DUMP_PROTOCOL_INFO  DumpInfo OPTIONAL,\r
+  IN CHAR16                       *IdString\r
+  );\r
+\r
+/**\r
+  this function finds a protocol handle by a GUID.  \r
+\r
+  This function will check for already known protocols by GUID and if one is \r
+  found it will return the name of that protocol.  if no name is found and \r
+  GenId is TRUE it will generate ths string.\r
+\r
+  @param Protocol               the GUID of the protocol to look for.\r
+  @param GenId                  whether to generate a name string if its not found.\r
+\r
+  @return !NULL                 the Name of the protocol.\r
+  @retval NULL                  the Name was not found and GenId was not TRUE.\r
+**/\r
+typedef \r
+CHAR16*\r
+(EFIAPI *SHELLENV_GET_PROT) (\r
+  IN EFI_GUID *Protocol, \r
+  IN BOOLEAN GenId\r
+  );\r
+\r
+/**\r
+  this function returns the current directory on a given device\r
+\r
+  If DeviceName is specified, then return the current shell directory on that \r
+  device.  If DeviceName is NULL, then return the current directory on the \r
+  current device.  The caller us responsible to free the returned string when\r
+  no londer required.\r
+\r
+  @param DeviceName             the name of the device to get the current \r
+                                directory on or NULL for current device\r
+\r
+  @return The current directory on the current or specified device.\r
+\r
+**/\r
+typedef \r
+CHAR16*\r
+(EFIAPI *SHELLENV_CUR_DIR) (\r
+  IN CHAR16 *DeviceName OPTIONAL\r
+  );\r
+\r
+/**\r
+  this function will open a group of files that match the Arg path, including \r
+  support for wildcard characters ('?' and '*') in the Arg path.  if there are \r
+  any wildcard characters in the path this function will find any and all files\r
+  that match the wildcards.  the return is a double linked list based on the \r
+  EFI_LIST_ENTRY linked list structure.  use this in conjunction with the \r
+  SHELL_FILE_ARG_SIGNATURE to get the SHELL_FILE_ARG structures that are returned.\r
+  The memory allocated by the callee for this list is freed by making a call to \r
+  SHELLENV_FREE_FILE_LIST.\r
+\r
+  @param Arg                    pointer Path to files to open\r
+  @param ListHead               pointer to allocated and initialized list head \r
+                                upon which to append all the opened file structures.\r
+\r
+  @retval EFI_SUCCESS           1 or more files was opened and a struct of each file's\r
+                                information was appended to ListHead.\r
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.\r
+  @retval EFI_NOT_FOUND         no matching files could be found.\r
+  @sa SHELLENV_FREE_FILE_LIST\r
+**/typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_FILE_META_ARG) (\r
+  IN CHAR16               *Arg,\r
+  IN OUT EFI_LIST_ENTRY   *ListHead\r
+  );\r
+\r
+/**\r
+  this frees all of the nodes under the ListHead, but not ListHead itself.\r
+\r
+  @param ListHead               Pointer to list to free all nodes of.\r
+\r
+  @retval EFI_SUCCESS           always returned.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_FREE_FILE_LIST) (\r
+  IN OUT EFI_LIST_ENTRY   *ListHead\r
+  );\r
+\r
+/**\r
+  this function creates a new instance of the ShellInterface protocol for use on \r
+  the ImageHandle.\r
+\r
+  This function is for internal shell usage.  this will allocate and then populate \r
+  EFI_SHELL_INTERFACE protocol.  it is the caller's responsibility to free the \r
+  memory.\r
+\r
+  @param ImageHandle            the handle which will use the new ShellInterface \r
+                                protocol.\r
+\r
+  @return the newly allocated shell interface protocol.\r
+\r
+**/\r
+typedef \r
+EFI_SHELL_INTERFACE* \r
+(EFIAPI *SHELLENV_NEW_SHELL) (\r
+  IN EFI_HANDLE ImageHandle\r
+  );\r
+\r
+/**\r
+  this function determins whether a script file is currently being processed.\r
+\r
+  a script file (.nsh file) can contain a series of commands and this is useful to \r
+  know for some shell commands whether they are being run manually or as part of a \r
+  script.\r
+\r
+  @retval TRUE                  A script file is being processed\r
+  @return FALSE                 A script file is not being processed\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *SHELLENV_BATCH_IS_ACTIVE) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  This is an internal shell function to free any and all allocated resources.  \r
+  This should be called just closing the shell.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_FREE_RESOURCES) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  This function enables the page break mode.\r
+\r
+  This mode causes the output to pause after each complete screen to enable a \r
+  user to more easily read it.  if AutoWrap is TRUE then rows with too many \r
+  characters will be chopped and divided into 2 rows.  if FALSE then rows with \r
+  too many characters may not be fully visible to the user on the screen.\r
+\r
+  @param StartRow               the row number to start this on.\r
+  @param AutoWrap               whether to auto wrap rows that are \r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_ENABLE_PAGE_BREAK) (\r
+  IN INT32      StartRow,\r
+  IN BOOLEAN    AutoWrap\r
+  );\r
+\r
+/**\r
+  This function disables the page break mode.\r
+\r
+  disabling this causes the output to print out exactly as coded with no breaks \r
+  for readability.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_DISABLE_PAGE_BREAK) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  Get the status of the page break output mode.\r
+\r
+  @retval FALSE                 page break output mode is not enabled\r
+  @retval TRUE                  page break output mode is enabled\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *SHELLENV_GET_PAGE_BREAK) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  this function sets the keys to filter for for the console in.  the valid \r
+  values to set are:\r
+\r
+  #define EFI_OUTPUT_SCROLL   0x00000001\r
+  #define EFI_OUTPUT_PAUSE    0x00000002\r
+  #define EFI_EXECUTION_BREAK 0x00000004\r
+\r
+  @param KeyFilter              The new key filter to use.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_SET_KEY_FILTER) (\r
+  IN UINT32      KeyFilter\r
+  );\r
+\r
+/**\r
+  this function gets the keys to filter for for the console in.  the valid \r
+  values to get are:\r
+\r
+  #define EFI_OUTPUT_SCROLL   0x00000001\r
+  #define EFI_OUTPUT_PAUSE    0x00000002\r
+  #define EFI_EXECUTION_BREAK 0x00000004\r
+\r
+  @retval the current filter mask.\r
+**/\r
+typedef\r
+UINT32\r
+(EFIAPI *SHELLENV_GET_KEY_FILTER) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  this function determins if the shell application should break.\r
+\r
+  This is used to inform a shell application that a break condition has been \r
+  initiated.  long loops should check this to prevent delays to the break.\r
+\r
+  @retval TRUE                  a break has been signaled.  the application   \r
+                                should exit with EFI_ABORTED as soon as possible.\r
+  @retval FALSE                 continue as normal.\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *SHELLENV_GET_EXECUTION_BREAK) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  This is an internal-shell function used to increment the shell nesting level.\r
+\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_INCREMENT_SHELL_NESTING_LEVEL) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  This is an internal-shell function used to decrement the shell nesting level.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_DECREMENT_SHELL_NESTING_LEVEL) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  this function determins if the caller is running under the root shell.\r
+\r
+  @retval TRUE                  The caller is running under the root shell\r
+  @retval FALSE                 The caller is not running under the root shell\r
+\r
+**/\r
+typedef\r
+BOOLEAN\r
+(EFIAPI *SHELLENV_IS_ROOT_SHELL) (\r
+  IN VOID\r
+  );\r
+\r
+/**\r
+  Close the console proxy to restore the original console.\r
+\r
+  This is an internal shell function to handle shell cascading.  it restores the \r
+  original set of console protocols.\r
+  \r
+  @param ConInHandle            The handle of ConIn.\r
+  @param ConIn                  pointer to the location to return the pointer to \r
+                                the original console input.\r
+  @param ConOutHandle           The handle of ConOut\r
+  @param ConOut                 pointer to the location to return the pointer to \r
+                                the original console output.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *SHELLENV_CLOSE_CONSOLE_PROXY) (\r
+  IN     EFI_HANDLE                       ConInHandle,\r
+  IN OUT EFI_SIMPLE_TEXT_INPUT_PROTOCOL   **ConIn,\r
+  IN     EFI_HANDLE                       ConOutHandle,\r
+  IN OUT EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  **ConOut\r
+  );\r
+\r
+//\r
+// declarations of handle enumerator\r
+//\r
+/**\r
+  For ease of use the shell maps handle #'s to short numbers.\r
+  This is only done on request for various internal commands and the references \r
+  are immediately freed when the internal command completes.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *INIT_HANDLE_ENUMERATOR) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  this is an internal shell function to enumerate the handle database.\r
+\r
+  this function gets the next handle in the handle database.  if no handles are \r
+  found EFI_NOT_FOUND is returned.  if the previous Handle was the last handle \r
+  it is set to NULL before returning.\r
+\r
+  this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.\r
+\r
+  @param Handle                 pointer to pointer to Handle.  will be set\r
+                                on a sucessful return.\r
+\r
+  @retval EFI_SUCCESS           the next handle in the handle database is *Handle\r
+  @retval EFI_NOT_FOUND         there is not another handle.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *NEXT_HANDLE) (\r
+  IN OUT EFI_HANDLE             **Handle\r
+  );\r
+\r
+/**\r
+  this is an internal shell function to enumerate the handle database.\r
+\r
+  this function skips the next SkipNum handles in the handle database.  If there \r
+  are not enough handles left to skip that many EFI_ACCESS_DENIED is returned and \r
+  no skip is performed.\r
+\r
+  this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.\r
+\r
+  @param SkipNum                how many handles to skip\r
+\r
+  @retval EFI_SUCCESS           the next handle in the handle database is *Handle\r
+  @retval EFI_ACCESS_DENIED     there are not SkipNum handles left in the database\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SKIP_HANDLE) (\r
+  IN UINTN                   SkipNum\r
+  );\r
+\r
+/**\r
+  this is an internal shell function to enumerate the handle database.\r
+\r
+  this function resets the the handle database so that NEXT_HANDLE and SKIP_HANDLE \r
+  will start from EnumIndex on the next call. \r
+  \r
+  this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.\r
+\r
+  @param EnumIndex              where to start.\r
+\r
+  @retval the number of handles either read out or skipped before this reset.\r
+**/\r
+typedef\r
+UINTN\r
+(EFIAPI *RESET_HANDLE_ENUMERATOR) (\r
+  IN UINTN                  EnumIndex\r
+  );\r
+\r
+/**\r
+  this is an internal shell function to enumerate the handle database.\r
+  \r
+  this must be called after INIT_HANDLE_ENUMERATOR.\r
+\r
+  this function releases all memory and resources associated with the handle database.\r
+  after this no other handle enumerator functions except INIT_HANDLE_ENUMERATOR will \r
+  function properly.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *CLOSE_HANDLE_ENUMERATOR) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  this is an internal shell function to enumerate the handle database.\r
+\r
+  this function returns the number of handles in the handle database.\r
+  \r
+  this must be called after INIT_HANDLE_ENUMERATOR and before CLOSE_HANDLE_ENUMERATOR.\r
+\r
+  @retval the number of handles in the handle database.\r
+**/\r
+typedef\r
+UINTN\r
+(EFIAPI *GET_NUM) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+Handle Enumerator structure\r
+**/\r
+typedef struct {\r
+  INIT_HANDLE_ENUMERATOR  Init;   ///< pointer to INIT_HANDLE_ENUMERATOR function\r
+  NEXT_HANDLE             Next;   ///< pointer to NEXT_HANDLE function\r
+  SKIP_HANDLE             Skip;   ///< pointer to SKIP_HANDLE function\r
+  RESET_HANDLE_ENUMERATOR Reset;  ///< pointer to RESET_HANDLE_ENUMERATOR function\r
+  CLOSE_HANDLE_ENUMERATOR Close;  ///< pointer to CLOSE_HANDLE_ENUMERATOR function\r
+  GET_NUM                 GetNum; ///< pointer to GET_NUM function\r
+} HANDLE_ENUMERATOR;\r
+/**\r
+  signature for the PROTOCOL_INFO structure \r
+**/\r
+#define PROTOCOL_INFO_SIGNATURE SIGNATURE_32 ('s', 'p', 'i', 'n')\r
+/**\r
+  PROTOCOL_INFO structure for protocol enumerator functions.\r
+\r
+**/\r
+typedef struct {\r
+  UINTN                       Signature;   ///< PROTOCOL_INFO_SIGNATURE \r
+  EFI_LIST_ENTRY              Link;        ///< standard lined list helper member\r
+  //\r
+  // parsing info for the protocol\r
+  //\r
+  EFI_GUID                    ProtocolId;  ///< GUID for the protocol\r
+  CHAR16                      *IdString;   ///< Name of the protocol\r
+  SHELLENV_DUMP_PROTOCOL_INFO DumpToken;   ///< pointer to DumpToken function for the protocol\r
+  SHELLENV_DUMP_PROTOCOL_INFO DumpInfo;    ///< pointer to DumpInfo function for the protocol\r
+  //\r
+  // database info on which handles are supporting this protocol\r
+  //\r
+  UINTN                       NoHandles;   ///< how many handles produce this protocol\r
+  EFI_HANDLE                  *Handles;    ///< array of handles\r
+\r
+} PROTOCOL_INFO;\r
+\r
+//\r
+// declarations of protocol info enumerator\r
+//\r
+/**\r
+  this is an internal shell function to initialize the protocol enumerator.\r
+\r
+  this must be called before NEXT_PROTOCOL_INFO, SKIP_PROTOCOL_INFO, \r
+  RESET_PROTOCOL_INFO_ENUMERATOR, and CLOSE_PROTOCOL_INFO_ENUMERATOR are\r
+  called.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *INIT_PROTOCOL_INFO_ENUMERATOR) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+  this function is an internal shell function for enumeration of protocols.  \r
+\r
+  This functiol will return the next protocol in the list.  If this is called \r
+  immediately after initialization it will return the first.  If this is called\r
+  immediately after reset it will return the protocol first again.\r
+\r
+  This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be \r
+  called after INIT_PROTOCOL_INFO_ENUMERATOR.\r
+\r
+  @param ProtocolInfo           pointer to pointer to protocol information structure.\r
+\r
+  @retval EFI_SUCCESS           the next protocol's information was sucessfully returned.  \r
+                                If there were no more protocols NULL was returned.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *NEXT_PROTOCOL_INFO) (\r
+  IN OUT PROTOCOL_INFO            **ProtocolInfo\r
+  );\r
+\r
+/**\r
+  this function is an internal shell function for enumeration of protocols.  \r
+\r
+  This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be \r
+  called after INIT_PROTOCOL_INFO_ENUMERATOR.\r
+\r
+  this function does nothing and always returns EFI_SUCCESS.\r
+\r
+  @retval EFI_SUCCESS           always returned (see note).\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SKIP_PROTOCOL_INFO) (\r
+  IN UINTN                         SkipNum\r
+  );\r
+\r
+/**\r
+  this function is an internal shell function for enumeration of protocols.  \r
+\r
+  This cannot be called after CLOSE_PROTOCOL_INFO_ENUMERATOR, but it must be \r
+  called after INIT_PROTOCOL_INFO_ENUMERATOR.\r
+\r
+  this function resets the list of protocols such that the next one in the \r
+  list is the begining of the list.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *RESET_PROTOCOL_INFO_ENUMERATOR) (\r
+  VOID\r
+  );\r
+\r
+\r
+/**\r
+  this function is an internal shell function for enumeration of protocols.  \r
+\r
+  This must be called after INIT_PROTOCOL_INFO_ENUMERATOR.  After this call\r
+  no protocol enumerator calls except INIT_PROTOCOL_INFO_ENUMERATOR may be made.\r
+\r
+  this function frees any memory or resources associated with the protocol\r
+  enumerator.\r
+**/\r
+typedef\r
+VOID\r
+(EFIAPI *CLOSE_PROTOCOL_INFO_ENUMERATOR) (\r
+  VOID\r
+  );\r
+\r
+/**\r
+*  protocol enumerator structure of function pointers.\r
+**/\r
+typedef struct {\r
+  INIT_PROTOCOL_INFO_ENUMERATOR   Init;   ///< pointer to INIT_PROTOCOL_INFO_ENUMERATOR function\r
+  NEXT_PROTOCOL_INFO              Next;   ///< pointer to NEXT_PROTOCOL_INFO function\r
+  SKIP_PROTOCOL_INFO              Skip;   ///< pointer to SKIP_PROTOCOL_INFO function\r
+  RESET_PROTOCOL_INFO_ENUMERATOR  Reset;  ///< pointer to RESET_PROTOCOL_INFO_ENUMERATOR function\r
+  CLOSE_PROTOCOL_INFO_ENUMERATOR  Close;  ///< pointer to CLOSE_PROTOCOL_INFO_ENUMERATOR function\r
+} PROTOCOL_INFO_ENUMERATOR;\r
+\r
+/**\r
+  this function is used to retrieve a user-friendly display name for a handle.  \r
+\r
+  If UseComponentName is TRUE then the component name protocol for this device \r
+  or it's parent device (if required) will be used to obtain the name of the \r
+  device.  If UseDevicePath is TRUE it will get the human readable device path\r
+  and return that.  If both are TRUE it will try to use component name first\r
+  and device path if that fails. \r
+\r
+  It will use either ComponentName or ComponentName2 protocol, depending on \r
+  what is present.\r
+\r
+  This function will furthur verify whether the handle in question produced either\r
+  EFI_DRIVER_CONFIGRATION_PROTOCOL or EFI_DRIVER_CONFIGURATION2_PROTOCOL and also \r
+  whether the handle in question produced either EFI_DRIVER_DIAGNOSTICS_PROTOCOL or \r
+  EFI_DRIVER_DIAGNOSTICS2_PROTOCOL.\r
+  \r
+  Upon sucessful return the memory for *BestDeviceName is up to the caller to free.\r
+\r
+  @param DeviceHandle           the device handle whose name is desired\r
+  @param UseComponentName       whether to use the ComponentName protocol at all\r
+  @param UseDevicePath          whether to use the DevicePath protocol at all\r
+  @param Language               pointer to language string to use\r
+  @param BestDeviceName         pointer to pointer to string allocated with the name\r
+  @param ConfigurationStatus    pointer to status for opening a Configuration protocol\r
+  @param DiagnosticsStatus      pointer to status for opening a Diagnostics protocol\r
+  @param Display                Whether to Print this out to default Print location\r
+  @param Indent                 how many characters to indent the printing\r
+\r
+  @retval EFI_SUCCESS           this function always returns EFI_SUCCESS\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *GET_DEVICE_NAME) (\r
+  EFI_HANDLE  DeviceHandle,\r
+  BOOLEAN     UseComponentName,\r
+  BOOLEAN     UseDevicePath,\r
+  CHAR8       *Language,\r
+  CHAR16      **BestDeviceName,\r
+  EFI_STATUS  *ConfigurationStatus,\r
+  EFI_STATUS  *DiagnosticsStatus,\r
+  BOOLEAN     Display,\r
+  UINTN       Indent\r
+  );\r
+\r
+#define EFI_SHELL_COMPATIBLE_MODE_VER L"1.1.1" ///< string for lowest version this shell supports\r
+#define EFI_SHELL_ENHANCED_MODE_VER   L"1.1.2" ///< string for highest version this shell supports\r
+\r
+/**\r
+  this function gets the shell mode as stored in the shell environment \r
+  "efishellmode".  it will not fail.\r
+\r
+  @param Mode                   returns a string representing one of the \r
+                                2 supported modes of the shell.\r
+\r
+  @retval EFI_SUCCESS           this function always returns success\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *GET_SHELL_MODE) (\r
+  OUT CHAR16     **Mode\r
+  );\r
+\r
+/**\r
+  Convert a file system style name to an file path\r
+\r
+  This function will convert a shell path name to a Device Path Protocol path.\r
+  This function will allocate any required memory for this operation and it \r
+  is the responsibility of the caller to free that memory when no longer required.\r
+\r
+  if anything prevents the complete conversion free any allocated memory and \r
+  return NULL.\r
+\r
+  @retval !NULL                 a pointer to the callee allocated Device Path\r
+  @retval NULL                  the operation could not be completed.\r
+**/\r
+typedef \r
+EFI_DEVICE_PATH_PROTOCOL* \r
+(EFIAPI *SHELLENV_NAME_TO_PATH) (\r
+  IN CHAR16 *Path\r
+  );\r
+\r
+/**\r
+  converts a device path into a file system map name.\r
+\r
+  if DevPath is NULL then ASSERT\r
+  This function looks through the shell environment map for a map whose device\r
+  path matches the DevPath parameter.  If one is found the Name is returned via \r
+  Name parameter.  If sucessful the caller must free the memory allocated for\r
+  Name.\r
+\r
+  this function will use the internal lock to prevent changes to the map during \r
+  the lookup operation.\r
+  \r
+  @param DevPath                The device path to search for a name for\r
+  @param ConsistMapping         what state to verify map flag VAR_ID_CONSIST\r
+  @param Name                   on sucessful return the name of that device path\r
+\r
+  @retval EFI_SUCCESS           the DevPath was found and the name returned\r
+                                in Name.  \r
+  @retval EFI_OUT_OF_RESOURCES  A required memory allocation failed.\r
+  @retval EFI_UNSUPPORTED       the DevPath was not found in the map\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_GET_FS_NAME) (\r
+  IN EFI_DEVICE_PATH_PROTOCOL     * DevPath,\r
+  IN BOOLEAN                      ConsistMapping,\r
+  OUT CHAR16                      **Name\r
+  );\r
+\r
+/**\r
+  this function will open a group of files that match the Arg path, but will not \r
+  support the wildcard characters ('?' and '*') in the Arg path.  if there are \r
+  any wildcard characters in the path this function will return \r
+  EFI_INVALID_PARAMETER.  the return is a double linked list based on the \r
+  EFI_LIST_ENTRY linked list structure.  use this in conjunction with the \r
+  SHELL_FILE_ARG_SIGNATURE to get the SHELL_FILE_ARG structures that are returned.\r
+  The memory allocated by the callee for this list is freed by making a call to \r
+  SHELLENV_FREE_FILE_LIST.\r
+\r
+  @param Arg                    pointer Path to files to open\r
+  @param ListHead               pointer to allocated and initialized list head \r
+                                upon which to append all the opened file structures.\r
+\r
+  @retval EFI_SUCCESS           1 or more files was opened and a struct of each file's\r
+                                information was appended to ListHead.\r
+  @retval EFI_OUT_OF_RESOURCES  a memory allocation failed.\r
+  @retval EFI_NOT_FOUND         no matching files could be found.\r
+  @sa SHELLENV_FREE_FILE_LIST\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_FILE_META_ARG_NO_WILDCARD) (\r
+  IN CHAR16               *Arg,\r
+  IN OUT EFI_LIST_ENTRY   *ListHead\r
+  );\r
+\r
+/**\r
+  this function removes duplicate file listings from lists.\r
+\r
+  this is a function for use with SHELLENV_FILE_META_ARG_NO_WILDCARD and \r
+  SHELLENV_FILE_META_ARG.  this function will verify that there are no duplicate\r
+  files in the list of returned files.  any file listed twice will have one of its\r
+  instances removed.\r
+\r
+  @param ListHead               pointer to linked list head that was returned from \r
+                                SHELLENV_FILE_META_ARG_NO_WILDCARD or\r
+                                SHELLENV_FILE_META_ARG.\r
+\r
+  @retval EFI_SUCCESS           this function always returns success.\r
+\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_DEL_DUP_FILE) (\r
+  IN EFI_LIST_ENTRY   * ListHead\r
+  );\r
+\r
+/**\r
+  Converts a File System map name to a device path.\r
+\r
+  if DevPath is NULL then ASSERT()\r
+\r
+  This function looks through the shell environment map for a map whose Name \r
+  matches the Name parameter.  If one is found the device path pointer is \r
+  updated to point to that file systems device path.  the caller should not \r
+  free the memory from that device path.\r
+\r
+  this function will use the internal lock to prevent changes to the map during \r
+  the lookup operation.\r
+\r
+  @param Name                   pointer to NULL terminated UNICODE string of the \r
+                                file system name\r
+  @param DevPath                pointer to pointer to DevicePath.  only valid on \r
+                                OUT if sucessful\r
+\r
+  @retval EFI_SUCCESS           the conversion was successful and the device \r
+                                path was returned.\r
+  @retval EFI_NOT_FOUND         the file system could not be found in the map.\r
+**/\r
+typedef\r
+EFI_STATUS\r
+(EFIAPI *SHELLENV_GET_FS_DEVICE_PATH) (\r
+  IN CHAR16                        *Name,\r
+  OUT EFI_DEVICE_PATH_PROTOCOL     **DevPath\r
+  );\r
+\r
+/// EFI_SHELL_ENVIRONMENT2 protocol structure\r
+/// contains pointers to functions\r
+typedef struct {\r
+  SHELLENV_EXECUTE                        Execute;\r
+  SHELLENV_GET_ENV                        GetEnv;\r
+  SHELLENV_GET_MAP                        GetMap;\r
+  SHELLENV_ADD_CMD                        AddCmd;\r
+  SHELLENV_ADD_PROT                       AddProt;\r
+  SHELLENV_GET_PROT                       GetProt;\r
+  SHELLENV_CUR_DIR                        CurDir;\r
+  SHELLENV_FILE_META_ARG                  FileMetaArg;\r
+  SHELLENV_FREE_FILE_LIST                 FreeFileList;\r
+\r
+  //\r
+  // The following services are only used by the shell itself\r
+  //\r
+  SHELLENV_NEW_SHELL                      NewShell;\r
+  SHELLENV_BATCH_IS_ACTIVE                BatchIsActive;\r
+\r
+  SHELLENV_FREE_RESOURCES                 FreeResources;\r
+\r
+  //\r
+  // GUID to differentiate ShellEnvironment2 from ShellEnvironment\r
+  //\r
+  EFI_GUID                                SESGuid;\r
+  //\r
+  // Major Version grows if shell environment interface has been changes\r
+  //\r
+  UINT32                                  MajorVersion;\r
+  UINT32                                  MinorVersion;\r
+  SHELLENV_ENABLE_PAGE_BREAK              EnablePageBreak;\r
+  SHELLENV_DISABLE_PAGE_BREAK             DisablePageBreak;\r
+  SHELLENV_GET_PAGE_BREAK                 GetPageBreak;\r
+\r
+  SHELLENV_SET_KEY_FILTER                 SetKeyFilter;\r
+  SHELLENV_GET_KEY_FILTER                 GetKeyFilter;\r
+\r
+  SHELLENV_GET_EXECUTION_BREAK            GetExecutionBreak;\r
+  SHELLENV_INCREMENT_SHELL_NESTING_LEVEL  IncrementShellNestingLevel;\r
+  SHELLENV_DECREMENT_SHELL_NESTING_LEVEL  DecrementShellNestingLevel;\r
+  SHELLENV_IS_ROOT_SHELL                  IsRootShell;\r
+\r
+  SHELLENV_CLOSE_CONSOLE_PROXY            CloseConsoleProxy;\r
+  HANDLE_ENUMERATOR                       HandleEnumerator;\r
+  PROTOCOL_INFO_ENUMERATOR                ProtocolInfoEnumerator;\r
+  GET_DEVICE_NAME                         GetDeviceName;\r
+  GET_SHELL_MODE                          GetShellMode;\r
+  SHELLENV_NAME_TO_PATH                   NameToPath;\r
+  SHELLENV_GET_FS_NAME                    GetFsName;\r
+  SHELLENV_FILE_META_ARG_NO_WILDCARD      FileMetaArgNoWildCard;\r
+  SHELLENV_DEL_DUP_FILE                   DelDupFileArg;\r
+  SHELLENV_GET_FS_DEVICE_PATH             GetFsDevicePath;\r
+} EFI_SHELL_ENVIRONMENT2;\r
+\r
+extern EFI_GUID gEfiShellEnvironment2Guid;\r
+extern EFI_GUID gEfiShellEnvironment2ExtGuid;\r
+#endif // _SHELLENV_H_\r
diff --git a/ShellPkg/Include/Protocol/EfiShellInterface.h b/ShellPkg/Include/Protocol/EfiShellInterface.h
new file mode 100644 (file)
index 0000000..bc15b4b
--- /dev/null
@@ -0,0 +1,96 @@
+/** @file\r
+  EFI Shell Interface protocol from EDK shell (no spec).\r
+\r
+  Shell Interface - additional information (over image_info) provided\r
+  to an application started by the shell.\r
+\r
+  ConIo - provides a file style interface to the console.  Note that the\r
+  ConOut & ConIn interfaces in the system table will work as well, and both\r
+  all will be redirected to a file if needed on a command line\r
+\r
+  The shell interface's and data (including ConIo) are only valid during\r
+  the applications Entry Point.  Once the application returns from it's\r
+  entry point the data is freed by the invoking shell.\r
+  \r
+  Copyright (c) 2006 - 2009, Intel Corporation                                                         \r
+  All rights reserved. This program and the accompanying materials                          \r
+  are licensed and made available under the terms and conditions of the BSD License         \r
+  which accompanies this distribution.  The full text of the license may be found at        \r
+  http://opensource.org/licenses/bsd-license.php                                            \r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+**/\r
+\r
+#ifndef _SHELLINTERFACE_H_\r
+#define _SHELLINTERFACE_H_\r
+\r
+#include <Protocol\LoadedImage.h>\r
+\r
+#define SHELL_INTERFACE_PROTOCOL_GUID \\r
+  { \\r
+    0x47c7b223, 0xc42a, 0x11d2, 0x8e, 0x57, 0x0, 0xa0, 0xc9, 0x69, 0x72, 0x3b \\r
+  }\r
+\r
+///\r
+/// bit definitions for EFI_SHELL_ARG_INFO\r
+///\r
+typedef enum {\r
+  ARG_NO_ATTRIB         = 0x0,\r
+  ARG_IS_QUOTED         = 0x1,\r
+  ARG_PARTIALLY_QUOTED  = 0x2,\r
+  ARG_FIRST_HALF_QUOTED = 0x4,\r
+  ARG_FIRST_CHAR_IS_ESC = 0x8\r
+};\r
+\r
+///\r
+/// attributes for an argument.\r
+///\r
+typedef struct _EFI_SHELL_ARG_INFO {\r
+  UINT32  Attributes;\r
+} EFI_SHELL_ARG_INFO;\r
+\r
+///\r
+/// This protocol provides access to additional information about a shell app.\r
+///\r
+typedef struct {\r
+  ///\r
+  /// Handle back to original image handle & image info\r
+  ///\r
+  EFI_HANDLE                ImageHandle;\r
+  EFI_LOADED_IMAGE_PROTOCOL *Info;\r
+\r
+  ///\r
+  /// Parsed arg list converted more C like format\r
+  ///\r
+  CHAR16                    **Argv;\r
+  UINTN                     Argc;\r
+\r
+  ///\r
+  /// Storage for file redirection args after parsing\r
+  ///\r
+  CHAR16                    **RedirArgv;\r
+  UINTN                     RedirArgc;\r
+\r
+  ///\r
+  /// A file style handle for console io\r
+  ///\r
+  EFI_FILE_HANDLE           StdIn;\r
+  EFI_FILE_HANDLE           StdOut;\r
+  EFI_FILE_HANDLE           StdErr;\r
+\r
+  ///\r
+  /// list of attributes for each argument\r
+  ///\r
+  EFI_SHELL_ARG_INFO        *ArgInfo;\r
+\r
+  ///\r
+  /// whether we are echoing\r
+  ///\r
+  BOOLEAN                   EchoOn;\r
+} EFI_SHELL_INTERFACE;\r
+\r
+extern EFI_GUID gEfiShellInterfaceGuid;\r
+\r
+#endif\r
diff --git a/ShellPkg/Include/Protocol/EfiShellParameters.h b/ShellPkg/Include/Protocol/EfiShellParameters.h
new file mode 100644 (file)
index 0000000..49ad2fd
--- /dev/null
@@ -0,0 +1,33 @@
+/** @file\r
+  EFI Shell protocol as defined in the UEFI Shell 2.0 specification.\r
+  \r
+  Copyright (c) 2006 - 2009, Intel Corporation                                                         \r
+  All rights reserved. This program and the accompanying materials                          \r
+  are licensed and made available under the terms and conditions of the BSD License         \r
+  which accompanies this distribution.  The full text of the license may be found at        \r
+  http://opensource.org/licenses/bsd-license.php                                            \r
+\r
+  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,                     \r
+  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.             \r
+\r
+**/\r
+\r
+#ifndef __EFI_SHELL_PARAMETERS_PROTOCOL__\r
+#define __EFI_SHELL_PARAMETERS_PROTOCOL__\r
+\r
+#define EFI_SHELL_PARAMETERS_PROTOCOL_GUID \\r
+  { \\r
+  0x752f3136, 0x4e16, 0x4fdc, { 0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca } \\r
+  }\r
+\r
+typedef struct _EFI_SHELL_PARAMETERS_PROTOCOL {\r
+  CHAR16 **Argv;\r
+  UINTN Argc;\r
+  EFI_FILE_HANDLE StdIn;\r
+  EFI_FILE_HANDLE StdOut;\r
+  EFI_FILE_HANDLE StdErr;\r
+} EFI_SHELL_PARAMETERS_PROTOCOL;\r
+\r
+extern EFI_GUID gEfiShellParametersProtocolGuid;\r
+\r
+#endif\r
diff --git a/ShellPkg/Library/BaseShellLib/BaseShellLib.c b/ShellPkg/Library/BaseShellLib/BaseShellLib.c
new file mode 100644 (file)
index 0000000..205974d
--- /dev/null
@@ -0,0 +1,2099 @@
+/** @file\r
+  Provides interface to shell functionality for shell commands and applications.\r
+\r
+Copyright (c) 2006 - 2009, Intel Corporation\r
+All rights reserved. This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#include <Uefi.h>\r
+#include <Library/ShellLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/DevicePathLib.h>\r
+#include <Protocol/EfiShellEnvironment2.h>\r
+#include <Protocol/EfiShellInterface.h>\r
+#include <Protocol/EfiShell.h>\r
+#include <Protocol/EfiShellParameters.h>\r
+#include <Protocol/SimpleFileSystem.h>\r
+\r
+#define MAX_FILE_NAME_LEN 522 // (20 * (6+5+2))+1) unicode characters from EFI FAT spec (doubled for bytes)\r
+#define FIND_XXXXX_FILE_BUFFER_SIZE (SIZE_OF_EFI_FILE_INFO + MAX_FILE_NAME_LEN)\r
+\r
+EFI_SHELL_ENVIRONMENT2        *mEfiShellEnvironment2;\r
+EFI_SHELL_INTERFACE           *mEfiShellInterface;\r
+EFI_SHELL_PROTOCOL            *mEfiShellProtocol;\r
+EFI_SHELL_PARAMETERS_PROTOCOL *mEfiShellParametersProtocol;\r
+EFI_HANDLE                    mEfiShellEnvironment2Handle;\r
+EFI_LIST_ENTRY                *mOldStyleFileList;\r
+\r
+/**\r
+  helper function to find ShellEnvironment2 for constructor\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFindSE2 (\r
+  IN EFI_HANDLE        ImageHandle\r
+  )\r
+{\r
+  EFI_STATUS  Status;\r
+  EFI_HANDLE  *Buffer;\r
+  UINTN       BufferSize;\r
+  UINTN       HandleIndex;\r
+\r
+  BufferSize = 0;\r
+  Buffer = NULL;\r
+  Status = gBS->OpenProtocol(ImageHandle, \r
+                             &gEfiShellEnvironment2Guid,\r
+                             (VOID **)&mEfiShellEnvironment2,\r
+                             ImageHandle,\r
+                             NULL,\r
+                             EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                             );\r
+  //\r
+  // look for the mEfiShellEnvironment2 protocol at a higher level\r
+  //\r
+  if (EFI_ERROR (Status) || !(CompareGuid (&mEfiShellEnvironment2->SESGuid, &gEfiShellEnvironment2ExtGuid) != FALSE &&\r
+     (mEfiShellEnvironment2->MajorVersion > EFI_SHELL_MAJOR_VER ||\r
+     (mEfiShellEnvironment2->MajorVersion == EFI_SHELL_MAJOR_VER && mEfiShellEnvironment2->MinorVersion >= EFI_SHELL_MINOR_VER)))) {\r
+    //\r
+    // figure out how big of a buffer we need.\r
+    //\r
+    Status = gBS->LocateHandle (ByProtocol,\r
+                                &gEfiShellEnvironment2Guid,\r
+                                NULL, // ignored for ByProtocol\r
+                                &BufferSize,\r
+                                Buffer\r
+                                );\r
+    ASSERT(Status == EFI_BUFFER_TOO_SMALL);\r
+    Buffer = (EFI_HANDLE*)AllocatePool(BufferSize);\r
+    ASSERT(Buffer != NULL);\r
+    Status = gBS->LocateHandle (ByProtocol,\r
+                                &gEfiShellEnvironment2Guid,\r
+                                NULL, // ignored for ByProtocol\r
+                                &BufferSize,\r
+                                Buffer\r
+                                );\r
+    if (!EFI_ERROR (Status)) {\r
+      //\r
+      // now parse the list of returned handles\r
+      //\r
+      Status = EFI_NOT_FOUND;\r
+      for (HandleIndex = 0; HandleIndex < (BufferSize/sizeof(Buffer[0])); HandleIndex++) {\r
+        Status = gBS->OpenProtocol(Buffer[HandleIndex], \r
+                                   &gEfiShellEnvironment2Guid,\r
+                                   (VOID **)&mEfiShellEnvironment2,\r
+                                   ImageHandle,\r
+                                   NULL,\r
+                                   EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                                   );\r
+         if (CompareGuid (&mEfiShellEnvironment2->SESGuid, &gEfiShellEnvironment2ExtGuid) != FALSE &&\r
+          (mEfiShellEnvironment2->MajorVersion > EFI_SHELL_MAJOR_VER ||\r
+          (mEfiShellEnvironment2->MajorVersion == EFI_SHELL_MAJOR_VER && mEfiShellEnvironment2->MinorVersion >= EFI_SHELL_MINOR_VER))) {\r
+          mEfiShellEnvironment2Handle = Buffer[HandleIndex];\r
+          Status = EFI_SUCCESS;\r
+          break;\r
+        }\r
+      }\r
+    }\r
+  }\r
+  if (Buffer != NULL) {\r
+    FreePool (Buffer);\r
+  }\r
+  return (Status);\r
+}\r
+\r
+/**\r
+  Constructor for the Shell library.\r
+\r
+  Initialize the library and determine if the underlying is a UEFI Shell 2.0 or an EFI shell.\r
+\r
+  @param ImageHandle    the image handle of the process\r
+  @param SystemTable    the EFI System Table pointer\r
+\r
+  @retval EFI_SUCCESS   the initialization was complete sucessfully\r
+  @return others        an error ocurred during initialization\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellLibConstructor (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+{\r
+  EFI_STATUS Status;\r
+\r
+  ASSERT(SystemTable != NULL);\r
+  ASSERT(gBS != NULL);\r
+\r
+  mEfiShellEnvironment2       = NULL;\r
+  mEfiShellProtocol           = NULL;\r
+  mEfiShellParametersProtocol = NULL;\r
+  mEfiShellInterface          = NULL;\r
+  mEfiShellEnvironment2Handle = NULL;\r
+  mOldStyleFileList           = NULL;\r
+\r
+  //\r
+  // UEFI 2.0 shell interfaces (used preferentially)\r
+  //\r
+  Status = gBS->OpenProtocol(ImageHandle, \r
+                             &gEfiShellProtocolGuid,\r
+                             (VOID **)&mEfiShellProtocol,\r
+                             ImageHandle,\r
+                             NULL,\r
+                             EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                             );\r
+  if (EFI_ERROR(Status)) {\r
+    mEfiShellProtocol = NULL;\r
+  }\r
+  Status = gBS->OpenProtocol(ImageHandle, \r
+                             &gEfiShellParametersProtocolGuid,\r
+                             (VOID **)&mEfiShellParametersProtocol,\r
+                             ImageHandle,\r
+                             NULL,\r
+                             EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                             );\r
+  if (EFI_ERROR(Status)) {\r
+    mEfiShellParametersProtocol = NULL;\r
+  }\r
+\r
+  if (mEfiShellParametersProtocol == NULL || mEfiShellProtocol == NULL) {\r
+    //\r
+    // Moved to seperate function due to complexity\r
+    //\r
+    Status = ShellFindSE2(ImageHandle);\r
+\r
+    if (EFI_ERROR(Status)) {\r
+      DEBUG((DEBUG_ERROR, "Status: 0x%08x\r\n", Status));\r
+      mEfiShellEnvironment2 = NULL;\r
+    }\r
+    Status = gBS->OpenProtocol(ImageHandle, \r
+                               &gEfiShellInterfaceGuid,\r
+                               (VOID **)&mEfiShellInterface,\r
+                               ImageHandle,\r
+                               NULL,\r
+                               EFI_OPEN_PROTOCOL_GET_PROTOCOL\r
+                               );\r
+    if (EFI_ERROR(Status)) {\r
+      mEfiShellInterface = NULL;\r
+    }\r
+  }\r
+  //\r
+  // only success getting 2 of either the old or new, but no 1/2 and 1/2\r
+  //\r
+  if ((mEfiShellEnvironment2 != NULL && mEfiShellInterface          != NULL) || \r
+      (mEfiShellProtocol     != NULL && mEfiShellParametersProtocol != NULL)    ) {\r
+    return (EFI_SUCCESS);\r
+  }\r
+  return (EFI_NOT_FOUND);\r
+}\r
+\r
+/**\r
+  Destructory for the library.  free any resources.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellLibDestructor (\r
+  IN EFI_HANDLE        ImageHandle,\r
+  IN EFI_SYSTEM_TABLE  *SystemTable\r
+  )\r
+{\r
+  if (mEfiShellEnvironment2 != NULL) {\r
+    gBS->CloseProtocol(mEfiShellEnvironment2Handle==NULL?ImageHandle:mEfiShellEnvironment2Handle,\r
+                       &gEfiShellEnvironment2Guid,\r
+                       ImageHandle,\r
+                       NULL);\r
+  }\r
+  if (mEfiShellInterface != NULL) {\r
+    gBS->CloseProtocol(ImageHandle,\r
+                       &gEfiShellInterfaceGuid,\r
+                       ImageHandle,\r
+                       NULL);  \r
+  }\r
+  if (mEfiShellProtocol != NULL) {\r
+    gBS->CloseProtocol(ImageHandle,\r
+                       &gEfiShellProtocolGuid,\r
+                       ImageHandle,\r
+                       NULL);    \r
+  }\r
+  if (mEfiShellParametersProtocol != NULL) {\r
+    gBS->CloseProtocol(ImageHandle,\r
+                       &gEfiShellParametersProtocolGuid,\r
+                       ImageHandle,\r
+                       NULL);    \r
+  }\r
+  return (EFI_SUCCESS);\r
+}\r
+/**\r
+  This function will retrieve the information about the file for the handle \r
+  specified and store it in allocated pool memory.\r
+\r
+  This function allocates a buffer to store the file\92s information. It is the \r
+  caller\92s responsibility to free the buffer\r
+\r
+  @param  FileHandle  The file handle of the file for which information is \r
+  being requested.\r
+\r
+  @retval NULL information could not be retrieved.\r
+\r
+  @return the information about the file\r
+**/\r
+EFI_FILE_INFO*\r
+EFIAPI\r
+ShellGetFileInfo (\r
+  IN EFI_FILE_HANDLE            FileHandle\r
+  )\r
+{\r
+  EFI_GUID        FileInfoGuid;\r
+  EFI_FILE_INFO   *pFileInfo;\r
+  UINTN           FileInfoSize;\r
+  EFI_STATUS      Status;\r
+\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+\r
+  //\r
+  // Get the required size to allocate\r
+  //\r
+  FileInfoGuid = gEfiFileInfoGuid;\r
+  FileInfoSize = 0;\r
+  pFileInfo = NULL;\r
+  Status = FileHandle->GetInfo(FileHandle, \r
+                               &FileInfoGuid, \r
+                               &FileInfoSize, \r
+                               pFileInfo);\r
+  //\r
+  // error is expected.  getting size to allocate\r
+  //\r
+  ASSERT (Status == EFI_BUFFER_TOO_SMALL);\r
+  pFileInfo = AllocateZeroPool(FileInfoSize);\r
+  ASSERT (pFileInfo != NULL);\r
+  //\r
+  // now get the information\r
+  //\r
+  Status = FileHandle->GetInfo(FileHandle, \r
+                               &FileInfoGuid, \r
+                               &FileInfoSize, \r
+                               pFileInfo);\r
+  //\r
+  // if we got an error free the memory and return NULL\r
+  //\r
+  if (EFI_ERROR(Status)) {\r
+    FreePool(pFileInfo);\r
+    return NULL;\r
+  }\r
+  return (pFileInfo);\r
+}\r
+\r
+/**\r
+  This function will set the information about the file for the opened handle \r
+  specified.\r
+\r
+  @param  FileHandle            The file handle of the file for which information \r
+  is being set\r
+\r
+  @param  FileInfo              The infotmation to set.\r
+\r
+  @retval EFI_SUCCESS          The information was set.\r
+  @retval EFI_UNSUPPORTED The InformationType is not known.\r
+  @retval EFI_NO_MEDIA         The device has no medium.\r
+  @retval EFI_DEVICE_ERROR     The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED  The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED    The file was opened read only.\r
+  @retval EFI_VOLUME_FULL      The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetFileInfo (\r
+  IN EFI_FILE_HANDLE           FileHandle,\r
+  IN EFI_FILE_INFO              *FileInfo\r
+  )\r
+{\r
+  EFI_GUID        FileInfoGuid;\r
+  \r
+  //\r
+  // ASSERT if the FileHandle or FileInfo is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  ASSERT (FileInfo   != NULL);\r
+\r
+  FileInfoGuid = gEfiFileInfoGuid;\r
+  //\r
+  // Set the info\r
+  //\r
+  return (FileHandle->SetInfo(FileHandle, \r
+                              &FileInfoGuid,\r
+                              (UINTN)FileInfo->Size,\r
+                              FileInfo));\r
+}  \r
+  \r
+  /**\r
+  This function will open a file or directory referenced by DevicePath.\r
+\r
+  This function opens a file with the open mode according to the file path. The \r
+  Attributes is valid only for EFI_FILE_MODE_CREATE.\r
+\r
+  @param  FilePath                 on input the device path to the file.  On output \r
+                          the remaining device path.\r
+  @param  DeviceHandle         pointer to the system device handle.\r
+  @param  FileHandle             pointer to the file handle.\r
+  @param  OpenMode                 the mode to open the file with.\r
+  @param  Attributes             the file's file attributes.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED            Could not open the file path.     \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found on \r
+                                the device.\r
+  @retval EFI_NO_MEDIA               The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED        The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR         The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED    The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED    The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL            The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileByDevicePath(\r
+  IN OUT EFI_DEVICE_PATH_PROTOCOL        **FilePath,\r
+  OUT EFI_HANDLE                       *DeviceHandle,\r
+  OUT EFI_FILE_HANDLE                  *FileHandle,\r
+  IN UINT64                            OpenMode,\r
+  IN UINT64                            Attributes\r
+  )\r
+{\r
+  CHAR16      *FileName;\r
+  EFI_STATUS  Status;\r
+  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *EfiSimpleFileSystemProtocol;\r
+  EFI_FILE_HANDLE LastHandle;\r
+\r
+  //\r
+  // ASERT for FileHandle, FilePath, and DeviceHandle being NULL\r
+  //\r
+  ASSERT(FilePath != NULL);\r
+  ASSERT(FileHandle != NULL);\r
+  ASSERT(DeviceHandle != NULL);\r
+  // \r
+  // which shell interface should we use\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    //\r
+    // use UEFI Shell 2.0 method.\r
+    //\r
+    FileName = mEfiShellProtocol->GetFilePathFromDevicePath(*FilePath);\r
+    if (FileName == NULL) {\r
+      return (EFI_INVALID_PARAMETER);\r
+    }\r
+    Status = ShellOpenFileByName(FileName, FileHandle, OpenMode, Attributes);\r
+    FreePool(FileName);\r
+    return (Status);\r
+  } else {\r
+    //\r
+    // use old shell method.\r
+    //\r
+    Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, \r
+                                    FilePath, \r
+                                    DeviceHandle);\r
+    if (EFI_ERROR (Status)) {\r
+      return Status;\r
+    }\r
+    Status = gBS->OpenProtocol(*DeviceHandle,\r
+                               &gEfiSimpleFileSystemProtocolGuid,\r
+                               &EfiSimpleFileSystemProtocol,\r
+                               gImageHandle,\r
+                               NULL,\r
+                               EFI_OPEN_PROTOCOL_GET_PROTOCOL);\r
+    if (EFI_ERROR (Status)) {\r
+      return Status;\r
+    }\r
+    Status = EfiSimpleFileSystemProtocol->OpenVolume(EfiSimpleFileSystemProtocol, FileHandle);\r
+    if (EFI_ERROR (Status)) {\r
+      FileHandle = NULL;\r
+      return Status;\r
+    }\r
+\r
+    //\r
+    // go down directories one node at a time.\r
+    //\r
+    while (!IsDevicePathEnd (*FilePath)) {\r
+      //\r
+      // For file system access each node should be a file path component\r
+      //\r
+      if (DevicePathType    (*FilePath) != MEDIA_DEVICE_PATH ||\r
+          DevicePathSubType (*FilePath) != MEDIA_FILEPATH_DP\r
+          ) {\r
+        FileHandle = NULL;\r
+        return (EFI_INVALID_PARAMETER);\r
+      }\r
+      //\r
+      // Open this file path node\r
+      //\r
+      LastHandle  = *FileHandle;\r
+      *FileHandle = NULL;\r
+\r
+      //\r
+      // Try to test opening an existing file\r
+      //\r
+      Status = LastHandle->Open (\r
+                            LastHandle,\r
+                            FileHandle,\r
+                            ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,\r
+                            OpenMode &~EFI_FILE_MODE_CREATE,\r
+                            0\r
+                            );\r
+\r
+      //\r
+      // see if the error was that it needs to be created\r
+      //\r
+      if ((EFI_ERROR (Status)) && (OpenMode != (OpenMode &~EFI_FILE_MODE_CREATE))) {\r
+        Status = LastHandle->Open (\r
+                              LastHandle,\r
+                              FileHandle,\r
+                              ((FILEPATH_DEVICE_PATH*)*FilePath)->PathName,\r
+                              OpenMode,\r
+                              Attributes\r
+                              );\r
+      }\r
+      //\r
+      // Close the last node\r
+      //\r
+      LastHandle->Close (LastHandle);\r
+\r
+      if (EFI_ERROR(Status)) {\r
+        return (Status);\r
+      }\r
+\r
+      //\r
+      // Get the next node\r
+      //\r
+      *FilePath = NextDevicePathNode (*FilePath);\r
+    }\r
+    return (EFI_SUCCESS);\r
+  }\r
+}\r
+\r
+/**\r
+  This function will open a file or directory referenced by filename.\r
+\r
+  If return is EFI_SUCCESS, the Filehandle is the opened file\92s handle; \r
+  otherwise, the Filehandle is NULL. The Attributes is valid only for \r
+  EFI_FILE_MODE_CREATE.\r
+\r
+  if FileNAme is NULL then ASSERT()\r
+\r
+  @param  FileName               pointer to file name\r
+  @param  FileHandle           pointer to the file handle.\r
+  @param  OpenMode               the mode to open the file with.\r
+  @param  Attributes           the file's file attributes.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED            Could not open the file path.     \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found \r
+                                on the device.\r
+  @retval EFI_NO_MEDIA               The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED        The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR         The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED    The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED        The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL            The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileByName(\r
+  IN CHAR16                              *FileName,\r
+  OUT EFI_FILE_HANDLE           *FileHandle,\r
+  IN UINT64                     OpenMode,\r
+  IN UINT64                            Attributes\r
+  )\r
+{\r
+  EFI_HANDLE                    DeviceHandle;\r
+  EFI_DEVICE_PATH_PROTOCOL      *FilePath;\r
+\r
+  //\r
+  // ASSERT if FileName is NULL\r
+  //\r
+  ASSERT(FileName != NULL);\r
+\r
+  if (mEfiShellProtocol != NULL) {\r
+    //\r
+    // Use UEFI Shell 2.0 method\r
+    //\r
+    return (mEfiShellProtocol->OpenFileByName(FileName,\r
+                                             FileHandle,\r
+                                             OpenMode));\r
+  } \r
+  //\r
+  // Using EFI Shell version\r
+  // this means convert name to path and call that function\r
+  // since this will use EFI method again that will open it.\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+  FilePath = mEfiShellEnvironment2->NameToPath (FileName);\r
+  if (FileDevicePath != NULL) {\r
+    return (ShellOpenFileByDevicePath(&FilePath,\r
+                                      &DeviceHandle,\r
+                                      FileHandle,\r
+                                      OpenMode,\r
+                                      Attributes ));\r
+  }\r
+  return (EFI_DEVICE_ERROR);\r
+}\r
+/**\r
+  This function create a directory\r
+\r
+  If return is EFI_SUCCESS, the Filehandle is the opened directory's handle; \r
+  otherwise, the Filehandle is NULL. If the directory already existed, this \r
+  function opens the existing directory.\r
+\r
+  @param  DirectoryName                pointer to directory name\r
+  @param  FileHandle             pointer to the file handle.\r
+\r
+  @retval EFI_SUCCESS                  The information was set.\r
+  @retval EFI_INVALID_PARAMETER        One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED            Could not open the file path.     \r
+  @retval EFI_NOT_FOUND                The specified file could not be found on the \r
+                                device or the file system could not be found \r
+                                on the device.\r
+  @retval EFI_NO_MEDIA               The device has no medium.\r
+  @retval EFI_MEDIA_CHANGED        The device has a different medium in it or the \r
+                                medium is no longer supported.\r
+  @retval EFI_DEVICE_ERROR         The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED    The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED        The file was opened read only.\r
+  @retval EFI_OUT_OF_RESOURCES Not enough resources were available to open the \r
+                                file.\r
+  @retval EFI_VOLUME_FULL            The volume is full.\r
+  @sa ShellOpenFileByName\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCreateDirectory(\r
+  IN CHAR16                   *DirectoryName,\r
+  OUT EFI_FILE_HANDLE         *FileHandle\r
+  )\r
+{\r
+  //\r
+  // this is a pass thru to the open file function with sepcific open mode and attributes\r
+  //\r
+  return (ShellOpenFileByName(DirectoryName,\r
+                              FileHandle,\r
+                              EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,\r
+                              EFI_FILE_DIRECTORY\r
+                              ));\r
+}\r
+\r
+/**\r
+  This function reads information from an opened file.\r
+\r
+  If FileHandle is not a directory, the function reads the requested number of \r
+  bytes from the file at the file\92s current position and returns them in Buffer. \r
+  If the read goes beyond the end of the file, the read length is truncated to the\r
+  end of the file. The file\92s current position is increased by the number of bytes \r
+  returned.  If FileHandle is a directory, the function reads the directory entry \r
+  at the file\92s current position and returns the entry in Buffer. If the Buffer \r
+  is not large enough to hold the current directory entry, then \r
+  EFI_BUFFER_TOO_SMALL is returned and the current file position is not updated. \r
+  BufferSize is set to be the size of the buffer needed to read the entry. On \r
+  success, the current position is updated to the next directory entry. If there \r
+  are no more directory entries, the read returns a zero-length buffer. \r
+  EFI_FILE_INFO is the structure returned as the directory entry.\r
+\r
+  @param FileHandle             the opened file handle\r
+  @param BufferSize             on input the size of buffer in bytes.  on return \r
+                                the number of bytes written.\r
+  @param Buffer                 the buffer to put read data into.\r
+\r
+  @retval EFI_SUCCESS            Data was read.\r
+  @retval EFI_NO_MEDIA         The device has no media.\r
+  @retval EFI_DEVICE_ERROR     The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED The file system structures are corrupted.\r
+  @retval EFI_BUFFER_TO_SMALL  Buffer is too small. ReadSize contains required \r
+                                size.\r
+\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellReadFile(\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  IN OUT UINTN                  *BufferSize,\r
+  OUT VOID                      *Buffer\r
+  )\r
+{\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+\r
+  //\r
+  // Perform the read based on EFI_FILE_PROTOCOL\r
+  //\r
+  return (FileHandle->Read(FileHandle, BufferSize, Buffer));\r
+}\r
+\r
+\r
+/**\r
+  Write data to a file.\r
+\r
+  This function writes the specified number of bytes to the file at the current \r
+  file position. The current file position is advanced the actual number of bytes \r
+  written, which is returned in BufferSize. Partial writes only occur when there \r
+  has been a data error during the write attempt (such as \93volume space full\94). \r
+  The file is automatically grown to hold the data if required. Direct writes to \r
+  opened directories are not supported.\r
+\r
+  @param FileHandle           The opened file for writing\r
+  @param BufferSize           on input the number of bytes in Buffer.  On output\r
+                              the number of bytes written.\r
+  @param Buffer               the buffer containing data to write is stored.\r
+\r
+ @retval EFI_SUCCESS           Data was written.\r
+ @retval EFI_UNSUPPORTED           Writes to an open directory are not supported.\r
+ @retval EFI_NO_MEDIA          The device has no media.\r
+ @retval EFI_DEVICE_ERROR          The device reported an error.\r
+ @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+ @retval EFI_WRITE_PROTECTED   The device is write-protected.\r
+ @retval EFI_ACCESS_DENIED       The file was open for read only.\r
+ @retval EFI_VOLUME_FULL           The volume is full.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellWriteFile(\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  IN OUT UINTN                  *BufferSize,\r
+  IN VOID                       *Buffer\r
+  )\r
+{\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  //\r
+  // Perform the write based on EFI_FILE_PROTOCOL\r
+  //\r
+  return (FileHandle->Write(FileHandle, BufferSize, Buffer));\r
+}\r
+\r
+/** \r
+  Close an open file handle.\r
+\r
+  This function closes a specified file handle. All \93dirty\94 cached file data is \r
+  flushed to the device, and the file is closed. In all cases the handle is \r
+  closed.\r
+\r
+@param FileHandle               the file handle to close.\r
+\r
+@retval EFI_SUCCESS             the file handle was closed sucessfully.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCloseFile (\r
+  IN EFI_FILE_HANDLE            *FileHandle\r
+  )\r
+{\r
+  EFI_STATUS Status;\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  ASSERT (*FileHandle != NULL);\r
+  //\r
+  // Perform the Close based on EFI_FILE_PROTOCOL\r
+  //\r
+  Status = (*FileHandle)->Close(*FileHandle);\r
+  *FileHandle = NULL;\r
+  return Status;\r
+}\r
+\r
+/**\r
+  Delete a file and close the handle\r
+\r
+  This function closes and deletes a file. In all cases the file handle is closed.\r
+  If the file cannot be deleted, the warning code EFI_WARN_DELETE_FAILURE is \r
+  returned, but the handle is still closed.\r
+\r
+  @param FileHandle             the file handle to delete\r
+\r
+  @retval EFI_SUCCESS           the file was closed sucessfully\r
+  @retval EFI_WARN_DELETE_FAILURE the handle was closed, but the file was not \r
+                                deleted\r
+  @retval INVALID_PARAMETER            One of the parameters has an invalid value.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellDeleteFile (\r
+  IN EFI_FILE_HANDLE           *FileHandle\r
+  )\r
+{\r
+  EFI_STATUS Status;\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  ASSERT (*FileHandle != NULL);\r
+  //\r
+  // Perform the Delete based on EFI_FILE_PROTOCOL\r
+  //\r
+  Status = (*FileHandle)->Delete(*FileHandle);\r
+  *FileHandle = NULL;\r
+  return Status;\r
+}\r
+\r
+/**\r
+  Set the current position in a file.\r
+\r
+  This function sets the current file position for the handle to the position \r
+  supplied. With the exception of seeking to position 0xFFFFFFFFFFFFFFFF, only\r
+  absolute positioning is supported, and seeking past the end of the file is \r
+  allowed (a subsequent write would grow the file). Seeking to position \r
+  0xFFFFFFFFFFFFFFFF causes the current position to be set to the end of the file.\r
+  If FileHandle is a directory, the only position that may be set is zero. This \r
+  has the effect of starting the read process of the directory entries over.\r
+\r
+  @param FileHandle             The file handle on which the position is being set\r
+  @param Position               Byte position from begining of file\r
+\r
+  @retval EFI_SUCCESS           Operation completed sucessfully.\r
+  @retval EFI_UNSUPPORTED       the seek request for non-zero is not valid on \r
+                                directories.\r
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetFilePosition (\r
+  IN EFI_FILE_HANDLE           FileHandle,\r
+  IN UINT64            Position\r
+  )\r
+{\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  //\r
+  // Perform the SetPosition based on EFI_FILE_PROTOCOL\r
+  //\r
+  return (FileHandle->SetPosition(FileHandle, Position));\r
+}\r
+\r
+/** \r
+  Gets a file's current position\r
+\r
+  This function retrieves the current file position for the file handle. For \r
+  directories, the current file position has no meaning outside of the file \r
+  system driver and as such the operation is not supported. An error is returned\r
+  if FileHandle is a directory.\r
+\r
+  @param FileHandle             The open file handle on which to get the position.\r
+  @param Position               Byte position from begining of file.\r
+\r
+  @retval EFI_SUCCESS           the operation completed sucessfully.\r
+  @retval INVALID_PARAMETER     One of the parameters has an invalid value.\r
+  @retval EFI_UNSUPPORTED       the request is not valid on directories.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellGetFilePosition (\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  OUT UINT64                    *Position\r
+  )\r
+{\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  //\r
+  // Perform the GetPosition based on EFI_FILE_PROTOCOL\r
+  //\r
+  return (FileHandle->GetPosition(FileHandle, Position));\r
+}\r
+/**\r
+  Flushes data on a file\r
+  \r
+  This function flushes all modified data associated with a file to a device.\r
+\r
+  @param FileHandle             The file handle on which to flush data\r
+\r
+  @retval EFI_SUCCESS           The data was flushed.\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @retval EFI_WRITE_PROTECTED   The file or medium is write protected.\r
+  @retval EFI_ACCESS_DENIED     The file was opened for read only.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFlushFile (\r
+  IN EFI_FILE_HANDLE            FileHandle\r
+  )\r
+{\r
+  //\r
+  // ASSERT if FileHandle is NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  //\r
+  // Perform the Flush based on EFI_FILE_PROTOCOL\r
+  //\r
+  return (FileHandle->Flush(FileHandle));\r
+}\r
+\r
+/**\r
+  function to determine if a given handle is a directory handle\r
+\r
+  if DirHandle is NULL then ASSERT()\r
+\r
+  open the file information on the DirHandle and verify that the Attribute\r
+  includes EFI_FILE_DIRECTORY bit set.\r
+\r
+  @param DirHandle              Handle to open file\r
+\r
+  @retval EFI_SUCCESS           DirHandle is a directory\r
+  @retval EFI_INVALID_PARAMETER DirHandle did not have EFI_FILE_INFO available\r
+  @retval EFI_NOT_FOUND         DirHandle is not a directory\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+InternalShellIsDirectory (\r
+  IN EFI_FILE_HANDLE            DirHandle\r
+  )\r
+{\r
+  EFI_FILE_INFO *DirInfo;\r
+\r
+  //\r
+  // ASSERT if DirHandle is NULL\r
+  //\r
+  ASSERT(DirHandle != NULL);\r
+  \r
+  //\r
+  // get the file information for DirHandle\r
+  //\r
+  DirInfo     = ShellGetFileInfo (DirHandle);\r
+  \r
+  //\r
+  // Parse DirInfo\r
+  //\r
+  if (DirInfo == NULL) {\r
+    //\r
+    // We got nothing...\r
+    //\r
+    return (EFI_INVALID_PARAMETER);\r
+  } \r
+  if ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == 0) {\r
+    //\r
+    // Attributes say this is not a directory\r
+    //\r
+    FreePool (DirInfo);\r
+    return (EFI_NOT_FOUND);\r
+  }\r
+  //\r
+  // all good...\r
+  //\r
+  FreePool (DirInfo);\r
+  return (EFI_SUCCESS);\r
+}\r
+\r
+/**\r
+  Retrieves the first file from a directory\r
+\r
+  This function opens a directory and gets the first file\92s info in the \r
+  directory. Caller can use ShellFindNextFile() to get other files.  When \r
+  complete the caller is responsible for calling FreePool() on Buffer.\r
+\r
+  @param DirHandle              The file handle of the directory to search\r
+  @param Buffer                 Pointer to buffer for file's information\r
+\r
+  @retval EFI_SUCCESS           Found the first file.\r
+  @retval EFI_NOT_FOUND         Cannot find the directory.\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+  @return Others                status of ShellGetFileInfo, ShellSetFilePosition,\r
+                                or ShellReadFile\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFindFirstFile (\r
+  IN EFI_FILE_HANDLE            DirHandle,\r
+  OUT EFI_FILE_INFO             *Buffer\r
+  )\r
+{\r
+  EFI_STATUS    Status;\r
+  UINTN         BufferSize;\r
+\r
+  //\r
+  // ASSERT if DirHandle is NULL\r
+  //\r
+  ASSERT (DirHandle != NULL);\r
+  \r
+  //\r
+  // verify that DirHandle is a directory\r
+  //\r
+  Status = InternalShellIsDirectory(DirHandle);\r
+  if (EFI_ERROR(Status)) {\r
+    return (Status);\r
+  } \r
+\r
+  //\r
+  // reset to the begining of the directory \r
+  //\r
+  Status = ShellSetFilePosition (DirHandle, 0);\r
+  if (EFI_ERROR(Status)) {\r
+    return (Status);\r
+  } \r
+\r
+  //\r
+  // Allocate a buffer sized to struct size + enough for the string at the end\r
+  //\r
+  BufferSize = FIND_XXXXX_FILE_BUFFER_SIZE;\r
+  Buffer = AllocateZeroPool(BufferSize);\r
+  ASSERT (Buffer != NULL);\r
+\r
+  //\r
+  // read in the info about the first file\r
+  //\r
+  Status = ShellReadFile (DirHandle, &BufferSize, Buffer);\r
+  ASSERT(Status != EFI_BUFFER_TOO_SMALL);\r
+  if (EFI_ERROR(Status)) {\r
+    return (Status);\r
+  }\r
+  return (EFI_SUCCESS);\r
+}\r
+/**\r
+  Retrieves the next file in a directory.\r
+\r
+  To use this function, caller must call the LibFindFirstFile() to get the \r
+  first file, and then use this function get other files. This function can be \r
+  called for several times to get each file's information in the directory. If \r
+  the call of ShellFindNextFile() got the last file in the directory, the next \r
+  call of this function has no file to get. *NoFile will be set to TRUE and the \r
+  Buffer memory will be automatically freed. \r
+\r
+  @param DirHandle              the file handle of the directory\r
+  @param Buffer                                    pointer to buffer for file's information\r
+  @param NoFile                                    pointer to boolean when last file is found\r
+\r
+  @retval EFI_SUCCESS           Found the next file, or reached last file\r
+  @retval EFI_NO_MEDIA          The device has no media.\r
+  @retval EFI_DEVICE_ERROR      The device reported an error.\r
+  @retval EFI_VOLUME_CORRUPTED  The file system structures are corrupted.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellFindNextFile(\r
+  IN EFI_FILE_HANDLE             DirHandle,\r
+  OUT EFI_FILE_INFO              *Buffer,\r
+  OUT BOOLEAN                    *NoFile\r
+  )\r
+{\r
+  EFI_STATUS    Status;\r
+  UINTN         BufferSize;\r
+\r
+  //\r
+  // ASSERTs for DirHandle or Buffer or NoFile poitners being NULL\r
+  //\r
+  ASSERT (DirHandle != NULL);\r
+  ASSERT (Buffer    != NULL);\r
+  ASSERT (NoFile    != NULL);\r
+  \r
+  //\r
+  // verify that DirHandle is a directory\r
+  //\r
+  Status = InternalShellIsDirectory(DirHandle);\r
+  if (EFI_ERROR(Status)) {\r
+    return (Status);\r
+  } \r
+\r
+  //\r
+  // This BufferSize MUST stay equal to the originally allocated one in GetFirstFile\r
+  //\r
+  BufferSize = FIND_XXXXX_FILE_BUFFER_SIZE;\r
+\r
+  //\r
+  // read in the info about the next file\r
+  //\r
+  Status = ShellReadFile (DirHandle, &BufferSize, Buffer);\r
+  ASSERT(Status != EFI_BUFFER_TOO_SMALL);\r
+  if (EFI_ERROR(Status)) {\r
+    return (Status);\r
+  }\r
+\r
+  //\r
+  // If we read 0 bytes (but did not have erros) we already read in the last file.\r
+  //\r
+  if (BufferSize == 0) {\r
+    FreePool(Buffer);\r
+    *NoFile = TRUE;\r
+  }\r
+\r
+  return (EFI_SUCCESS);\r
+}\r
+/**\r
+  Retrieve the size of a file.\r
+\r
+  if FileHandle is NULL then ASSERT()\r
+  if Size is NULL then ASSERT()\r
+\r
+  This function extracts the file size info from the FileHandle\92s EFI_FILE_INFO \r
+  data.\r
+\r
+  @param FileHandle             file handle from which size is retrieved\r
+  @param Size                   pointer to size\r
+\r
+  @retval EFI_SUCCESS           operation was completed sucessfully\r
+  @retval EFI_DEVICE_ERROR      cannot access the file\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellGetFileSize (\r
+  IN EFI_FILE_HANDLE            FileHandle,\r
+  OUT UINT64                    *Size\r
+  )\r
+{\r
+  EFI_FILE_INFO                 *FileInfo;\r
+\r
+  //\r
+  // ASSERT for FileHandle or Size being NULL\r
+  //\r
+  ASSERT (FileHandle != NULL);\r
+  ASSERT (Size != NULL);\r
+  \r
+  //\r
+  // get the FileInfo structure\r
+  //\r
+  FileInfo = ShellGetFileInfo(FileHandle);\r
+  if (FileInfo == NULL) {\r
+    return (EFI_DEVICE_ERROR);\r
+  }\r
+\r
+  //\r
+  // Assign the Size pointer to the correct value\r
+  //\r
+  *Size = FileInfo->FileSize;\r
+  \r
+  //\r
+  // free the FileInfo memory\r
+  //\r
+  FreePool(FileInfo);\r
+\r
+  return (EFI_SUCCESS);\r
+}\r
+/**\r
+  Retrieves the status of the break execution flag\r
+\r
+  this function is useful to check whether the application is being asked to halt by the shell.\r
+\r
+  @retval TRUE                  the execution break is enabled\r
+  @retval FALSE                 the execution break is not enabled\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+ShellGetExecutionBreakFlag(\r
+  VOID\r
+  )\r
+{\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+\r
+    //\r
+    // We are using UEFI Shell 2.0; see if the event has been triggered\r
+    //\r
+    if (gBS->CheckEvent(mEfiShellProtocol->ExecutionBreak) != EFI_SUCCESS) {\r
+      return (FALSE);\r
+    }\r
+    return (TRUE);\r
+  } \r
+\r
+  //\r
+  // using EFI Shell; call the function to check\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+  return (mEfiShellEnvironment2->GetExecutionBreak());\r
+}\r
+/**\r
+  return the value of an environment variable\r
+\r
+  this function gets the value of the environment variable set by the \r
+  ShellSetEnvironmentVariable function\r
+\r
+  @param EnvKey                 The key name of the environment variable.\r
+\r
+  @retval NULL                  the named environment variable does not exist.\r
+  @return != NULL               pointer to the value of the environment variable\r
+**/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellGetEnvironmentVariable (\r
+  IN CHAR16                     *EnvKey\r
+  )\r
+{\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    return (mEfiShellProtocol->GetEnv(EnvKey));\r
+  }\r
+\r
+  //\r
+  // ASSERT that we must have EFI shell\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+\r
+  //\r
+  // using EFI Shell\r
+  //\r
+  return (mEfiShellEnvironment2->GetEnv(EnvKey));\r
+}\r
+/**\r
+  set the value of an environment variable\r
+\r
+This function changes the current value of the specified environment variable. If the\r
+environment variable exists and the Value is an empty string, then the environment\r
+variable is deleted. If the environment variable exists and the Value is not an empty\r
+string, then the value of the environment variable is changed. If the environment\r
+variable does not exist and the Value is an empty string, there is no action. If the\r
+environment variable does not exist and the Value is a non-empty string, then the\r
+environment variable is created and assigned the specified value.\r
+\r
+  This is not supported pre-UEFI Shell 2.0.\r
+\r
+  @param EnvKey                 The key name of the environment variable.\r
+  @param EnvVal                 The Value of the environment variable\r
+  @param Volatile               Indicates whether the variable is non-volatile (FALSE) or volatile (TRUE).\r
+\r
+  @retval EFI_SUCCESS           the operation was completed sucessfully\r
+  @retval EFI_UNSUPPORTED       This operation is not allowed in pre UEFI 2.0 Shell environments\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellSetEnvironmentVariable (\r
+  IN CONST CHAR16               *EnvKey,\r
+  IN CONST CHAR16               *EnvVal,\r
+  IN BOOLEAN                    Volatile\r
+  )\r
+{\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    return (mEfiShellProtocol->SetEnv(EnvKey, EnvVal, Volatile));\r
+  } \r
+\r
+  //\r
+  // This feature does not exist under EFI shell\r
+  //\r
+  return (EFI_UNSUPPORTED);\r
+}\r
+/**\r
+  cause the shell to parse and execute a command line.\r
+\r
+  This function creates a nested instance of the shell and executes the specified\r
+command (CommandLine) with the specified environment (Environment). Upon return,\r
+the status code returned by the specified command is placed in StatusCode.\r
+If Environment is NULL, then the current environment is used and all changes made\r
+by the commands executed will be reflected in the current environment. If the\r
+Environment is non-NULL, then the changes made will be discarded.\r
+The CommandLine is executed from the current working directory on the current\r
+device.\r
+\r
+EnvironmentVariables and Status are only supported for UEFI Shell 2.0.\r
+Output is only supported for pre-UEFI Shell 2.0\r
+\r
+  @param ImageHandle            Parent image that is starting the operation\r
+  @param CommandLine            pointer to null terminated command line.\r
+  @param Output                 true to display debug output.  false to hide it.\r
+  @param EnvironmentVariables   optional pointer to array of environment variables\r
+                                in the form "x=y".  if NULL current set is used.\r
+  @param Status                 the status of the run command line.\r
+\r
+  @retval EFI_SUCCESS           the operation completed sucessfully.  Status\r
+                                contains the status code returned.\r
+  @retval EFI_INVALID_PARAMETER a parameter contains an invalid value\r
+  @retval EFI_OUT_OF_RESOURCES  out of resources\r
+  @retval EFI_UNSUPPORTED       the operation is not allowed.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellExecute (\r
+  IN EFI_HANDLE                 *ParentHandle,\r
+  IN CHAR16                     *CommandLine OPTIONAL,\r
+  IN BOOLEAN                    Output OPTIONAL,\r
+  IN CHAR16                     **EnvironmentVariables OPTIONAL,\r
+  OUT EFI_STATUS                *Status OPTIONAL\r
+  )\r
+{\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    //\r
+    // Call UEFI Shell 2.0 version (not using Output parameter)\r
+    //\r
+    return (mEfiShellProtocol->Execute(ParentHandle,\r
+                                      CommandLine,\r
+                                      EnvironmentVariables,\r
+                                      Status));\r
+  } \r
+  //\r
+  // ASSERT that we must have EFI shell\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+  //\r
+  // Call EFI Shell version (not using EnvironmentVariables or Status parameters)\r
+  // Due to oddity in the EFI shell we want to dereference the ParentHandle here\r
+  //\r
+  return (mEfiShellEnvironment2->Execute(*ParentHandle, \r
+                                        CommandLine, \r
+                                        Output));\r
+}\r
+/**\r
+  Retreives the current directory path\r
+\r
+  If the DeviceName is NULL, it returns the current device\92s current directory \r
+  name. If the DeviceName is not NULL, it returns the current directory name \r
+  on specified drive.\r
+\r
+  @param DeviceName             the name of the drive to get directory on\r
+\r
+  @retval NULL                  the directory does not exist\r
+  @return != NULL               the directory\r
+**/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellGetCurrentDir (\r
+  IN CHAR16                     *DeviceName OPTIONAL\r
+  )\r
+{\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    return (mEfiShellProtocol->GetCurDir(DeviceName));\r
+  } \r
+  //\r
+  // ASSERT that we must have EFI shell\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+  return (mEfiShellEnvironment2->CurDir(DeviceName));\r
+}\r
+/**\r
+  sets (enabled or disabled) the page break mode\r
+\r
+  when page break mode is enabled the screen will stop scrolling \r
+  and wait for operator input before scrolling a subsequent screen.\r
+\r
+  @param CurrentState           TRUE to enable and FALSE to disable\r
+**/\r
+VOID \r
+EFIAPI\r
+ShellSetPageBreakMode (\r
+  IN BOOLEAN                    CurrentState\r
+  )\r
+{\r
+  //\r
+  // check for enabling\r
+  //\r
+  if (CurrentState != 0x00) {\r
+    // \r
+    // check for UEFI Shell 2.0\r
+    //\r
+    if (mEfiShellProtocol != NULL) {\r
+      //\r
+      // Enable with UEFI 2.0 Shell\r
+      //\r
+      mEfiShellProtocol->EnablePageBreak();\r
+      return;\r
+    } else {\r
+      // \r
+      // ASSERT that must have EFI Shell\r
+      //\r
+      ASSERT(mEfiShellEnvironment2 != NULL);\r
+      //\r
+      // Enable with EFI Shell\r
+      //\r
+      mEfiShellEnvironment2->EnablePageBreak (DEFAULT_INIT_ROW, DEFAULT_AUTO_LF);\r
+      return;\r
+    }\r
+  } else {\r
+    // \r
+    // check for UEFI Shell 2.0\r
+    //\r
+    if (mEfiShellProtocol != NULL) {\r
+      //\r
+      // Disable with UEFI 2.0 Shell\r
+      //\r
+      mEfiShellProtocol->DisablePageBreak();\r
+      return;\r
+    } else {\r
+      // \r
+      // ASSERT that must have EFI Shell\r
+      //\r
+      ASSERT(mEfiShellEnvironment2 != NULL);\r
+      //\r
+      // Disable with EFI Shell\r
+      //\r
+      mEfiShellEnvironment2->DisablePageBreak ();\r
+      return;\r
+    }\r
+  }\r
+}\r
+\r
+///\r
+/// version of EFI_SHELL_FILE_INFO struct, except has no CONST pointers.\r
+/// This allows for the struct to be populated.\r
+///\r
+typedef struct {\r
+  EFI_LIST_ENTRY Link;\r
+  EFI_STATUS Status;\r
+  CHAR16 *FullName;\r
+  CHAR16 *FileName;\r
+  EFI_FILE_HANDLE Handle;\r
+  EFI_FILE_INFO *Info;\r
+} EFI_SHELL_FILE_INFO_NO_CONST;\r
+\r
+/**\r
+  Converts a EFI shell list of structures to the coresponding UEFI Shell 2.0 type of list.\r
+\r
+  if OldStyleFileList is NULL then ASSERT()\r
+\r
+  this function will convert a SHELL_FILE_ARG based list into a callee allocated \r
+  EFI_SHELL_FILE_INFO based list.  it is up to the caller to free the memory via\r
+  the ShellCloseFileMetaArg function.\r
+\r
+  @param FileList               the EFI shell list type\r
+\r
+  @retval the resultant head of the double linked new format list;\r
+**/\r
+LIST_ENTRY*\r
+EFIAPI\r
+InternalShellConvertFileListType (\r
+  EFI_LIST_ENTRY                *FileList\r
+  )\r
+{\r
+  LIST_ENTRY                    *ListHead;\r
+  SHELL_FILE_ARG                *OldInfo;\r
+  EFI_LIST_ENTRY                *Link;\r
+  EFI_SHELL_FILE_INFO_NO_CONST  *NewInfo;\r
+\r
+  //\r
+  // ASSERT that FileList is not NULL\r
+  //\r
+  ASSERT(FileList != NULL);\r
+\r
+  //\r
+  // Allocate our list head and initialize the list\r
+  //\r
+  ListHead = AllocateZeroPool(sizeof(EFI_LIST_ENTRY));\r
+  ASSERT (ListHead != NULL);\r
+  ListHead = InitializeListHead (ListHead);\r
+\r
+  //\r
+  // enumerate through each member of the old list and copy\r
+  //\r
+  for (Link = FileList->Flink; Link != FileList; Link = Link->Flink) {\r
+    OldInfo = CR (Link, SHELL_FILE_ARG, Link, SHELL_FILE_ARG_SIGNATURE);\r
+\r
+    //\r
+    // make sure the old list was valid\r
+    //\r
+    ASSERT(OldInfo           != NULL); \r
+    ASSERT(OldInfo->Info     != NULL);\r
+    ASSERT(OldInfo->FullName != NULL);\r
+    ASSERT(OldInfo->FileName != NULL);\r
+\r
+    //\r
+    // allocate a new EFI_SHELL_FILE_INFO object\r
+    //\r
+    NewInfo               = AllocateZeroPool(sizeof(EFI_SHELL_FILE_INFO));\r
+    \r
+    // \r
+    // copy the simple items\r
+    //\r
+    NewInfo->Handle       = OldInfo->Handle;\r
+    NewInfo->Status       = OldInfo->Status;\r
+\r
+    //\r
+    // allocate new space to copy strings and structure\r
+    //\r
+    NewInfo->FullName     = AllocateZeroPool(StrSize(OldInfo->FullName));\r
+    NewInfo->FileName     = AllocateZeroPool(StrSize(OldInfo->FileName));\r
+    NewInfo->Info         = AllocateZeroPool((UINTN)OldInfo->Info->Size);\r
+    \r
+    //\r
+    // make sure all the memory allocations were sucessful\r
+    //\r
+    ASSERT(NewInfo->FullName != NULL);\r
+    ASSERT(NewInfo->FileName != NULL);\r
+    ASSERT(NewInfo->Info     != NULL);\r
+\r
+    //\r
+    // Copt the strings and structure\r
+    //\r
+    StrCpy(NewInfo->FullName, OldInfo->FullName);\r
+    StrCpy(NewInfo->FileName, OldInfo->FileName);\r
+    gBS->CopyMem (NewInfo->Info, OldInfo->Info, (UINTN)OldInfo->Info->Size);\r
+\r
+    //\r
+    // add that to the list\r
+    //\r
+    InsertTailList(ListHead, (LIST_ENTRY*)NewInfo);\r
+  }\r
+  return (ListHead);\r
+}\r
+/**\r
+  Opens a group of files based on a path.\r
+\r
+  This function uses the Arg to open all the matching files. Each matched \r
+  file has a SHELL_FILE_ARG structure to record the file information. These \r
+  structures are placed on the list ListHead. Users can get the SHELL_FILE_ARG \r
+  structures from ListHead to access each file. This function supports wildcards\r
+  and will process '?' and '*' as such.  the list must be freed with a call to \r
+  ShellCloseFileMetaArg().\r
+\r
+  This function will fail if called sequentially without freeing the list in the middle.\r
+\r
+  @param Arg                    pointer to path string\r
+  @param OpenMode               mode to open files with\r
+  @param ListHead               head of linked list of results\r
+\r
+  @retval EFI_SUCCESS           the operation was sucessful and the list head \r
+                                contains the list of opened files\r
+  #retval EFI_UNSUPPORTED       a previous ShellOpenFileMetaArg must be closed first.\r
+                                *ListHead is set to NULL.\r
+  @return != EFI_SUCCESS        the operation failed\r
+\r
+  @sa InternalShellConvertFileListType\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellOpenFileMetaArg (\r
+  IN CHAR16                     *Arg,\r
+  IN UINT64                     OpenMode,\r
+  IN OUT EFI_SHELL_FILE_INFO    **ListHead\r
+  )\r
+{\r
+  EFI_STATUS                    Status;\r
+  LIST_ENTRY                    *EmptyNode;\r
+\r
+  //\r
+  // make sure we have no outstanding list\r
+  //\r
+  if (mOldStyleFileList != NULL) {\r
+    *ListHead = NULL;\r
+    return (EFI_UNSUPPORTED);\r
+  }\r
+\r
+  //\r
+  // ASSERT that Arg and ListHead are not NULL\r
+  //\r
+  ASSERT(Arg      != NULL);\r
+  ASSERT(ListHead != NULL);\r
+\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    return (mEfiShellProtocol->OpenFileList(Arg, \r
+                                           OpenMode, \r
+                                           ListHead));\r
+  } \r
+\r
+  //\r
+  // ASSERT that we must have EFI shell\r
+  //\r
+  ASSERT(mEfiShellEnvironment2 != NULL);\r
+\r
+  //\r
+  // allocate memory for old list head\r
+  //\r
+  mOldStyleFileList = (EFI_LIST_ENTRY*)AllocatePool(sizeof(EFI_LIST_ENTRY));\r
+  ASSERT(mOldStyleFileList != NULL);\r
+\r
+  //\r
+  // make sure the list head is initialized\r
+  //\r
+  InitializeListHead((LIST_ENTRY*)mOldStyleFileList);\r
+\r
+  //\r
+  // Get the EFI Shell list of files\r
+  //\r
+  Status = mEfiShellEnvironment2->FileMetaArg(Arg, mOldStyleFileList);\r
+  if (EFI_ERROR(Status)) {\r
+    *ListHead = NULL;\r
+    return (Status);\r
+  }\r
+\r
+  //\r
+  // Convert that to equivalent of UEFI Shell 2.0 structure\r
+  //\r
+  EmptyNode = InternalShellConvertFileListType(mOldStyleFileList);\r
+\r
+  //\r
+  // remove the empty head of the list\r
+  //\r
+  *ListHead = (EFI_SHELL_FILE_INFO*)RemoveEntryList(EmptyNode);\r
+  FreePool(EmptyNode);  \r
+\r
+  return (Status);\r
+}\r
+/**\r
+  Free the linked list returned from ShellOpenFileMetaArg\r
+\r
+  if ListHead is NULL then ASSERT()\r
+\r
+  @param ListHead               the pointer to free\r
+\r
+  @retval EFI_SUCCESS           the operation was sucessful\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCloseFileMetaArg (\r
+  IN OUT EFI_SHELL_FILE_INFO    **ListHead\r
+  )\r
+{\r
+  LIST_ENTRY                    *Node;\r
+\r
+  //\r
+  // ASSERT that ListHead is not NULL\r
+  //\r
+  ASSERT(ListHead != NULL);\r
+\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellProtocol != NULL) {\r
+    return (mEfiShellProtocol->FreeFileList(ListHead));\r
+  } else {\r
+    //\r
+    // Free the EFI Shell version that was converted.\r
+    //\r
+    ASSERT_EFI_ERROR(mEfiShellEnvironment2->FreeFileList(mOldStyleFileList));\r
+    FreePool(mOldStyleFileList);\r
+    mOldStyleFileList = NULL;\r
+\r
+    //\r
+    // Since this is EFI Shell version we need to free our internally made copy \r
+    // of the list\r
+    //\r
+    for (Node = GetFirstNode((LIST_ENTRY*)*ListHead) ; IsListEmpty((LIST_ENTRY*)*ListHead) == FALSE ; Node = GetFirstNode((LIST_ENTRY*)*ListHead)) {\r
+      RemoveEntryList(Node);\r
+      FreePool(((EFI_SHELL_FILE_INFO_NO_CONST*)Node)->FullName);\r
+      FreePool(((EFI_SHELL_FILE_INFO_NO_CONST*)Node)->FileName);\r
+      FreePool(((EFI_SHELL_FILE_INFO_NO_CONST*)Node)->Info);\r
+      FreePool((EFI_SHELL_FILE_INFO_NO_CONST*)Node);\r
+    }\r
+    return EFI_SUCCESS;\r
+  }\r
+}\r
+\r
+typedef struct {\r
+  EFI_LIST_ENTRY List;\r
+  CHAR16         *Name;\r
+  ParamType      Type;\r
+  CHAR16         *Value;\r
+  UINTN          OriginalPosition;\r
+} SHELL_PARAM_PACKAGE;\r
+\r
+/**\r
+  Checks the list of valid arguments and returns TRUE if the item was found.  If the \r
+  return value is TRUE then the type parameter is set also.\r
+  \r
+  if CheckList is NULL then ASSERT();\r
+  if Name is NULL then ASSERT();\r
+  if Type is NULL then ASSERT();\r
+\r
+  @param Type                   pointer to type of parameter if it was found\r
+  @param Name                   pointer to Name of parameter found\r
+  @param CheckList              List to check against\r
+\r
+  @retval TRUE                  the Parameter was found.  Type is valid.\r
+  @retval FALSE                 the Parameter was not found.  Type is not valid.\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+IsCheckList (\r
+  IN CONST CHAR16               *Name,\r
+  IN CONST SHELL_PARAM_ITEM     *CheckList,\r
+  OUT ParamType                 *Type\r
+  )\r
+{\r
+  SHELL_PARAM_ITEM              *TempListItem;\r
+\r
+  //\r
+  // ASSERT that all 3 pointer parameters aren't NULL\r
+  //\r
+  ASSERT(CheckList  != NULL);\r
+  ASSERT(Type       != NULL);\r
+  ASSERT(Name       != NULL);\r
+\r
+  //\r
+  // Enumerate through the list\r
+  //\r
+  for (TempListItem = (SHELL_PARAM_ITEM*)CheckList ; TempListItem->Name != NULL ; TempListItem++) {\r
+    //\r
+    // If the Name matches set the type and return TRUE\r
+    //\r
+    if (StrCmp(Name, TempListItem->Name) == 0) {\r
+      *Type = TempListItem->Type;\r
+      return (TRUE);\r
+    }\r
+  }\r
+  return (FALSE);\r
+}\r
+/**\r
+  Checks the string for indicators of "flag" status.  this is a leading '/' or '-'\r
+\r
+  @param Name                   pointer to Name of parameter found\r
+\r
+  @retval TRUE                  the Parameter is a flag.\r
+  @retval FALSE                 the Parameter not a flag\r
+**/\r
+BOOLEAN\r
+EFIAPI\r
+IsFlag (\r
+  IN CONST CHAR16               *Name\r
+  )\r
+{\r
+  //\r
+  // ASSERT that Name isn't NULL\r
+  //\r
+  ASSERT(Name != NULL);\r
+\r
+  //\r
+  // If the Name has a / or - as the first character return TRUE\r
+  //\r
+  if ((Name[0] == L'/') || (Name[0] == L'-') ) {\r
+      return (TRUE);\r
+  }\r
+  return (FALSE);\r
+}\r
+\r
+/**\r
+  Checks the command line arguments passed against the list of valid ones.  \r
+\r
+  If no initialization is required, then return RETURN_SUCCESS.\r
+  \r
+  @param CheckList              pointer to list of parameters to check\r
+  @param CheckPackage           pointer to pointer to list checked values\r
+  @param ProblemParam           optional pointer to pointer to unicode string for \r
+                                the paramater that caused failure.\r
+  @param AutoPageBreak          will automatically set PageBreakEnabled for "b" parameter\r
+  @param Argc                   Count of parameters in Argv\r
+  @param Argv                   pointer to array of parameters\r
+\r
+  @retval EFI_SUCCESS           The operation completed sucessfully.\r
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed\r
+  @retval EFI_INVALID_PARAMETER A parameter was invalid\r
+  @retval EFI_VOLUME_CORRUPTED  the command line was corrupt.  an argument was \r
+                                duplicated.  the duplicated command line argument \r
+                                was returned in ProblemParam if provided.\r
+  @retval EFI_NOT_FOUND         a argument required a value that was missing.  \r
+                                the invalid command line argument was returned in\r
+                                ProblemParam if provided.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+InternalCommandLineParse (\r
+  IN CONST SHELL_PARAM_ITEM     *CheckList,\r
+  OUT LIST_ENTRY                **CheckPackage,\r
+  OUT CHAR16                    **ProblemParam OPTIONAL,\r
+  IN BOOLEAN                    AutoPageBreak,\r
+  IN CONST CHAR16               **Argv,\r
+  IN UINTN                      Argc\r
+  )\r
+{\r
+  UINTN                         LoopCounter;\r
+  UINTN                         Count;\r
+  ParamType                     CurrentItemType;\r
+  SHELL_PARAM_PACKAGE           *CurrentItemPackage;\r
+  BOOLEAN                       GetItemValue;\r
+\r
+  CurrentItemPackage = NULL;\r
+\r
+  //\r
+  // ASSERTs\r
+  //\r
+  ASSERT(CheckList  != NULL);\r
+  ASSERT(Argv       != NULL);\r
+\r
+  Count = 0;\r
+  GetItemValue = FALSE;\r
+\r
+  //\r
+  // If there is only 1 item we dont need to do anything\r
+  //\r
+  if (Argc <= 1) {\r
+    *CheckPackage = NULL;\r
+    return (EFI_SUCCESS);\r
+  }\r
+\r
+  //\r
+  // initialize the linked list\r
+  //\r
+  *CheckPackage = (LIST_ENTRY*)AllocateZeroPool(sizeof(LIST_ENTRY));\r
+  InitializeListHead(*CheckPackage);\r
+\r
+  //\r
+  // loop through each of the arguments\r
+  //\r
+  for (LoopCounter = 0 ; LoopCounter < Argc ; ++LoopCounter) {\r
+    if (Argv[LoopCounter] == NULL) {\r
+      //\r
+      // do nothing for NULL argv\r
+      //\r
+    } else if (GetItemValue == TRUE) {\r
+      ASSERT(CurrentItemPackage != NULL);\r
+      //\r
+      // get the item VALUE for the previous flag\r
+      //\r
+      GetItemValue = FALSE;\r
+      CurrentItemPackage->Value = AllocateZeroPool(StrSize(Argv[LoopCounter]));\r
+      ASSERT(CurrentItemPackage->Value != NULL);\r
+      StrCpy(CurrentItemPackage->Value, Argv[LoopCounter]);\r
+      InsertTailList(*CheckPackage, (LIST_ENTRY*)CurrentItemPackage);\r
+    } else if (IsFlag(Argv[LoopCounter]) == FALSE) {\r
+      //\r
+      // add this one as a non-flag\r
+      //\r
+      CurrentItemPackage = AllocatePool(sizeof(SHELL_PARAM_PACKAGE));\r
+      ASSERT(CurrentItemPackage != NULL);\r
+      CurrentItemPackage->Name  = NULL;\r
+      CurrentItemPackage->Type  = TypePosition;\r
+      CurrentItemPackage->Value = AllocatePool(StrSize(Argv[LoopCounter]));\r
+      ASSERT(CurrentItemPackage->Value != NULL);\r
+      StrCpy(CurrentItemPackage->Value, Argv[LoopCounter]);\r
+      CurrentItemPackage->OriginalPosition = Count++;\r
+      InsertTailList(*CheckPackage, (LIST_ENTRY*)CurrentItemPackage);\r
+    } else if (IsCheckList(Argv[LoopCounter], CheckList, &CurrentItemType) == TRUE) {\r
+      //\r
+      // this is a flag\r
+      //\r
+      CurrentItemPackage = AllocatePool(sizeof(SHELL_PARAM_PACKAGE));\r
+      ASSERT(CurrentItemPackage != NULL);\r
+      CurrentItemPackage->Name  = AllocatePool(StrSize(Argv[LoopCounter]));\r
+      ASSERT(CurrentItemPackage->Name != NULL);\r
+      StrCpy(CurrentItemPackage->Name,  Argv[LoopCounter]);\r
+      CurrentItemPackage->Type  = CurrentItemType;\r
+      CurrentItemPackage->OriginalPosition = (UINTN)(-1);\r
+\r
+      //\r
+      // Does this flag require a value\r
+      //\r
+      if (CurrentItemPackage->Type == TypeValue) {\r
+        //\r
+        // trigger the next loop to populate the value of this item\r
+        //\r
+        GetItemValue = TRUE; \r
+      } else {\r
+        //\r
+        // this item has no value expected; we are done\r
+        //\r
+        CurrentItemPackage->Value = NULL;\r
+        InsertTailList(*CheckPackage, (LIST_ENTRY*)CurrentItemPackage);\r
+      }\r
+    } else if (ProblemParam) {\r
+      //\r
+      // this was a non-recognised flag... error!\r
+      //\r
+      *ProblemParam = (CHAR16*)Argv[LoopCounter];\r
+      ShellCommandLineFreeVarList(*CheckPackage);\r
+      *CheckPackage = NULL;\r
+      return (EFI_VOLUME_CORRUPTED);\r
+    } else {\r
+      ShellCommandLineFreeVarList(*CheckPackage);\r
+      *CheckPackage = NULL;\r
+      return (EFI_VOLUME_CORRUPTED);\r
+    }\r
+  }\r
+  //\r
+  // support for AutoPageBreak\r
+  //\r
+  if (AutoPageBreak && ShellCommandLineGetFlag(*CheckPackage, L"-b")) {\r
+    ShellSetPageBreakMode(TRUE);\r
+  }\r
+  return (EFI_SUCCESS);\r
+}\r
+\r
+/**\r
+  Checks the command line arguments passed against the list of valid ones.  \r
+  Optionally removes NULL values first.\r
+  \r
+  If no initialization is required, then return RETURN_SUCCESS.\r
+  \r
+  @param CheckList              pointer to list of parameters to check\r
+  @param CheckPackage           pointer to pointer to list checked values\r
+  @param ProblemParam           optional pointer to pointer to unicode string for \r
+                                the paramater that caused failure.\r
+  @param AutoPageBreak          will automatically set PageBreakEnabled for "b" parameter\r
+\r
+  @retval EFI_SUCCESS           The operation completed sucessfully.\r
+  @retval EFI_OUT_OF_RESOURCES  A memory allocation failed\r
+  @retval EFI_INVALID_PARAMETER A parameter was invalid\r
+  @retval EFI_VOLUME_CORRUPTED  the command line was corrupt.  an argument was \r
+                                duplicated.  the duplicated command line argument \r
+                                was returned in ProblemParam if provided.\r
+  @retval EFI_DEVICE_ERROR      the commands contained 2 opposing arguments.  one\r
+                                of the command line arguments was returned in \r
+                                ProblemParam if provided.\r
+  @retval EFI_NOT_FOUND         a argument required a value that was missing.  \r
+                                the invalid command line argument was returned in\r
+                                ProblemParam if provided.\r
+**/\r
+EFI_STATUS\r
+EFIAPI\r
+ShellCommandLineParse (\r
+  IN CONST SHELL_PARAM_ITEM     *CheckList,\r
+  OUT LIST_ENTRY                **CheckPackage,\r
+  OUT CHAR16                    **ProblemParam OPTIONAL,\r
+  IN BOOLEAN                    AutoPageBreak\r
+  )\r
+{\r
+  // \r
+  // ASSERT that CheckList and CheckPackage aren't NULL\r
+  //\r
+  ASSERT(CheckList    != NULL);\r
+  ASSERT(CheckPackage != NULL);\r
+\r
+  // \r
+  // Check for UEFI Shell 2.0 protocols\r
+  //\r
+  if (mEfiShellParametersProtocol != NULL) {\r
+    return (InternalCommandLineParse(CheckList, \r
+                                     CheckPackage, \r
+                                     ProblemParam, \r
+                                     AutoPageBreak, \r
+                                     mEfiShellParametersProtocol->Argv,\r
+                                     mEfiShellParametersProtocol->Argc ));\r
+  }\r
+\r
+  // \r
+  // ASSERT That EFI Shell is not required\r
+  //\r
+  ASSERT (mEfiShellInterface != NULL);\r
+  return (InternalCommandLineParse(CheckList, \r
+                                   CheckPackage, \r
+                                   ProblemParam, \r
+                                   AutoPageBreak, \r
+                                   mEfiShellInterface->Argv,\r
+                                   mEfiShellInterface->Argc ));\r
+}\r
+\r
+/**\r
+  Frees shell variable list that was returned from ShellCommandLineParse.\r
+\r
+  This function will free all the memory that was used for the CheckPackage\r
+  list of postprocessed shell arguments.\r
+\r
+  this function has no return value.\r
+\r
+  if CheckPackage is NULL, then return\r
+\r
+  @param CheckPackage           the list to de-allocate\r
+  **/\r
+VOID\r
+EFIAPI\r
+ShellCommandLineFreeVarList (\r
+  IN LIST_ENTRY                 *CheckPackage\r
+  )\r
+{\r
+  LIST_ENTRY                    *Node;\r
+\r
+  //\r
+  // check for CheckPackage == NULL\r
+  //\r
+  if (CheckPackage == NULL) {\r
+    return;\r
+  }\r
+\r
+  //\r
+  // for each node in the list\r
+  //\r
+  for (Node = GetFirstNode(CheckPackage); Node != CheckPackage ; Node = GetFirstNode(CheckPackage)) {\r
+    //\r
+    // Remove it from the list\r
+    //\r
+    RemoveEntryList(Node);\r
+\r
+    //\r
+    // if it has a name free the name\r
+    //\r
+    if (((SHELL_PARAM_PACKAGE*)Node)->Name != NULL) {\r
+      FreePool(((SHELL_PARAM_PACKAGE*)Node)->Name);\r
+    }\r
+\r
+    //\r
+    // if it has a value free the value\r
+    //\r
+    if (((SHELL_PARAM_PACKAGE*)Node)->Value != NULL) {\r
+      FreePool(((SHELL_PARAM_PACKAGE*)Node)->Value);\r
+    }\r
+    \r
+    //\r
+    // free the node structure\r
+    //\r
+    FreePool((SHELL_PARAM_PACKAGE*)Node);\r
+  }\r
+  //\r
+  // free the list head node\r
+  //\r
+  FreePool(CheckPackage);\r
+}\r
+/**\r
+  Checks for presence of a flag parameter\r
+\r
+  flag arguments are in the form of "-<Key>" or "/<Key>", but do not have a value following the key\r
+\r
+  if CheckPackage is NULL then return FALSE.\r
+  if KeyString is NULL then ASSERT()\r
+  \r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param KeyString              the Key of the command line argument to check for\r
+\r
+  @retval TRUE                  the flag is on the command line\r
+  @retval FALSE                 the flag is not on the command line\r
+  **/\r
+BOOLEAN\r
+EFIAPI\r
+ShellCommandLineGetFlag (\r
+  IN CONST LIST_ENTRY           *CheckPackage,\r
+  IN CHAR16                     *KeyString\r
+  )\r
+{\r
+  LIST_ENTRY                    *Node;\r
+\r
+  //\r
+  // ASSERT that both CheckPackage and KeyString aren't NULL\r
+  //\r
+  ASSERT(KeyString != NULL);\r
+\r
+  //\r
+  // return FALSE for no package\r
+  //\r
+  if (CheckPackage == NULL) {\r
+    return (FALSE);\r
+  }\r
+\r
+  //\r
+  // enumerate through the list of parametrs\r
+  //\r
+  for (Node = GetFirstNode(CheckPackage) ; Node != CheckPackage ; Node = GetNextNode(CheckPackage, Node) ) {\r
+    //\r
+    // If the Name matches, return TRUE (and there may be NULL name)\r
+    //\r
+    if (((SHELL_PARAM_PACKAGE*)Node)->Name != NULL) {\r
+      if (StrCmp(KeyString, ((SHELL_PARAM_PACKAGE*)Node)->Name) == 0) {\r
+        return (TRUE);\r
+      }\r
+    }\r
+  }\r
+  return (FALSE);\r
+}\r
+/**\r
+  returns value from command line argument\r
+\r
+  value parameters are in the form of "-<Key> value" or "/<Key> value"\r
+  \r
+  if CheckPackage is NULL, then return NULL;\r
+\r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param KeyString              the Key of the command line argument to check for\r
+\r
+  @retval NULL                  the flag is not on the command line\r
+  @return !=NULL                pointer to unicode string of the value\r
+  **/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellCommandLineGetValue (\r
+  IN CONST LIST_ENTRY           *CheckPackage,\r
+  IN CHAR16                     *KeyString\r
+  )\r
+{\r
+  LIST_ENTRY                    *Node;\r
+\r
+  //\r
+  // check for CheckPackage == NULL\r
+  //\r
+  if (CheckPackage == NULL) {\r
+    return (NULL);\r
+  }\r
+\r
+  //\r
+  // enumerate through the list of parametrs\r
+  //\r
+  for (Node = GetFirstNode(CheckPackage) ; Node != NULL ; Node = GetNextNode(CheckPackage, Node) ) {\r
+    //\r
+    // If the Name matches, return the value (name can be NULL)\r
+    //\r
+    if (((SHELL_PARAM_PACKAGE*)Node)->Name != NULL) {\r
+      if (StrCmp(KeyString, ((SHELL_PARAM_PACKAGE*)Node)->Name) == 0) {\r
+        return (((SHELL_PARAM_PACKAGE*)Node)->Value);\r
+      }\r
+    }\r
+  }\r
+  return (NULL);\r
+}\r
+/**\r
+  returns raw value from command line argument\r
+\r
+  raw value parameters are in the form of "value" in a specific position in the list\r
+  \r
+  if CheckPackage is NULL, then return NULL;\r
+\r
+  @param CheckPackage           The package of parsed command line arguments\r
+  @param Position               the position of the value \r
+\r
+  @retval NULL                  the flag is not on the command line\r
+  @return !=NULL                pointer to unicode string of the value\r
+  **/\r
+CONST CHAR16*\r
+EFIAPI\r
+ShellCommandLineGetRawValue (\r
+  IN CONST LIST_ENTRY           *CheckPackage,\r
+  IN UINT32                     Position\r
+  )\r
+{\r
+  LIST_ENTRY                    *Node;\r
+\r
+  //\r
+  // check for CheckPackage == NULL\r
+  //\r
+  if (CheckPackage == NULL) {\r
+    return (NULL);\r
+  }\r
+\r
+  //\r
+  // enumerate through the list of parametrs\r
+  //\r
+  for (Node = GetFirstNode(CheckPackage) ; Node != NULL ; Node = GetNextNode(CheckPackage, Node) ) {\r
+    //\r
+    // If the position matches, return the value\r
+    //\r
+    if (((SHELL_PARAM_PACKAGE*)Node)->OriginalPosition == Position) {\r
+      return (((SHELL_PARAM_PACKAGE*)Node)->Value);\r
+    }\r
+  }\r
+  return (NULL);\r
+}
\ No newline at end of file
diff --git a/ShellPkg/Library/BaseShellLib/BaseShellLib.inf b/ShellPkg/Library/BaseShellLib/BaseShellLib.inf
new file mode 100644 (file)
index 0000000..8a2c33b
--- /dev/null
@@ -0,0 +1,61 @@
+#/** @file\r
+# Provides interface to shell functionality for shell commands and applications.\r
+#\r
+# Copyright (c) 2006 - 2009, Intel Corporation.\r
+#\r
+#  All rights reserved. This program and the accompanying materials\r
+#  are licensed and made available under the terms and conditions of the BSD License\r
+#  which accompanies this distribution. The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.php\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#\r
+#**/\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010006\r
+  BASE_NAME                      = BaseShellLib\r
+  FILE_GUID                      = 449D0F00-2148-4a43-9836-F10B3980ECF5\r
+  MODULE_TYPE                    = UEFI_DRIVER\r
+  VERSION_STRING                 = 1.0\r
+  LIBRARY_CLASS                  = ShellLib|UEFI_APPLICATION UEFI_DRIVER\r
+  CONSTRUCTOR                    = ShellLibConstructor\r
+  DESTRUCTOR                     = ShellLibDestructor\r
+\r
+#\r
+#  VALID_ARCHITECTURES           = IA32 X64 IPF EBC\r
+#\r
+\r
+[Sources.common]\r
+  BaseShellLib.c\r
+\r
+[Packages]\r
+  MdePkg/MdePkg.dec\r
+  ShellPkg/ShellPkg.dec\r
+\r
+[LibraryClasses]\r
+  UefiBootServicesTableLib\r
+  MemoryAllocationLib\r
+  DevicePathLib\r
+  BaseLib\r
+  BaseMemoryLib\r
+  DebugLib\r
+\r
+[Protocols]\r
+  gEfiSimpleFileSystemProtocolGuid              # ALWAYS_CONSUMED\r
+  \r
+  # shell 2.0 \r
+  gEfiShellProtocolGuid                         # SOMETIMES_CONSUMED\r
+  gEfiShellParametersProtocolGuid               # SOMETIMES_CONSUMED\r
+\r
+  # 'old' shell\r
+  gEfiShellEnvironment2Guid                     # SOMETIMES_CONSUMED\r
+  gEfiShellInterfaceGuid                        # SOMETIMES_CONSUMED\r
+\r
+[Guids]\r
+  gEfiFileInfoGuid                              # ALWAYS_CONSUMED\r
+  gEfiShellEnvironment2ExtGuid                  # ALWAYS_CONSUMED\r
+\r
+[Pcd.common]\r
+\r
diff --git a/ShellPkg/ShellPkg.dec b/ShellPkg/ShellPkg.dec
new file mode 100644 (file)
index 0000000..922ad5e
--- /dev/null
@@ -0,0 +1,50 @@
+##  @file  ShellPkg.dec\r
+#\r
+# This Package provides all definitions for EFI and UEFI Shell\r
+#\r
+# Copyright (c) 2009, Intel Corporation.\r
+#\r
+# All rights reserved.\r
+# This program and the accompanying materials are licensed and made available under\r
+# the terms and conditions of the BSD License which accompanies this distribution.\r
+# The full text of the license may be found at\r
+# http://opensource.org/licenses/bsd-license.php\r
+#\r
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+##\r
+\r
+\r
+[Defines]\r
+  DEC_SPECIFICATION              = 0x00010005\r
+  PACKAGE_NAME                   = ShellPkg\r
+  PACKAGE_GUID                   = 9FB7587C-93F7-40a7-9C04-FD7BA94EE646\r
+  PACKAGE_VERSION                = 0.1\r
+\r
+\r
+[Includes.common]\r
+  Include\r
+\r
+[LibraryClasses.common]\r
+  ##  @libraryclass  Provides most Shell APIs.\r
+  #                  Only available for Shell applications\r
+  ##\r
+  ShellLib|Include/Library/ShellLib.h\r
+\r
+[Guids.common]\r
+  gEfiShellEnvironment2ExtGuid    = {0xd2c18636, 0x40e5, 0x4eb5, {0xa3, 0x1b, 0x36, 0x69, 0x5f, 0xd4, 0x2c, 0x87}}\r
+\r
+[Protocols.common]\r
+  gEfiShellProtocolGuid           = {0x6302d008, 0x7f9b, 0x4f30, {0x87, 0xac, 0x60, 0xc9, 0xfe, 0xf5, 0xda, 0x4e}}\r
+  gEfiShellParametersProtocolGuid = {0x752f3136, 0x4e16, 0x4fdc, {0xa2, 0x2a, 0xe5, 0xf4, 0x68, 0x12, 0xf4, 0xca}}\r
+  gEfiShellEnvironment2Guid       = {0x47c7b221, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}\r
+  gEfiShellInterfaceGuid          = {0x47c7b223, 0xc42a, 0x11d2, {0x8e, 0x57, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b}}\r
+\r
+[PcdsFeatureFlag.common]\r
+\r
+[PcdsFixedAtBuild.common]\r
+\r
+[PcdsPatchableInModule.common]\r
+\r
+[PcdsDynamic.common]
\ No newline at end of file
diff --git a/ShellPkg/ShellPkg.dsc b/ShellPkg/ShellPkg.dsc
new file mode 100644 (file)
index 0000000..ebe872a
--- /dev/null
@@ -0,0 +1,48 @@
+#/** @file\r
+# Shell Package\r
+# This is the first release of the Shell package.  Please be aware that there will \r
+# probably be higher than usual numbers of changes as the package gets used and issues, \r
+# enhancements, and bugs are found and fixed.\r
+#\r
+# Copyright (c) 2007 - 2008, Intel Corporation\r
+#\r
+#  All rights reserved. This program and the accompanying materials\r
+#    are licensed and made available under the terms and conditions of the BSD License\r
+#    which accompanies this distribution. The full text of the license may be found at\r
+#    http://opensource.org/licenses/bsd-license.php\r
+#\r
+#    THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#    WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+#**/\r
+\r
+[Defines]\r
+  PLATFORM_NAME                  = Shell\r
+  PLATFORM_GUID                  = E1DC9BF8-7013-4c99-9437-795DAA45F3BD\r
+  PLATFORM_VERSION               = 0.1\r
+  DSC_SPECIFICATION              = 0x00010005\r
+  OUTPUT_DIRECTORY               = Build/Shell\r
+  SUPPORTED_ARCHITECTURES        = IA32|IPF|X64|EBC\r
+  BUILD_TARGETS                  = DEBUG|RELEASE\r
+  SKUID_IDENTIFIER               = DEFAULT\r
+\r
+[LibraryClasses.common]\r
+  UefiApplicationEntryPoint|MdePkg/Library/UefiApplicationEntryPoint/UefiApplicationEntryPoint.inf\r
+  UefiBootServicesTableLib|MdePkg/Library/UefiBootServicesTableLib/UefiBootServicesTableLib.inf\r
+  DevicePathLib|MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.inf\r
+  DebugLib|MdePkg/Library/BaseDebugLibNull/BaseDebugLibNull.inf\r
+  PcdLib|MdePkg/Library/BasePcdLibNull/BasePcdLibNull.inf\r
+  MemoryAllocationLib|MdePkg/Library/UefiMemoryAllocationLib/UefiMemoryAllocationLib.inf\r
+  UefiLib|MdePkg/Library/UefiLib/UefiLib.inf\r
+  BaseLib|MdePkg/Library/BaseLib/BaseLib.inf\r
+  BaseMemoryLib|MdePkg/Library/BaseMemoryLibOptDxe/BaseMemoryLibOptDxe.inf\r
+  PrintLib|MdeModulePkg/Library/DxePrintLibPrint2Protocol/DxePrintLibPrint2Protocol.inf\r
+  UefiRuntimeServicesTableLib|MdePkg/Library/UefiRuntimeServicesTableLib/UefiRuntimeServicesTableLib.inf\r
+  ShellLib|ShellPkg/Library/BaseShellLib/BaseShellLib.inf\r
+\r
+[PcdsFixedAtBuild.common]\r
+\r
+[Components.common]\r
+  ShellPkg/Library/BaseShellLib/BaseShellLib.inf\r
+  ShellPkg/Application/ShellExecTestApp/SA.inf\r
+  ShellPkg/Application/ShellLibTestApp/SA3.inf
\ No newline at end of file