contrib/llvm/tools/lldb/source/Core/InputReader.cpp

   1 //===-- InputReader.cpp -----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/lldb-python.h"
  11
  12 #include <string>
  13
  14 #include "lldb/Core/InputReader.h"
  15 #include "lldb/Core/Debugger.h"
  16 #include "lldb/Interpreter/CommandInterpreter.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 InputReader::InputReader (Debugger &debugger) :
  22     m_debugger (debugger),
  23     m_callback (NULL),
  24     m_callback_baton (NULL),
  25     m_end_token (),
  26     m_granularity (eInputReaderGranularityInvalid),
  27     m_done (true),
  28     m_echo (true),
  29     m_active (false),
  30     m_reader_done (false),
  31     m_user_input(),
  32     m_save_user_input(false)
  33 {
  34 }
  35
  36 InputReader::~InputReader ()
  37 {
  38 }
  39
  40 Error
  41 InputReader::Initialize
  42 (
  43     Callback callback,
  44     void *baton,
  45     lldb::InputReaderGranularity granularity,
  46     const char *end_token,
  47     const char *prompt,
  48     bool echo
  49 )
  50 {
  51     Error err;
  52     m_callback = callback;
  53     m_callback_baton = baton,
  54     m_granularity = granularity;
  55     if (end_token != NULL)
  56         m_end_token = end_token;
  57     if (prompt != NULL)
  58         m_prompt = prompt;
  59     m_done = true;
  60     m_echo = echo;
  61
  62     if (m_granularity == eInputReaderGranularityInvalid)
  63     {
  64         err.SetErrorString ("Invalid read token size:  Reader must be initialized with a token size other than 'eInputReaderGranularityInvalid'.");
  65     }
  66     else
  67     if (end_token != NULL && granularity != eInputReaderGranularityInvalid)
  68     {
  69         if (granularity == eInputReaderGranularityByte)
  70         {
  71             // Check to see if end_token is longer than one byte.
  72
  73             if (strlen (end_token) > 1)
  74             {
  75                 err.SetErrorString ("Invalid end token:  End token cannot be larger than specified token size (byte).");
  76             }
  77         }
  78         else if (granularity == eInputReaderGranularityWord)
  79         {
  80             // Check to see if m_end_token contains any white space (i.e. is multiple words).
  81
  82             const char *white_space = " \t\n";
  83             size_t pos = m_end_token.find_first_of (white_space);
  84             if (pos != std::string::npos)
  85             {
  86                 err.SetErrorString ("Invalid end token:  End token cannot be larger than specified token size (word).");
  87             }
  88         }
  89         else
  90         {
  91             // Check to see if m_end_token contains any newlines; cannot handle multi-line end tokens.
  92
  93             size_t pos = m_end_token.find_first_of ('\n');
  94             if (pos != std::string::npos)
  95             {
  96                 err.SetErrorString ("Invalid end token:  End token cannot contain a newline.");
  97             }
  98         }
  99     }
 100
 101     m_done = err.Fail();
 102
 103     return err;
 104 }
 105
 106 size_t
 107 InputReader::HandleRawBytes (const char *bytes, size_t bytes_len)
 108 {
 109     const char *end_token = NULL;
 110
 111     if (m_end_token.empty() == false)
 112     {
 113         end_token = ::strstr (bytes, m_end_token.c_str());
 114         if (end_token >= bytes + bytes_len)
 115             end_token = NULL;
 116     }
 117
 118     const char *p = bytes;
 119     const char *end = bytes + bytes_len;
 120
 121     switch (m_granularity)
 122     {
 123     case eInputReaderGranularityInvalid:
 124         break;
 125
 126     case eInputReaderGranularityByte:
 127         while (p < end)
 128         {
 129             if (end_token == p)
 130             {
 131                 p += m_end_token.size();
 132                 SetIsDone(true);
 133                 break;
 134             }
 135
 136             if (m_callback (m_callback_baton, *this, eInputReaderGotToken, p, 1) == 0)
 137                 break;
 138             ++p;
 139             if (IsDone())
 140                 break;
 141         }
 142         // Return how many bytes were handled.
 143         return p - bytes;
 144         break;
 145
 146
 147     case eInputReaderGranularityWord:
 148         {
 149             char quote = '\0';
 150             const char *word_start = NULL;
 151             bool send_word = false;
 152             for (; p < end; ++p, send_word = false)
 153             {
 154                 if (end_token && end_token == p)
 155                 {
 156                     m_end_token.size();
 157                     SetIsDone(true);
 158                     break;
 159                 }
 160
 161                 const char ch = *p;
 162                 if (isspace(ch) && (!quote || (quote == ch && p[-1] != '\\')))
 163                 {
 164                     // We have a space character or the terminating quote
 165                     send_word = word_start != NULL;
 166                     quote = '\0';
 167                 }
 168                 else if (quote)
 169                 {
 170                     // We are in the middle of a quoted character
 171                     continue;
 172                 }
 173                 else if (ch == '"' || ch == '\'' || ch == '`')
 174                     quote = ch;
 175                 else if (word_start == NULL)
 176                 {
 177                     // We have the first character in a word
 178                     word_start = p;
 179                 }
 180
 181                 if (send_word)
 182                 {
 183                     const size_t word_len = p - word_start;
 184                     size_t bytes_handled = m_callback (m_callback_baton,
 185                                                        *this,
 186                                                        eInputReaderGotToken,
 187                                                        word_start,
 188                                                        word_len);
 189
 190                     if (bytes_handled != word_len)
 191                         return word_start - bytes + bytes_handled;
 192
 193                     if (IsDone())
 194                         return p - bytes;
 195                 }
 196             }
 197         }
 198         break;
 199
 200
 201     case eInputReaderGranularityLine:
 202         {
 203             const char *line_start = bytes;
 204             const char *end_line = NULL;
 205             while (p < end)
 206             {
 207                 const char ch = *p;
 208                 if (ch == '\n' || ch == '\r')
 209                 {
 210                     size_t line_length = p - line_start;
 211                     // Now skip the newline character
 212                     ++p;
 213                     // Skip a complete DOS newline if we run into one
 214                     if (ch == 0xd && p < end && *p == 0xa)
 215                         ++p;
 216
 217                     if (line_start <= end_token && end_token < line_start + line_length)
 218                     {
 219                         SetIsDone(true);
 220                         m_callback (m_callback_baton,
 221                                     *this,
 222                                     eInputReaderGotToken,
 223                                     line_start,
 224                                     end_token - line_start);
 225
 226                         return p - bytes;
 227                     }
 228
 229                     size_t bytes_handled = m_callback (m_callback_baton,
 230                                                        *this,
 231                                                        eInputReaderGotToken,
 232                                                        line_start,
 233                                                        line_length);
 234
 235                     end_line = p;
 236
 237                     if (bytes_handled != line_length)
 238                     {
 239                         // The input reader wasn't able to handle all the data
 240                         return line_start - bytes + bytes_handled;
 241                     }
 242
 243
 244                     if (IsDone())
 245                         return p - bytes;
 246
 247                     line_start = p;
 248                 }
 249                 else
 250                 {
 251                     ++p;
 252                 }
 253             }
 254
 255             if (end_line)
 256                 return end_line - bytes;
 257         }
 258         break;
 259
 260
 261     case eInputReaderGranularityAll:
 262         {
 263             // Nothing should be handle unless we see our end token
 264             if (end_token)
 265             {
 266                 size_t length = end_token - bytes;
 267                 size_t bytes_handled = m_callback (m_callback_baton,
 268                                                    *this,
 269                                                    eInputReaderGotToken,
 270                                                    bytes,
 271                                                    length);
 272                 m_done = true;
 273
 274                 p += bytes_handled + m_end_token.size();
 275
 276                 // Consume any white space, such as newlines, beyond the end token
 277
 278                 while (p < end && isspace(*p))
 279                     ++p;
 280
 281                 if (bytes_handled != length)
 282                     return bytes_handled;
 283                 else
 284                 {
 285                     return p - bytes;
 286                     //return bytes_handled + m_end_token.size();
 287                 }
 288             }
 289             return 0;
 290         }
 291         break;
 292     }
 293     return 0;
 294 }
 295
 296 const char *
 297 InputReader::GetPrompt () const
 298 {
 299     if (!m_prompt.empty())
 300         return m_prompt.c_str();
 301     else
 302         return NULL;
 303 }
 304
 305 void
 306 InputReader::RefreshPrompt ()
 307 {
 308         if (m_debugger.GetCommandInterpreter().GetBatchCommandMode())
 309         return;
 310
 311     if (!m_prompt.empty())
 312     {
 313         File &out_file = m_debugger.GetOutputFile();
 314         if (out_file.IsValid())
 315         {
 316             out_file.Printf ("%s", m_prompt.c_str());
 317             out_file.Flush();
 318         }
 319     }
 320 }
 321
 322 void
 323 InputReader::Notify (InputReaderAction notification)
 324 {
 325     switch (notification)
 326     {
 327     case eInputReaderActivate:
 328     case eInputReaderReactivate:
 329         m_active = true;
 330         m_reader_done.SetValue(false, eBroadcastAlways);
 331         break;
 332
 333     case eInputReaderDeactivate:
 334     case eInputReaderDone:
 335         m_active = false;
 336         break;
 337
 338     case eInputReaderAsynchronousOutputWritten:
 339         break;
 340
 341     case eInputReaderInterrupt:
 342     case eInputReaderEndOfFile:
 343         break;
 344
 345     case eInputReaderGotToken:
 346         return; // We don't notify the tokens here, it is done in HandleRawBytes
 347     }
 348     if (m_callback)
 349         m_callback (m_callback_baton, *this, notification, NULL, 0);
 350     if (notification == eInputReaderDone)
 351         m_reader_done.SetValue(true, eBroadcastAlways);
 352 }
 353
 354 void
 355 InputReader::WaitOnReaderIsDone ()
 356 {
 357     m_reader_done.WaitForValueEqualTo (true);
 358 }
 359
 360 const char *
 361 InputReader::GranularityAsCString (lldb::InputReaderGranularity granularity)
 362 {
 363     switch (granularity)
 364     {
 365     case eInputReaderGranularityInvalid:  return "invalid";
 366     case eInputReaderGranularityByte:     return "byte";
 367     case eInputReaderGranularityWord:     return "word";
 368     case eInputReaderGranularityLine:     return "line";
 369     case eInputReaderGranularityAll:      return "all";
 370     }
 371
 372     static char unknown_state_string[64];
 373     snprintf(unknown_state_string, sizeof (unknown_state_string), "InputReaderGranularity = %i", granularity);
 374     return unknown_state_string;
 375 }
 376
 377 bool
 378 InputReader::HandlerData::GetBatchMode()
 379 {
 380     return reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode();
 381 }
 382
 383 lldb::StreamSP
 384 InputReader::HandlerData::GetOutStream()
 385 {
 386     return reader.GetDebugger().GetAsyncOutputStream();
 387 }