ShellPkg/Library/UefiShellLevel1CommandsLib/If.c

   1 /** @file
   2   Main file for If and else shell level 1 function.
   3
   4   Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
   5   This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "UefiShellLevel1CommandsLib.h"
  16 #include <Library/PrintLib.h>
  17
  18
  19
  20
  21 typedef enum {
  22   END_TAG_OR,
  23   END_TAG_AND,
  24   END_TAG_THEN,
  25   END_TAG_MAX
  26 } END_TAG_TYPE;
  27
  28 typedef enum {
  29   OPERATOR_GT,
  30   OPERATOR_LT,
  31   OPERATOR_EQ,
  32   OPERATOR_NE,
  33   OPERATOR_GE,
  34   OPERATOR_LE,
  35   OPERATOR_UGT,
  36   OPERATOR_ULT,
  37   OPERATOR_UGE,
  38   OPERATOR_ULE,
  39   OPERATOR_MAX
  40 } BIN_OPERATOR_TYPE;
  41
  42 BOOLEAN
  43 EFIAPI
  44 IsNextFragment (
  45   IN CONST CHAR16         **Statement,
  46   IN CONST CHAR16         *Fragment
  47   )
  48 {
  49   CHAR16                  *Tester;
  50
  51   Tester = NULL;
  52
  53   Tester = StrnCatGrow(&Tester, NULL, *Statement, StrLen(Fragment));
  54   ASSERT(Tester != NULL);
  55   Tester[StrLen(Fragment)] = CHAR_NULL;
  56   if (gUnicodeCollation->StriColl(
  57         gUnicodeCollation,
  58         (CHAR16*)Fragment,
  59         Tester) == 0) {
  60     //
  61     // increment the string pointer to the end of what we found and then chop off spaces...
  62     //
  63     *Statement+=StrLen(Fragment);
  64     while (*Statement[0] == L' ') {
  65       (*Statement)++;
  66     }
  67     FreePool(Tester);
  68     return (TRUE);
  69   }
  70   FreePool(Tester);
  71   return (FALSE);
  72 }
  73
  74 BOOLEAN
  75 EFIAPI
  76 IsValidProfile (
  77   IN CONST CHAR16 *String
  78   )
  79 {
  80   CONST CHAR16  *ProfilesString;
  81   CONST CHAR16  *TempLocation;
  82
  83   ProfilesString = ShellGetEnvironmentVariable(L"profiles");
  84   TempLocation = StrStr(ProfilesString, String);
  85   if ((TempLocation != NULL) && (*(TempLocation-1) == L';') && (*(TempLocation+StrLen(String)) == L';')) {
  86     return (TRUE);
  87   }
  88   return (FALSE);
  89 }
  90
  91 BOOLEAN
  92 EFIAPI
  93 TestOperation (
  94   IN CONST CHAR16             *Compare1,
  95   IN CONST CHAR16             *Compare2,
  96   IN CONST BIN_OPERATOR_TYPE  BinOp,
  97   IN CONST BOOLEAN            CaseInsensitive,
  98   IN CONST BOOLEAN            ForceStringCompare
  99   )
 100 {
 101   INTN Cmp1;
 102   INTN Cmp2;
 103
 104   //
 105   // "Compare1 BinOp Compare2"
 106   //
 107   switch (BinOp) {
 108   case OPERATOR_UGT:
 109   case OPERATOR_GT:
 110     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 111       //
 112       // string compare
 113       //
 114       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) > 0) || (StringCompare(&Compare1, &Compare2) > 0)) {
 115         return (TRUE);
 116       }
 117     } else {
 118       //
 119       // numeric compare
 120       //
 121       if (Compare1[0] == L'-') {
 122         Cmp1 = 0 - (INTN)StrDecimalToUintn(Compare1+1);
 123       } else {
 124         Cmp1 = (INTN)StrDecimalToUintn(Compare1);
 125       }
 126       if (Compare2[0] == L'-') {
 127         Cmp2 = 0 - (INTN)StrDecimalToUintn(Compare2+1);
 128       } else {
 129         Cmp2 = (INTN)StrDecimalToUintn(Compare2);
 130       }
 131       if (BinOp == OPERATOR_GT) {
 132         if (Cmp1 > Cmp2) {
 133           return (TRUE);
 134         }
 135       } else {
 136         if ((UINTN)Cmp1 > (UINTN)Cmp2) {
 137           return (TRUE);
 138         }
 139       }
 140     }
 141     return (FALSE);
 142     break;
 143   case OPERATOR_ULT:
 144   case OPERATOR_LT:
 145     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 146       //
 147       // string compare
 148       //
 149       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) < 0) || (StringCompare(&Compare1, &Compare2) < 0)) {
 150         return (TRUE);
 151       }
 152     } else {
 153       //
 154       // numeric compare
 155       //
 156       if (Compare1[0] == L'-') {
 157         Cmp1 = 0 - (INTN)StrDecimalToUintn(Compare1+1);
 158       } else {
 159         Cmp1 = (INTN)StrDecimalToUintn(Compare1);
 160       }
 161       if (Compare2[0] == L'-') {
 162         Cmp2 = 0 - (INTN)StrDecimalToUintn(Compare2+1);
 163       } else {
 164         Cmp2 = (INTN)StrDecimalToUintn(Compare2);
 165       }
 166       if (BinOp == OPERATOR_LT) {
 167         if (Cmp1 < Cmp2) {
 168           return (TRUE);
 169         }
 170       } else {
 171         if ((UINTN)Cmp1 < (UINTN)Cmp2) {
 172           return (TRUE);
 173         }
 174       }
 175
 176     }
 177     return (FALSE);
 178     break;
 179   case OPERATOR_EQ:
 180     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 181       //
 182       // string compare
 183       //
 184       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) == 0) || (StringCompare(&Compare1, &Compare2) == 0)) {
 185         return (TRUE);
 186       }
 187     } else {
 188       //
 189       // numeric compare
 190       //
 191       if (Compare1[0] == L'-') {
 192         Cmp1 = 0 - (INTN)ShellStrToUintn(Compare1+1);
 193       } else {
 194         Cmp1 = (INTN)ShellStrToUintn(Compare1);
 195       }
 196       if (Compare2[0] == L'-') {
 197         Cmp2 = 0 - (INTN)ShellStrToUintn(Compare2+1);
 198       } else {
 199         Cmp2 = (INTN)ShellStrToUintn(Compare2);
 200       }
 201       if (Cmp1 == Cmp2) {
 202         return (TRUE);
 203       }
 204     }
 205     return (FALSE);
 206     break;
 207   case OPERATOR_NE:
 208     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 209       //
 210       // string compare
 211       //
 212       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) != 0) || (StringCompare(&Compare1, &Compare2) != 0)) {
 213         return (TRUE);
 214       }
 215     } else {
 216       //
 217       // numeric compare
 218       //
 219       if (Compare1[0] == L'-') {
 220         Cmp1 = 0 - (INTN)StrDecimalToUintn(Compare1+1);
 221       } else {
 222         Cmp1 = (INTN)StrDecimalToUintn(Compare1);
 223       }
 224       if (Compare2[0] == L'-') {
 225         Cmp2 = 0 - (INTN)StrDecimalToUintn(Compare2+1);
 226       } else {
 227         Cmp2 = (INTN)StrDecimalToUintn(Compare2);
 228       }
 229       if (Cmp1 != Cmp2) {
 230         return (TRUE);
 231       }
 232     }
 233     return (FALSE);
 234     break;
 235   case OPERATOR_UGE:
 236   case OPERATOR_GE:
 237     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 238       //
 239       // string compare
 240       //
 241       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) >= 0) || (StringCompare(&Compare1, &Compare2) >= 0)) {
 242         return (TRUE);
 243       }
 244     } else {
 245       //
 246       // numeric compare
 247       //
 248       if (Compare1[0] == L'-') {
 249         Cmp1 = 0 - (INTN)StrDecimalToUintn(Compare1+1);
 250       } else {
 251         Cmp1 = (INTN)StrDecimalToUintn(Compare1);
 252       }
 253       if (Compare2[0] == L'-') {
 254         Cmp2 = 0 - (INTN)StrDecimalToUintn(Compare2+1);
 255       } else {
 256         Cmp2 = (INTN)StrDecimalToUintn(Compare2);
 257       }
 258       if (BinOp == OPERATOR_GE) {
 259         if (Cmp1 >= Cmp2) {
 260           return (TRUE);
 261         }
 262       } else {
 263         if ((UINTN)Cmp1 >= (UINTN)Cmp2) {
 264           return (TRUE);
 265         }
 266       }
 267     }
 268     return (FALSE);
 269     break;
 270   case OPERATOR_LE:
 271   case OPERATOR_ULE:
 272     if (ForceStringCompare || !ShellIsHexOrDecimalNumber(Compare1, FALSE, FALSE) || !ShellIsHexOrDecimalNumber(Compare2, FALSE, FALSE)) {
 273       //
 274       // string compare
 275       //
 276       if ((CaseInsensitive && StringNoCaseCompare(&Compare1, &Compare2) <= 0) || (StringCompare(&Compare1, &Compare2) <= 0)) {
 277         return (TRUE);
 278       }
 279     } else {
 280       //
 281       // numeric compare
 282       //
 283       if (Compare1[0] == L'-') {
 284         Cmp1 = 0 - (INTN)StrDecimalToUintn(Compare1+1);
 285       } else {
 286         Cmp1 = (INTN)StrDecimalToUintn(Compare1);
 287       }
 288       if (Compare2[0] == L'-') {
 289         Cmp2 = 0 - (INTN)StrDecimalToUintn(Compare2+1);
 290       } else {
 291         Cmp2 = (INTN)StrDecimalToUintn(Compare2);
 292       }
 293       if (BinOp == OPERATOR_LE) {
 294         if (Cmp1 <= Cmp2) {
 295           return (TRUE);
 296         }
 297       } else {
 298         if ((UINTN)Cmp1 <= (UINTN)Cmp2) {
 299           return (TRUE);
 300         }
 301       }
 302     }
 303     return (FALSE);
 304     break;
 305   default:
 306     ASSERT(FALSE);
 307     return (FALSE);
 308   }
 309   ASSERT(FALSE);
 310   return (FALSE);
 311 }
 312
 313 EFI_STATUS
 314 EFIAPI
 315 ProcessStatement (
 316   IN OUT BOOLEAN          *PassingState,
 317   IN UINTN                StartParameterNumber,
 318   IN UINTN                EndParameterNumber,
 319   IN CONST END_TAG_TYPE   OperatorToUse,
 320   IN CONST BOOLEAN        CaseInsensitive,
 321   IN CONST BOOLEAN        ForceStringCompare
 322   )
 323 {
 324   EFI_STATUS              Status;
 325   BOOLEAN                 OperationResult;
 326   BOOLEAN                 NotPresent;
 327   CHAR16                  *StatementWalker;
 328   BIN_OPERATOR_TYPE       BinOp;
 329   CHAR16                  *Compare1;
 330   CHAR16                  *Compare2;
 331   CHAR16                  HexString[20];
 332   CHAR16                  *TempSpot;
 333
 334   ASSERT((END_TAG_TYPE)OperatorToUse != END_TAG_THEN);
 335
 336   Status          = EFI_SUCCESS;
 337   BinOp           = OPERATOR_MAX;
 338   OperationResult = FALSE;
 339   StatementWalker = gEfiShellParametersProtocol->Argv[StartParameterNumber];
 340   if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"not")) {
 341     NotPresent      = TRUE;
 342     StatementWalker = gEfiShellParametersProtocol->Argv[++StartParameterNumber];
 343   } else {
 344     NotPresent = FALSE;
 345   }
 346
 347   //
 348   // now check for 'boolfunc' operators
 349   //
 350   if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"isint")) {
 351     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && StatementWalker[StrLen(StatementWalker)-1] == L')') {
 352       StatementWalker[StrLen(StatementWalker)-1] = CHAR_NULL;
 353       OperationResult = ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE);
 354     } else {
 355       Status = EFI_INVALID_PARAMETER;
 356       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"isint");
 357     }
 358   } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"exists") || IsNextFragment((CONST CHAR16**)(&StatementWalker), L"exist")) {
 359     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && StatementWalker[StrLen(StatementWalker)-1] == L')') {
 360       StatementWalker[StrLen(StatementWalker)-1] = CHAR_NULL;
 361       //
 362       // is what remains a file in CWD???
 363       //
 364       OperationResult = (BOOLEAN)(ShellFileExists(StatementWalker)==EFI_SUCCESS);
 365     } else if (StatementWalker[0] == CHAR_NULL && StartParameterNumber+1 == EndParameterNumber) {
 366       OperationResult = (BOOLEAN)(ShellFileExists(gEfiShellParametersProtocol->Argv[++StartParameterNumber])==EFI_SUCCESS);
 367     } else {
 368       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"exist(s)");
 369       Status = EFI_INVALID_PARAMETER;
 370     }
 371   } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"available")) {
 372     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && StatementWalker[StrLen(StatementWalker)-1] == L')') {
 373       StatementWalker[StrLen(StatementWalker)-1] = CHAR_NULL;
 374       //
 375       // is what remains a file in the CWD or path???
 376       //
 377       OperationResult = (BOOLEAN)(ShellIsFileInPath(StatementWalker)==EFI_SUCCESS);
 378     } else {
 379       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"available");
 380       Status = EFI_INVALID_PARAMETER;
 381     }
 382   } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"profile")) {
 383     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && StatementWalker[StrLen(StatementWalker)-1] == L')') {
 384       //
 385       // Chop off that ')'
 386       //
 387       StatementWalker[StrLen(StatementWalker)-1] = CHAR_NULL;
 388       OperationResult = IsValidProfile(StatementWalker);
 389     } else {
 390       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"profile");
 391       Status = EFI_INVALID_PARAMETER;
 392     }
 393   } else if (StartParameterNumber+1 >= EndParameterNumber) {
 394       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, gEfiShellParametersProtocol->Argv[StartParameterNumber]);
 395       Status = EFI_INVALID_PARAMETER;
 396   } else {
 397     //
 398     // must be 'item binop item' style
 399     //
 400     Compare1 = NULL;
 401     Compare2 = NULL;
 402     BinOp    = OPERATOR_MAX;
 403
 404     //
 405     // get the first item
 406     //
 407     StatementWalker = gEfiShellParametersProtocol->Argv[StartParameterNumber];
 408     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"efierror")) {
 409       TempSpot = StrStr(StatementWalker, L")");
 410       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 411         *TempSpot = CHAR_NULL;
 412         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 413           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT);
 414           ASSERT(Compare1 == NULL);
 415           Compare1 = StrnCatGrow(&Compare1, NULL, HexString, 0);
 416           StatementWalker += StrLen(StatementWalker) + 1;
 417         } else {
 418           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"efierror");
 419           Status = EFI_INVALID_PARAMETER;
 420         }
 421       } else {
 422         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"efierror");
 423         Status = EFI_INVALID_PARAMETER;
 424       }
 425     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"pierror")) {
 426       TempSpot = StrStr(StatementWalker, L")");
 427       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 428         *TempSpot = CHAR_NULL;
 429         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 430           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT|(MAX_BIT>>2));
 431           ASSERT(Compare1 == NULL);
 432           Compare1 = StrnCatGrow(&Compare1, NULL, HexString, 0);
 433           StatementWalker += StrLen(StatementWalker) + 1;
 434         } else {
 435           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"pierror");
 436           Status = EFI_INVALID_PARAMETER;
 437         }
 438       } else {
 439         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"pierror");
 440         Status = EFI_INVALID_PARAMETER;
 441       }
 442     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"oemerror")) {
 443       TempSpot = StrStr(StatementWalker, L")");
 444       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 445         TempSpot = CHAR_NULL;
 446         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 447           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT|(MAX_BIT>>1));
 448           ASSERT(Compare1 == NULL);
 449           Compare1 = StrnCatGrow(&Compare1, NULL, HexString, 0);
 450           StatementWalker += StrLen(StatementWalker) + 1;
 451         } else {
 452           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"oemerror");
 453           Status = EFI_INVALID_PARAMETER;
 454         }
 455       } else {
 456         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"oemerror");
 457         Status = EFI_INVALID_PARAMETER;
 458       }
 459     } else {
 460       ASSERT(Compare1 == NULL);
 461       if (EndParameterNumber - StartParameterNumber > 2) {
 462           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_STARTING), gShellLevel1HiiHandle, gEfiShellParametersProtocol->Argv[StartParameterNumber+2]);
 463           Status = EFI_INVALID_PARAMETER;
 464       } else {
 465         //
 466         // must be a raw string
 467         //
 468         Compare1 = StrnCatGrow(&Compare1, NULL, StatementWalker, 0);
 469       }
 470     }
 471
 472     //
 473     // get the operator
 474     //
 475     ASSERT(StartParameterNumber+1<EndParameterNumber);
 476     StatementWalker = gEfiShellParametersProtocol->Argv[StartParameterNumber+1];
 477     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"gt")) {
 478       BinOp = OPERATOR_GT;
 479     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"lt")) {
 480       BinOp = OPERATOR_LT;
 481     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"eq")) {
 482       BinOp = OPERATOR_EQ;
 483     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"ne")) {
 484       BinOp = OPERATOR_NE;
 485     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"ge")) {
 486       BinOp = OPERATOR_GE;
 487     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"le")) {
 488       BinOp = OPERATOR_LE;
 489     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"==")) {
 490       BinOp = OPERATOR_EQ;
 491     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"ugt")) {
 492       BinOp = OPERATOR_UGT;
 493     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"ult")) {
 494       BinOp = OPERATOR_ULT;
 495     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"uge")) {
 496       BinOp = OPERATOR_UGE;
 497     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"ule")) {
 498       BinOp = OPERATOR_ULE;
 499     } else {
 500       ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_INVALID_BINOP), gShellLevel1HiiHandle, StatementWalker);
 501       Status = EFI_INVALID_PARAMETER;
 502     }
 503
 504     //
 505     // get the second item
 506     //
 507     ASSERT(StartParameterNumber+2<=EndParameterNumber);
 508     StatementWalker = gEfiShellParametersProtocol->Argv[StartParameterNumber+2];
 509     if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"efierror")) {
 510       TempSpot = StrStr(StatementWalker, L")");
 511       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 512         TempSpot = CHAR_NULL;
 513         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 514           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT);
 515           ASSERT(Compare2 == NULL);
 516           Compare2 = StrnCatGrow(&Compare2, NULL, HexString, 0);
 517           StatementWalker += StrLen(StatementWalker) + 1;
 518         } else {
 519           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"efierror");
 520           Status = EFI_INVALID_PARAMETER;
 521         }
 522       } else {
 523         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"efierror");
 524         Status = EFI_INVALID_PARAMETER;
 525       }
 526     //
 527     // can this be collapsed into the above?
 528     //
 529     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"pierror")) {
 530       TempSpot = StrStr(StatementWalker, L")");
 531       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 532         TempSpot = CHAR_NULL;
 533         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 534           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT|(MAX_BIT>>2));
 535           ASSERT(Compare2 == NULL);
 536           Compare2 = StrnCatGrow(&Compare2, NULL, HexString, 0);
 537           StatementWalker += StrLen(StatementWalker) + 1;
 538         } else {
 539           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"pierror");
 540           Status = EFI_INVALID_PARAMETER;
 541         }
 542       } else {
 543         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"pierror");
 544         Status = EFI_INVALID_PARAMETER;
 545       }
 546     } else if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"oemerror")) {
 547       TempSpot = StrStr(StatementWalker, L")");
 548       if (IsNextFragment((CONST CHAR16**)(&StatementWalker), L"(") && TempSpot != NULL) {
 549         TempSpot = CHAR_NULL;
 550         if (ShellIsHexOrDecimalNumber(StatementWalker, FALSE, FALSE)) {
 551           UnicodeSPrint(HexString, sizeof(HexString), L"0x%x", ShellStrToUintn(StatementWalker)|MAX_BIT|(MAX_BIT>>1));
 552           ASSERT(Compare2 == NULL);
 553           Compare2 = StrnCatGrow(&Compare2, NULL, HexString, 0);
 554           StatementWalker += StrLen(StatementWalker) + 1;
 555         } else {
 556           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"oemerror");
 557           Status = EFI_INVALID_PARAMETER;
 558         }
 559       } else {
 560         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_IN), gShellLevel1HiiHandle, L"oemerror");
 561         Status = EFI_INVALID_PARAMETER;
 562       }
 563     } else {
 564       //
 565       // must be a raw string
 566       //
 567       ASSERT(Compare2 == NULL);
 568       Compare2 = StrnCatGrow(&Compare2, NULL, StatementWalker, 0);
 569     }
 570
 571     if (Compare1 != NULL && Compare2 != NULL && BinOp != OPERATOR_MAX) {
 572       OperationResult = TestOperation(Compare1, Compare2, BinOp, CaseInsensitive, ForceStringCompare);
 573     }
 574
 575     SHELL_FREE_NON_NULL(Compare1);
 576     SHELL_FREE_NON_NULL(Compare2);
 577   }
 578
 579   //
 580   // done processing do result...
 581   //
 582
 583   if (!EFI_ERROR(Status)) {
 584     if (NotPresent) {
 585       OperationResult = (BOOLEAN)(!OperationResult);
 586     }
 587     switch(OperatorToUse) {
 588       case END_TAG_OR:
 589         *PassingState = (BOOLEAN)(*PassingState || OperationResult);
 590         break;
 591       case END_TAG_AND:
 592         *PassingState = (BOOLEAN)(*PassingState && OperationResult);
 593         break;
 594       case END_TAG_MAX:
 595         *PassingState = (BOOLEAN)(OperationResult);
 596         break;
 597       default:
 598         ASSERT(FALSE);
 599     }
 600   }
 601   return (Status);
 602 }
 603
 604 BOOLEAN
 605 EFIAPI
 606 BuildNextStatement (
 607   IN UINTN          ParameterNumber,
 608   OUT UINTN         *EndParameter,
 609   OUT END_TAG_TYPE  *EndTag
 610   )
 611 {
 612   CHAR16    *Buffer;
 613   UINTN     BufferSize;
 614
 615   *EndTag = END_TAG_MAX;
 616
 617   for(Buffer = NULL, BufferSize = 0
 618     ; ParameterNumber < gEfiShellParametersProtocol->Argc
 619     ; ParameterNumber++
 620    ) {
 621     if (gUnicodeCollation->StriColl(
 622           gUnicodeCollation,
 623           gEfiShellParametersProtocol->Argv[ParameterNumber],
 624           L"or") == 0) {
 625       *EndParameter = ParameterNumber - 1;
 626       *EndTag = END_TAG_OR;
 627       break;
 628     } else if (gUnicodeCollation->StriColl(
 629           gUnicodeCollation,
 630           gEfiShellParametersProtocol->Argv[ParameterNumber],
 631           L"and") == 0) {
 632       *EndParameter = ParameterNumber - 1;
 633       *EndTag = END_TAG_AND;
 634       break;
 635     } else if (gUnicodeCollation->StriColl(
 636           gUnicodeCollation,
 637           gEfiShellParametersProtocol->Argv[ParameterNumber],
 638           L"then") == 0) {
 639       *EndParameter = ParameterNumber - 1;
 640       *EndTag = END_TAG_THEN;
 641       break;
 642     }
 643   }
 644   if (*EndTag == END_TAG_MAX) {
 645     return (FALSE);
 646   }
 647   return (TRUE);
 648 }
 649
 650 BOOLEAN
 651 EFIAPI
 652 MoveToTagSpecial (
 653   IN SCRIPT_FILE                *ScriptFile
 654   )
 655 {
 656   SCRIPT_COMMAND_LIST *CommandNode;
 657   BOOLEAN             Found;
 658   UINTN               TargetCount;
 659   CHAR16              *CommandName;
 660   CHAR16              *CommandWalker;
 661   CHAR16              *TempLocation;
 662
 663   TargetCount         = 1;
 664   Found               = FALSE;
 665
 666   if (ScriptFile == NULL) {
 667     return FALSE;
 668   }
 669
 670   for (CommandNode = (SCRIPT_COMMAND_LIST *)GetNextNode(&ScriptFile->CommandList, &ScriptFile->CurrentCommand->Link), Found = FALSE
 671     ;  !IsNull(&ScriptFile->CommandList, &CommandNode->Link) && !Found
 672     ;  CommandNode = (SCRIPT_COMMAND_LIST *)GetNextNode(&ScriptFile->CommandList, &CommandNode->Link)
 673    ){
 674
 675     //
 676     // get just the first part of the command line...
 677     //
 678     CommandName   = NULL;
 679     CommandName   = StrnCatGrow(&CommandName, NULL, CommandNode->Cl, 0);
 680     CommandWalker = CommandName;
 681     while (CommandWalker[0] == L' ') {
 682       CommandWalker++;
 683     }
 684     TempLocation  = StrStr(CommandWalker, L" ");
 685
 686     if (TempLocation != NULL) {
 687       *TempLocation = CHAR_NULL;
 688     }
 689
 690     //
 691     // did we find a nested item ?
 692     //
 693     if (gUnicodeCollation->StriColl(
 694         gUnicodeCollation,
 695         (CHAR16*)CommandWalker,
 696         L"If") == 0) {
 697       TargetCount++;
 698     } else if (TargetCount == 1 && gUnicodeCollation->StriColl(
 699         gUnicodeCollation,
 700         (CHAR16*)CommandWalker,
 701         (CHAR16*)L"else") == 0) {
 702       //
 703       // else can only decrement the last part... not an nested if
 704       // hence the TargetCount compare added
 705       //
 706       TargetCount--;
 707     } else if (gUnicodeCollation->StriColl(
 708         gUnicodeCollation,
 709         (CHAR16*)CommandWalker,
 710         (CHAR16*)L"endif") == 0) {
 711       TargetCount--;
 712     }
 713     if (TargetCount == 0) {
 714       ScriptFile->CurrentCommand = (SCRIPT_COMMAND_LIST *)GetNextNode(&ScriptFile->CommandList, &CommandNode->Link);
 715       Found = TRUE;
 716     }
 717
 718     //
 719     // Free the memory for this loop...
 720     //
 721     SHELL_FREE_NON_NULL(CommandName);
 722   }
 723   return (Found);
 724 }
 725
 726 EFI_STATUS
 727 EFIAPI
 728 PerformResultOperation (
 729   IN CONST BOOLEAN Result
 730   )
 731 {
 732   if (Result || MoveToTagSpecial(ShellCommandGetCurrentScriptFile())) {
 733     return (EFI_SUCCESS);
 734   }
 735   return (EFI_NOT_FOUND);
 736 }
 737
 738 /**
 739   Function for 'if' command.
 740
 741   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 742   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 743 **/
 744 SHELL_STATUS
 745 EFIAPI
 746 ShellCommandRunIf (
 747   IN EFI_HANDLE        ImageHandle,
 748   IN EFI_SYSTEM_TABLE  *SystemTable
 749   )
 750 {
 751   EFI_STATUS          Status;
 752   SHELL_STATUS        ShellStatus;
 753   BOOLEAN             CaseInsensitive;
 754   BOOLEAN             ForceString;
 755   UINTN               CurrentParameter;
 756   UINTN               EndParameter;
 757   BOOLEAN             CurrentValue;
 758   END_TAG_TYPE        Ending;
 759   END_TAG_TYPE        PreviousEnding;
 760
 761
 762   Status = CommandInit();
 763   ASSERT_EFI_ERROR(Status);
 764
 765   if (!gEfiShellProtocol->BatchIsActive()) {
 766     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_NO_SCRIPT), gShellLevel1HiiHandle, L"If");
 767     return (SHELL_UNSUPPORTED);
 768   }
 769
 770   if (gEfiShellParametersProtocol->Argc < 3) {
 771     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_FEW), gShellLevel1HiiHandle);
 772     return (SHELL_INVALID_PARAMETER);
 773   }
 774
 775   //
 776   // Make sure that an End exists.
 777   //
 778   if (!MoveToTag(GetNextNode, L"endif", L"if", NULL, ShellCommandGetCurrentScriptFile(), TRUE, TRUE, FALSE)) {
 779     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"EnfIf", L"If", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 780     return (SHELL_DEVICE_ERROR);
 781   }
 782
 783   //
 784   // initialize the shell lib (we must be in non-auto-init...)
 785   //
 786   Status = ShellInitialize();
 787   ASSERT_EFI_ERROR(Status);
 788
 789   CurrentParameter    = 1;
 790   EndParameter        = 0;
 791
 792   if (gUnicodeCollation->StriColl(
 793         gUnicodeCollation,
 794         gEfiShellParametersProtocol->Argv[1],
 795         L"/i") == 0 ||
 796       gUnicodeCollation->StriColl(
 797         gUnicodeCollation,
 798         gEfiShellParametersProtocol->Argv[2],
 799         L"/i") == 0 ||
 800       (gEfiShellParametersProtocol->Argc > 3 && gUnicodeCollation->StriColl(
 801         gUnicodeCollation,
 802         gEfiShellParametersProtocol->Argv[3],
 803         L"/i") == 0)) {
 804     CaseInsensitive = TRUE;
 805     CurrentParameter++;
 806   } else {
 807     CaseInsensitive = FALSE;
 808   }
 809   if (gUnicodeCollation->StriColl(
 810         gUnicodeCollation,
 811         gEfiShellParametersProtocol->Argv[1],
 812         L"/s") == 0 ||
 813       gUnicodeCollation->StriColl(
 814         gUnicodeCollation,
 815         gEfiShellParametersProtocol->Argv[2],
 816         L"/s") == 0 ||
 817       (gEfiShellParametersProtocol->Argc > 3 && gUnicodeCollation->StriColl(
 818         gUnicodeCollation,
 819         gEfiShellParametersProtocol->Argv[3],
 820         L"/s") == 0)) {
 821     ForceString     = TRUE;
 822     CurrentParameter++;
 823   } else {
 824     ForceString     = FALSE;
 825   }
 826
 827   for ( ShellStatus = SHELL_SUCCESS, CurrentValue = FALSE, Ending = END_TAG_MAX
 828       ; CurrentParameter < gEfiShellParametersProtocol->Argc && ShellStatus == SHELL_SUCCESS
 829       ; CurrentParameter++) {
 830     if (gUnicodeCollation->StriColl(
 831           gUnicodeCollation,
 832           gEfiShellParametersProtocol->Argv[CurrentParameter],
 833           L"then") == 0) {
 834       //
 835       // we are at the then
 836       //
 837       if (CurrentParameter+1 != gEfiShellParametersProtocol->Argc) {
 838         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_TEXT_AFTER_THEN), gShellLevel1HiiHandle);
 839         ShellStatus = SHELL_INVALID_PARAMETER;
 840       } else {
 841         Status = PerformResultOperation(CurrentValue);
 842         if (EFI_ERROR(Status)) {
 843           ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_AFTER_BAD), gShellLevel1HiiHandle, gEfiShellParametersProtocol->Argv[CurrentParameter]);
 844           ShellStatus = SHELL_INVALID_PARAMETER;
 845         }
 846       }
 847     } else {
 848       PreviousEnding = Ending;
 849       //
 850       // build up the next statement for analysis
 851       //
 852       if (!BuildNextStatement(CurrentParameter, &EndParameter, &Ending)) {
 853         ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"Then", L"If", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 854         ShellStatus = SHELL_INVALID_PARAMETER;
 855       } else {
 856         //
 857         // Analyze the statement
 858         //
 859         Status = ProcessStatement(&CurrentValue, CurrentParameter, EndParameter, PreviousEnding, CaseInsensitive, ForceString);
 860         if (EFI_ERROR(Status)) {
 861 //          ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_STARTING), gShellLevel1HiiHandle, gEfiShellParametersProtocol->Argv[CurrentParameter]);
 862           ShellStatus = SHELL_INVALID_PARAMETER;
 863         } else {
 864           //
 865           // Optomize to get out of the loop early...
 866           //
 867           if ((Ending == END_TAG_OR && CurrentValue) || (Ending == END_TAG_AND && !CurrentValue)) {
 868             Status = PerformResultOperation(CurrentValue);
 869             if (EFI_ERROR(Status)) {
 870               ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_AFTER_BAD), gShellLevel1HiiHandle, gEfiShellParametersProtocol->Argv[CurrentParameter]);
 871               ShellStatus = SHELL_INVALID_PARAMETER;
 872             }
 873             break;
 874           }
 875         }
 876       }
 877       if (ShellStatus == SHELL_SUCCESS){
 878         CurrentParameter = EndParameter;
 879         //
 880         // Skip over the or or and parameter.
 881         //
 882         if (Ending == END_TAG_OR || Ending == END_TAG_AND) {
 883           CurrentParameter++;
 884         }
 885       }
 886     }
 887   }
 888   return (ShellStatus);
 889 }
 890
 891 /**
 892   Function for 'else' command.
 893
 894   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 895   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 896 **/
 897 SHELL_STATUS
 898 EFIAPI
 899 ShellCommandRunElse (
 900   IN EFI_HANDLE        ImageHandle,
 901   IN EFI_SYSTEM_TABLE  *SystemTable
 902   )
 903 {
 904   ASSERT_EFI_ERROR(CommandInit());
 905
 906   if (gEfiShellParametersProtocol->Argc > 1) {
 907     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel1HiiHandle);
 908     return (SHELL_INVALID_PARAMETER);
 909   }
 910
 911   if (!gEfiShellProtocol->BatchIsActive()) {
 912     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_NO_SCRIPT), gShellLevel1HiiHandle, L"Else");
 913     return (SHELL_UNSUPPORTED);
 914   }
 915
 916
 917   if (!MoveToTag(GetPreviousNode, L"if", L"endif", NULL, ShellCommandGetCurrentScriptFile(), FALSE, TRUE, FALSE)) {
 918     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"If", L"Else", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 919     return (SHELL_DEVICE_ERROR);
 920   }
 921   if (!MoveToTag(GetPreviousNode, L"if", L"else", NULL, ShellCommandGetCurrentScriptFile(), FALSE, TRUE, FALSE)) {
 922     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"If", L"Else", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 923     return (SHELL_DEVICE_ERROR);
 924   }
 925
 926   if (!MoveToTag(GetNextNode, L"endif", L"if", NULL, ShellCommandGetCurrentScriptFile(), FALSE, FALSE, FALSE)) {
 927     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"EndIf", "Else", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 928     return (SHELL_DEVICE_ERROR);
 929   }
 930
 931   return (SHELL_SUCCESS);
 932 }
 933
 934 /**
 935   Function for 'endif' command.
 936
 937   @param[in] ImageHandle  Handle to the Image (NULL if Internal).
 938   @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
 939 **/
 940 SHELL_STATUS
 941 EFIAPI
 942 ShellCommandRunEndIf (
 943   IN EFI_HANDLE        ImageHandle,
 944   IN EFI_SYSTEM_TABLE  *SystemTable
 945   )
 946 {
 947   ASSERT_EFI_ERROR(CommandInit());
 948
 949   if (gEfiShellParametersProtocol->Argc > 1) {
 950     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel1HiiHandle);
 951     return (SHELL_INVALID_PARAMETER);
 952   }
 953
 954   if (!gEfiShellProtocol->BatchIsActive()) {
 955     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_NO_SCRIPT), gShellLevel1HiiHandle, L"Endif");
 956     return (SHELL_UNSUPPORTED);
 957   }
 958
 959   if (!MoveToTag(GetPreviousNode, L"if", L"endif", NULL, ShellCommandGetCurrentScriptFile(), FALSE, TRUE, FALSE)) {
 960     ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_SYNTAX_NO_MATCHING), gShellLevel1HiiHandle, L"If", L"EndIf", ShellCommandGetCurrentScriptFile()->CurrentCommand->Line);
 961     return (SHELL_DEVICE_ERROR);
 962   }
 963
 964   return (SHELL_SUCCESS);
 965 }