MdeModulePkg: Replace BSD License with BSD+Patent License

[mirror_edk2.git] / MdeModulePkg / Universal / EbcDxe / EbcDebugger / EdbSupportUI.c

/** @file\r
\r
Copyright (c) 2007, Intel Corporation. All rights reserved.<BR>\r
SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
\r
**/\r
\r
#include "Edb.h"\r
\r
/**\r
  Set the current coordinates of the cursor position.\r
\r
  @param  ConOut        Point to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.\r
  @param  Column        The position to set the cursor to.\r
  @param  Row           The position to set the cursor to.\r
  @param  LineLength    Length of a line.\r
  @param  TotalRow      Total row of a screen.\r
  @param  Str           Point to the string.\r
  @param  StrPos        The position of the string.\r
  @param  Len           The length of the string.\r
\r
**/\r
VOID\r
EFIAPI\r
SetCursorPosition (\r
  IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL  *ConOut,\r
  IN  UINTN                           Column,\r
  IN  INTN                            Row,\r
  IN  UINTN                           LineLength,\r
  IN  UINTN                           TotalRow,\r
  IN  CHAR16                          *Str,\r
  IN  UINTN                           StrPos,\r
  IN  UINTN                           Len\r
  );\r
\r
/**\r
\r
  Function waits for a given event to fire, or for an optional timeout to expire.\r
\r
  @param  Event            - The event to wait for\r
  @param  Timeout          - An optional timeout value in 100 ns units.\r
\r
  @retval EFI_SUCCESS       - Event fired before Timeout expired.\r
  @retval EFI_TIME_OUT     - Timout expired before Event fired..\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
WaitForSingleEvent (\r
  IN EFI_EVENT                  Event,\r
  IN UINT64                     Timeout OPTIONAL\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Index;\r
  EFI_EVENT   TimerEvent;\r
  EFI_EVENT   WaitList[2];\r
\r
  if (Timeout != 0) {\r
    //\r
    // Create a timer event\r
    //\r
    Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);\r
    if (!EFI_ERROR (Status)) {\r
      //\r
      // Set the timer event\r
      //\r
      gBS->SetTimer (\r
            TimerEvent,\r
            TimerRelative,\r
            Timeout\r
            );\r
\r
      //\r
      // Wait for the original event or the timer\r
      //\r
      WaitList[0] = Event;\r
      WaitList[1] = TimerEvent;\r
      Status      = gBS->WaitForEvent (2, WaitList, &Index);\r
      gBS->CloseEvent (TimerEvent);\r
\r
      //\r
      // If the timer expired, change the return to timed out\r
      //\r
      if (!EFI_ERROR (Status) && Index == 1) {\r
        Status = EFI_TIMEOUT;\r
      }\r
    }\r
  } else {\r
    //\r
    // No timeout... just wait on the event\r
    //\r
    Status = gBS->WaitForEvent (1, &Event, &Index);\r
    ASSERT (!EFI_ERROR (Status));\r
    ASSERT (Index == 0);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
\r
  Move the cursor position one character backward.\r
\r
  @param  LineLength       Length of a line. Get it by calling QueryMode\r
  @param  Column           Current column of the cursor position\r
  @param  Row              Current row of the cursor position\r
\r
**/\r
VOID\r
EFIAPI\r
ConMoveCursorBackward (\r
  IN     UINTN                   LineLength,\r
  IN OUT UINTN                   *Column,\r
  IN OUT UINTN                   *Row\r
  )\r
{\r
  ASSERT (Column != NULL);\r
  ASSERT (Row != NULL);\r
  //\r
  // If current column is 0, move to the last column of the previous line,\r
  // otherwise, just decrement column.\r
  //\r
  if (*Column == 0) {\r
    (*Column) = LineLength - 1;\r
    //\r
    //   if (*Row > 0) {\r
    //\r
    (*Row)--;\r
    //\r
    // }\r
    //\r
  } else {\r
    (*Column)--;\r
  }\r
}\r
\r
/**\r
\r
  Move the cursor position one character backward.\r
\r
  @param  LineLength       Length of a line. Get it by calling QueryMode\r
  @param  TotalRow         Total row of a screen, get by calling QueryMode\r
  @param  Column           Current column of the cursor position\r
  @param  Row              Current row of the cursor position\r
\r
**/\r
VOID\r
EFIAPI\r
ConMoveCursorForward (\r
  IN     UINTN                   LineLength,\r
  IN     UINTN                   TotalRow,\r
  IN OUT UINTN                   *Column,\r
  IN OUT UINTN                   *Row\r
  )\r
{\r
  ASSERT (Column != NULL);\r
  ASSERT (Row != NULL);\r
  //\r
  // If current column is at line end, move to the first column of the nest\r
  // line, otherwise, just increment column.\r
  //\r
  (*Column)++;\r
  if (*Column >= LineLength) {\r
    (*Column) = 0;\r
    if ((*Row) < TotalRow - 1) {\r
      (*Row)++;\r
    }\r
  }\r
}\r
\r
CHAR16 mBackupSpace[EFI_DEBUG_INPUS_BUFFER_SIZE];\r
CHAR16 mInputBufferHistory[EFI_DEBUG_INPUS_BUFFER_SIZE];\r
\r
/**\r
\r
  Get user input.\r
\r
  @param  Prompt       The prompt string.\r
  @param  InStr        Point to the input string.\r
  @param  StrLength    The max length of string user can input.\r
\r
**/\r
VOID\r
EFIAPI\r
Input (\r
  IN CHAR16    *Prompt OPTIONAL,\r
  OUT CHAR16   *InStr,\r
  IN UINTN     StrLength\r
  )\r
{\r
  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL     *ConOut;\r
  EFI_SIMPLE_TEXT_INPUT_PROTOCOL      *ConIn;\r
  BOOLEAN       Done;\r
  UINTN         Column;\r
  UINTN         Row;\r
  UINTN         StartColumn;\r
  UINTN         Update;\r
  UINTN         Delete;\r
  UINTN         Len;\r
  UINTN         StrPos;\r
  UINTN         Index;\r
  UINTN         LineLength;\r
  UINTN         TotalRow;\r
  UINTN         SkipLength;\r
  UINTN         OutputLength;\r
  UINTN         TailRow;\r
  UINTN         TailColumn;\r
  EFI_INPUT_KEY Key;\r
  BOOLEAN       InsertMode;\r
  BOOLEAN       NeedAdjust;\r
  UINTN         SubIndex;\r
  CHAR16        *CommandStr;\r
\r
  ConOut = gST->ConOut;\r
  ConIn = gST->ConIn;\r
\r
  ASSERT (ConOut != NULL);\r
  ASSERT (ConIn != NULL);\r
  ASSERT (InStr != NULL);\r
\r
  if (Prompt != NULL) {\r
    ConOut->OutputString (ConOut, Prompt);\r
  }\r
  //\r
  // Read a line from the console\r
  //\r
  Len           = 0;\r
  StrPos        = 0;\r
  OutputLength  = 0;\r
  Update        = 0;\r
  Delete        = 0;\r
  InsertMode    = TRUE;\r
  NeedAdjust    = FALSE;\r
\r
  //\r
  // If buffer is not large enough to hold a CHAR16, do nothing.\r
  //\r
  if (StrLength < 1) {\r
    return ;\r
  }\r
  //\r
  // Get the screen setting and the current cursor location\r
  //\r
  StartColumn = ConOut->Mode->CursorColumn;\r
  Column      = StartColumn;\r
  Row         = ConOut->Mode->CursorRow;\r
  ConOut->QueryMode (ConOut, ConOut->Mode->Mode, &LineLength, &TotalRow);\r
  if (LineLength == 0) {\r
    return ;\r
  }\r
\r
  SetMem (InStr, StrLength * sizeof (CHAR16), 0);\r
  Done = FALSE;\r
  do {\r
    //\r
    // Read a key\r
    //\r
    WaitForSingleEvent (ConIn->WaitForKey, 0);\r
    ConIn->ReadKeyStroke (ConIn, &Key);\r
\r
    switch (Key.UnicodeChar) {\r
    case CHAR_CARRIAGE_RETURN:\r
      //\r
      // All done, print a newline at the end of the string\r
      //\r
      TailRow     = Row + (Len - StrPos + Column) / LineLength;\r
      TailColumn  = (Len - StrPos + Column) % LineLength;\r
      Done        = TRUE;\r
      break;\r
\r
    case CHAR_BACKSPACE:\r
      if (StrPos != 0) {\r
        //\r
        // If not move back beyond string beginning, move all characters behind\r
        // the current position one character forward\r
        //\r
        StrPos -= 1;\r
        Update  = StrPos;\r
        Delete  = 1;\r
        CopyMem (InStr + StrPos, InStr + StrPos + 1, sizeof (CHAR16) * (Len - StrPos));\r
\r
        //\r
        // Adjust the current column and row\r
        //\r
        ConMoveCursorBackward (LineLength, &Column, &Row);\r
\r
        NeedAdjust = TRUE;\r
      }\r
      break;\r
\r
    default:\r
      if (Key.UnicodeChar >= ' ') {\r
        //\r
        // If we are at the buffer's end, drop the key\r
        //\r
        if (Len == StrLength - 1 && (InsertMode || StrPos == Len)) {\r
          break;\r
        }\r
        //\r
        // If in insert mode, move all characters behind the current position\r
        // one character backward to make space for this character. Then store\r
        // the character.\r
        //\r
        if (InsertMode) {\r
          for (Index = Len; Index > StrPos; Index -= 1) {\r
            InStr[Index] = InStr[Index - 1];\r
          }\r
        }\r
\r
        InStr[StrPos] = Key.UnicodeChar;\r
        Update        = StrPos;\r
\r
        StrPos += 1;\r
        OutputLength = 1;\r
      }\r
      break;\r
\r
    case 0:\r
      switch (Key.ScanCode) {\r
      case SCAN_DELETE:\r
        //\r
        // Move characters behind current position one character forward\r
        //\r
        if (Len != 0) {\r
          Update  = StrPos;\r
          Delete  = 1;\r
          CopyMem (InStr + StrPos, InStr + StrPos + 1, sizeof (CHAR16) * (Len - StrPos));\r
\r
          NeedAdjust = TRUE;\r
        }\r
        break;\r
\r
      case SCAN_LEFT:\r
        //\r
        // Adjust current cursor position\r
        //\r
        if (StrPos != 0) {\r
          StrPos -= 1;\r
          ConMoveCursorBackward (LineLength, &Column, &Row);\r
        }\r
        break;\r
\r
      case SCAN_RIGHT:\r
        //\r
        // Adjust current cursor position\r
        //\r
        if (StrPos < Len) {\r
          StrPos += 1;\r
          ConMoveCursorForward (LineLength, TotalRow, &Column, &Row);\r
        }\r
        break;\r
\r
      case SCAN_HOME:\r
        //\r
        // Move current cursor position to the beginning of the command line\r
        //\r
        Row -= (StrPos + StartColumn) / LineLength;\r
        Column  = StartColumn;\r
        StrPos  = 0;\r
        break;\r
\r
      case SCAN_END:\r
        //\r
        // Move current cursor position to the end of the command line\r
        //\r
        TailRow     = Row + (Len - StrPos + Column) / LineLength;\r
        TailColumn  = (Len - StrPos + Column) % LineLength;\r
        Row         = TailRow;\r
        Column      = TailColumn;\r
        StrPos      = Len;\r
        break;\r
\r
      case SCAN_ESC:\r
        //\r
        // Prepare to clear the current command line\r
        //\r
        InStr[0]  = 0;\r
        Update    = 0;\r
        Delete    = Len;\r
        Row -= (StrPos + StartColumn) / LineLength;\r
        Column        = StartColumn;\r
        OutputLength  = 0;\r
\r
        NeedAdjust = TRUE;\r
        break;\r
\r
      case SCAN_INSERT:\r
        //\r
        // Toggle the SEnvInsertMode flag\r
        //\r
        InsertMode = (BOOLEAN)!InsertMode;\r
        break;\r
\r
      case SCAN_UP:\r
      case SCAN_DOWN:\r
        //\r
        // show history\r
        //\r
        CopyMem (InStr, mInputBufferHistory, StrLength * sizeof(CHAR16));\r
        StrPos       = StrLen (mInputBufferHistory);\r
        Update       = 0;\r
        Delete       = 0;\r
        OutputLength = 0;\r
\r
        TailRow      = Row + (StrPos + StartColumn) / LineLength;\r
        TailColumn   = (StrPos + StartColumn) % LineLength;\r
        Row          = TailRow;\r
        Column       = TailColumn;\r
        NeedAdjust   = FALSE;\r
\r
        ConOut->SetCursorPosition (ConOut, StartColumn, Row);\r
        for (SubIndex = 0; SubIndex < EFI_DEBUG_INPUS_BUFFER_SIZE - (StartColumn - EFI_DEBUG_PROMPT_COLUMN); SubIndex++) {\r
          mBackupSpace[SubIndex] = L' ';\r
        }\r
        EDBPrint (mBackupSpace);\r
        SetMem (mBackupSpace, (EFI_DEBUG_INPUS_BUFFER_SIZE - (StartColumn - EFI_DEBUG_PROMPT_COLUMN)) * sizeof(CHAR16), 0);\r
\r
        ConOut->SetCursorPosition (ConOut, StartColumn, Row);\r
        Len = StrPos;\r
\r
        break;\r
\r
      case SCAN_F1:\r
      case SCAN_F2:\r
      case SCAN_F3:\r
      case SCAN_F4:\r
      case SCAN_F5:\r
      case SCAN_F6:\r
      case SCAN_F7:\r
      case SCAN_F8:\r
      case SCAN_F9:\r
      case SCAN_F10:\r
      case SCAN_F11:\r
      case SCAN_F12:\r
        CommandStr = GetCommandNameByKey (Key);\r
        if (CommandStr != NULL) {\r
          StrnCpyS (InStr, StrLength, CommandStr, StrLength - 1);\r
          return ;\r
        }\r
        break;\r
      }\r
    }\r
\r
    if (Done) {\r
      break;\r
    }\r
    //\r
    // If we need to update the output do so now\r
    //\r
    if (Update != -1) {\r
      if (NeedAdjust) {\r
        ConOut->SetCursorPosition (ConOut, Column, Row);\r
        for (SubIndex = 0; SubIndex < EFI_DEBUG_INPUS_BUFFER_SIZE - (Column - EFI_DEBUG_PROMPT_COLUMN); SubIndex++) {\r
          mBackupSpace[SubIndex] = L' ';\r
        }\r
        EDBPrint (mBackupSpace);\r
        SetMem (mBackupSpace, (EFI_DEBUG_INPUS_BUFFER_SIZE - (Column - EFI_DEBUG_PROMPT_COLUMN)) * sizeof(CHAR16), 0);\r
        ConOut->SetCursorPosition (ConOut, Column, Row);\r
        NeedAdjust = FALSE;\r
      }\r
      EDBPrint (InStr + Update);\r
      Len = StrLen (InStr);\r
\r
      if (Delete != 0) {\r
        SetMem (InStr + Len, Delete * sizeof (CHAR16), 0x00);\r
      }\r
\r
      if (StrPos > Len) {\r
        StrPos = Len;\r
      }\r
\r
      Update = (UINTN) -1;\r
\r
      //\r
      // After using print to reflect newly updates, if we're not using\r
      // BACKSPACE and DELETE, we need to move the cursor position forward,\r
      // so adjust row and column here.\r
      //\r
      if (Key.UnicodeChar != CHAR_BACKSPACE && !(Key.UnicodeChar == 0 && Key.ScanCode == SCAN_DELETE)) {\r
        //\r
        // Calulate row and column of the tail of current string\r
        //\r
        TailRow     = Row + (Len - StrPos + Column + OutputLength) / LineLength;\r
        TailColumn  = (Len - StrPos + Column + OutputLength) % LineLength;\r
\r
        //\r
        // If the tail of string reaches screen end, screen rolls up, so if\r
        // Row does not equal TailRow, Row should be decremented\r
        //\r
        // (if we are recalling commands using UPPER and DOWN key, and if the\r
        // old command is too long to fit the screen, TailColumn must be 79.\r
        //\r
        if (TailColumn == 0 && TailRow >= TotalRow && (UINTN) Row != TailRow) {\r
          Row--;\r
        }\r
        //\r
        // Calculate the cursor position after current operation. If cursor\r
        // reaches line end, update both row and column, otherwise, only\r
        // column will be changed.\r
        //\r
        if (Column + OutputLength >= LineLength) {\r
          SkipLength = OutputLength - (LineLength - Column);\r
\r
          Row += SkipLength / LineLength + 1;\r
          if ((UINTN) Row > TotalRow - 1) {\r
            Row = TotalRow - 1;\r
          }\r
\r
          Column = SkipLength % LineLength;\r
        } else {\r
          Column += OutputLength;\r
        }\r
      }\r
\r
      Delete = 0;\r
    }\r
    //\r
    // Set the cursor position for this key\r
    //\r
    SetCursorPosition (ConOut, Column, Row, LineLength, TotalRow, InStr, StrPos, Len);\r
  } while (!Done);\r
\r
  CopyMem (mInputBufferHistory, InStr, StrLength * sizeof(CHAR16));\r
\r
  //\r
  // Return the data to the caller\r
  //\r
  return ;\r
}\r
\r
/**\r
  Set the current coordinates of the cursor position.\r
\r
  @param  ConOut        Point to EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL.\r
  @param  Column        The position to set the cursor to.\r
  @param  Row           The position to set the cursor to.\r
  @param  LineLength    Length of a line.\r
  @param  TotalRow      Total row of a screen.\r
  @param  Str           Point to the string.\r
  @param  StrPos        The position of the string.\r
  @param  Len           The length of the string.\r
\r
**/\r
VOID\r
EFIAPI\r
SetCursorPosition (\r
  IN  EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut,\r
  IN  UINTN                           Column,\r
  IN  INTN                            Row,\r
  IN  UINTN                           LineLength,\r
  IN  UINTN                           TotalRow,\r
  IN  CHAR16                          *Str,\r
  IN  UINTN                           StrPos,\r
  IN  UINTN                           Len\r
  )\r
{\r
  CHAR16  Backup;\r
\r
  ASSERT (ConOut != NULL);\r
  ASSERT (Str != NULL);\r
\r
  Backup = 0;\r
  if (Row >= 0) {\r
    ConOut->SetCursorPosition (ConOut, Column, Row);\r
    return ;\r
  }\r
\r
  if (Len - StrPos > Column * Row) {\r
    Backup                          = *(Str + StrPos + Column * Row);\r
    *(Str + StrPos + Column * Row)  = 0;\r
  }\r
\r
  EDBPrint (L"%s", Str + StrPos);\r
  if (Len - StrPos > Column * Row) {\r
    *(Str + StrPos + Column * Row) = Backup;\r
  }\r
\r
  ConOut->SetCursorPosition (ConOut, 0, 0);\r
}\r
\r
/**\r
\r
  SetPageBreak.\r
\r
**/\r
BOOLEAN\r
EFIAPI\r
SetPageBreak (\r
  VOID\r
  )\r
{\r
  EFI_INPUT_KEY Key;\r
  CHAR16        Str[3];\r
  BOOLEAN       OmitPrint;\r
\r
  //\r
  // Check\r
  //\r
  if (!mDebuggerPrivate.EnablePageBreak) {\r
    return FALSE;\r
  }\r
\r
  gST->ConOut->OutputString (gST->ConOut, L"Press ENTER to continue, 'q' to exit:");\r
\r
  OmitPrint = FALSE;\r
  //\r
  // Wait for user input\r
  //\r
  Str[0]  = ' ';\r
  Str[1]  = 0;\r
  Str[2]  = 0;\r
  for (;;) {\r
    WaitForSingleEvent (gST->ConIn->WaitForKey, 0);\r
    gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);\r
\r
    //\r
    // handle control keys\r
    //\r
    if (Key.UnicodeChar == CHAR_NULL) {\r
      if (Key.ScanCode == SCAN_ESC) {\r
        gST->ConOut->OutputString (gST->ConOut, L"\r\n");\r
        OmitPrint = TRUE;\r
        break;\r
      }\r
\r
      continue;\r
    }\r
\r
    if (Key.UnicodeChar == CHAR_CARRIAGE_RETURN) {\r
      gST->ConOut->OutputString (gST->ConOut, L"\r\n");\r
      break;\r
    }\r
    //\r
    // Echo input\r
    //\r
    Str[1] = Key.UnicodeChar;\r
    if (Str[1] == CHAR_BACKSPACE) {\r
      continue;\r
    }\r
\r
    gST->ConOut->OutputString (gST->ConOut, Str);\r
\r
    if ((Str[1] == L'q') || (Str[1] == L'Q')) {\r
      OmitPrint = TRUE;\r
    } else {\r
      OmitPrint = FALSE;\r
    }\r
\r
    Str[0] = CHAR_BACKSPACE;\r
  }\r
\r
  return OmitPrint;\r
}\r
\r
/**\r
  Print a Unicode string to the output device.\r
\r
  @param  Format    A Null-terminated Unicode format string.\r
  @param  ...       The variable argument list that contains pointers to Null-\r
                    terminated Unicode strings to be printed\r
\r
**/\r
UINTN\r
EFIAPI\r
EDBPrint (\r
  IN CONST CHAR16  *Format,\r
  ...\r
  )\r
{\r
  UINTN   Return;\r
  VA_LIST Marker;\r
  CHAR16  Buffer[EFI_DEBUG_MAX_PRINT_BUFFER];\r
\r
  VA_START (Marker, Format);\r
  Return = UnicodeVSPrint (Buffer, sizeof (Buffer), Format, Marker);\r
  VA_END (Marker);\r
\r
  if (gST->ConOut != NULL) {\r
    //\r
    // To be extra safe make sure ConOut has been initialized\r
    //\r
    gST->ConOut->OutputString (gST->ConOut, Buffer);\r
  }\r
\r
  return Return;\r
}\r
\r
/**\r
  Print a Unicode string to the output buffer.\r
\r
  @param  Buffer          A pointer to the output buffer for the produced Null-terminated\r
                          Unicode string.\r
  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.\r
  @param  Format          A Null-terminated Unicode format string.\r
  @param  ...             The variable argument list that contains pointers to Null-\r
                          terminated Unicode strings to be printed\r
\r
**/\r
UINTN\r
EFIAPI\r
EDBSPrint (\r
  OUT CHAR16        *Buffer,\r
  IN  INTN          BufferSize,\r
  IN  CONST CHAR16  *Format,\r
  ...\r
  )\r
{\r
  UINTN   Return;\r
  VA_LIST Marker;\r
\r
  ASSERT (BufferSize > 0);\r
\r
  VA_START (Marker, Format);\r
  Return = UnicodeVSPrint (Buffer, (UINTN)BufferSize, Format, Marker);\r
  VA_END (Marker);\r
\r
  return Return;\r
}\r
\r
/**\r
  Print a Unicode string to the output buffer with specified offset..\r
\r
  @param  Buffer          A pointer to the output buffer for the produced Null-terminated\r
                          Unicode string.\r
  @param  BufferSize      The size, in bytes, of the output buffer specified by StartOfBuffer.\r
  @param  Offset          The offset of the buffer.\r
  @param  Format          A Null-terminated Unicode format string.\r
  @param  ...             The variable argument list that contains pointers to Null-\r
                          terminated Unicode strings to be printed\r
\r
**/\r
UINTN\r
EFIAPI\r
EDBSPrintWithOffset (\r
  OUT CHAR16        *Buffer,\r
  IN  INTN          BufferSize,\r
  IN  UINTN         Offset,\r
  IN  CONST CHAR16  *Format,\r
  ...\r
  )\r
{\r
  UINTN   Return;\r
  VA_LIST Marker;\r
\r
  ASSERT (BufferSize - (Offset * sizeof(CHAR16)) > 0);\r
\r
  VA_START (Marker, Format);\r
  Return = UnicodeVSPrint (Buffer + Offset, (UINTN)(BufferSize - (Offset * sizeof(CHAR16))), Format, Marker);\r
  VA_END (Marker);\r
\r
  return Return;\r
}\r