Example #1
0
/**
  Determine if String is a valid representation for a time or date.

  @param[in] String     The pointer to the string to test.
  @param[in] Char       The delimeter character.
  @param[in] Min        The minimum value allowed.
  @param[in] Max        The maximum value allowed.
  @param[in] MinusOk    Whether negative numbers are permitted.

  @retval TRUE    String is a valid representation.
  @retval FALSE   String is invalid.
**/
BOOLEAN
EFIAPI
InternalIsTimeLikeString (
  IN CONST CHAR16   *String,
  IN CONST CHAR16   Char,
  IN CONST UINTN    Min,
  IN CONST UINTN    Max,
  IN CONST BOOLEAN  MinusOk
  )
{
  UINTN Count;
  Count = 0;

  if (MinusOk) {
    //
    // A single minus is ok.
    //
    if (*String == L'-') {
      String++;
    }
  }

  //
  // the first char must be numeric.
  //
  if (!ShellIsDecimalDigitCharacter(*String)) {
    return (FALSE);
  }
  //
  // loop through the characters and use the lib function
  //
  for ( ; String != NULL && *String != CHAR_NULL ; String++){
    if (*String == Char) {
      Count++;
      if (Count > Max) {
        return (FALSE);
      }
      continue;
    }
    if (!ShellIsDecimalDigitCharacter(*String)) {
      return (FALSE);
    }
  }
  if (Count < Min) {
    return (FALSE);
  }
  return (TRUE);
}
Example #2
0
/**
  Determine if a valid string is a valid number for the 'for' command.

  @param[in] Number The pointer to the string representation of the number to test.

  @retval TRUE    The number is valid.
  @retval FALSE   The number is not valid.
**/
BOOLEAN
EFIAPI
ShellIsValidForNumber (
  IN CONST CHAR16 *Number
  )
{
  if (Number == NULL || *Number == CHAR_NULL) {
    return (FALSE);
  }

  if (*Number == L'-') {
    Number++;
  }

  if (StrLen(Number) == 0) {
    return (FALSE);
  }

  if (StrLen(Number) >= 7) {
    if ((StrStr(Number, L" ") == NULL) || (((StrStr(Number, L" ") != NULL) && (StrStr(Number, L" ") - Number) >= 7))) {
      return (FALSE);
    }
  }

  if (!ShellIsDecimalDigitCharacter(*Number)) {
    return (FALSE);
  }

  return (TRUE);
}
Example #3
0
File: Cls.c Project: jian-tian/UEFI
/**
  Function for 'cls' command.

  @param[in] ImageHandle  Handle to the Image (NULL if Internal).
  @param[in] SystemTable  Pointer to the System Table (NULL if Internal).
**/
SHELL_STATUS
EFIAPI
ShellCommandRunCls (
    IN EFI_HANDLE        ImageHandle,
    IN EFI_SYSTEM_TABLE  *SystemTable
)
{
    EFI_STATUS    Status;
    LIST_ENTRY    *Package;
    UINTN         Background;
    UINTN         ForeColor;
    CHAR16        *ProblemParam;
    SHELL_STATUS  ShellStatus;
    CONST CHAR16  *Param1;

    //
    // Initialize variables
    //
    ShellStatus   = SHELL_SUCCESS;
    ProblemParam  = NULL;
    Background    = 0;

    //
    // initialize the shell lib (we must be in non-auto-init...)
    //
    Status = ShellInitialize();
    ASSERT_EFI_ERROR(Status);

    //
    // parse the command line
    //
    Status = ShellCommandLineParse (EmptyParamList, &Package, &ProblemParam, TRUE);
    if (EFI_ERROR(Status)) {
        if (Status == EFI_VOLUME_CORRUPTED && ProblemParam != NULL) {
            ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel3HiiHandle, ProblemParam);
            FreePool(ProblemParam);
            ShellStatus = SHELL_INVALID_PARAMETER;
        } else {
            ASSERT(FALSE);
        }
    } else {
        //
        // check for "-?"
        //
        if (ShellCommandLineGetFlag(Package, L"-?")) {
            ASSERT(FALSE);
        } else {
            //
            // If there are 0 value parameters, clear sceen
            //
            Param1 = ShellCommandLineGetRawValue(Package, 1);
            if (Param1 == NULL) {
                //
                // clear screen
                //
                gST->ConOut->ClearScreen (gST->ConOut);
            } else if (ShellCommandLineGetCount(Package) > 2) {
                ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_TOO_MANY), gShellLevel3HiiHandle);
                ShellStatus = SHELL_INVALID_PARAMETER;
            } else {
                if (ShellStrToUintn(Param1) > 7 || StrLen(Param1) > 1 || !ShellIsDecimalDigitCharacter(*Param1)) {
                    ShellPrintHiiEx(-1, -1, NULL, STRING_TOKEN (STR_GEN_PROBLEM), gShellLevel3HiiHandle, Param1);
                    ShellStatus = SHELL_INVALID_PARAMETER;
                } else {
                    switch (ShellStrToUintn(Param1)) {
                    case 0:
                        Background = EFI_BACKGROUND_BLACK;
                        break;
                    case 1:
                        Background = EFI_BACKGROUND_BLUE;
                        break;
                    case 2:
                        Background = EFI_BACKGROUND_GREEN;
                        break;
                    case 3:
                        Background = EFI_BACKGROUND_CYAN;
                        break;
                    case 4:
                        Background = EFI_BACKGROUND_RED;
                        break;
                    case 5:
                        Background = EFI_BACKGROUND_MAGENTA;
                        break;
                    case 6:
                        Background = EFI_BACKGROUND_BROWN;
                        break;
                    case 7:
                        Background = EFI_BACKGROUND_LIGHTGRAY;
                        break;
                    }
                    ForeColor = (~ShellStrToUintn(Param1)) & 0xF;
                    Status = gST->ConOut->SetAttribute (gST->ConOut, (ForeColor | Background) & 0x7F );
                    ASSERT_EFI_ERROR(Status);
                    Status = gST->ConOut->ClearScreen (gST->ConOut);
                    ASSERT_EFI_ERROR(Status);
                }
            }
        }
    }
    //
    // free the command line package
    //
    ShellCommandLineFreeVarList (Package);

    //
    // return the status
    //
    return (ShellStatus);
}