File indexing completed on 2024-05-12 04:39:43

 /*
     SPDX-FileCopyrightText: 2004 Roberto Raggi <roberto@kdevelop.org>
     SPDX-FileCopyrightText: 2005-2006 Vladimir Prus <ghost@cs.msu.su>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "miparser.h"
 #include "tokens.h"
 
 using namespace KDevMI::MI;
 
 #define MATCH(tok) \
   do { \
       if (m_lex->lookAhead(0) != (tok)) \
           return false; \
   } while (0)
 
 #define ADVANCE(tok) \
   do { \
       MATCH(tok); \
       m_lex->nextToken(); \
   } while (0)
 
 #define MATCH_PTR(tok) \
   do { \
       if (m_lex->lookAhead(0) != (tok)) \
           return {}; \
   } while (0)
 
 #define ADVANCE_PTR(tok) \
   do { \
       MATCH_PTR(tok); \
       m_lex->nextToken(); \
   } while (0)
 
 MIParser::MIParser()
 {
 }
 
 MIParser::~MIParser()
 {
 }
 
 std::unique_ptr<Record> MIParser::parse(FileSymbol *file)
 {
     m_lex = nullptr;
 
     TokenStream *tokenStream = m_lexer.tokenize(file);
     if (!tokenStream)
         return nullptr;
 
     m_lex = file->tokenStream = tokenStream;
 
     uint32_t token = 0;
     if (m_lex->lookAhead() == Token_number_literal) {
         token = QString::fromUtf8(m_lex->currentTokenText()).toUInt();
         m_lex->nextToken();
     }
 
     std::unique_ptr<Record> record;
 
     switch (m_lex->lookAhead()) {
         case '~':
         case '@':
         case '&':
             record = parseStreamRecord();
             break;
         case '(':
             record = parsePrompt();
             break;
         case '^':
         case '*':
         case '=':
         case '+':
             record = parseResultOrAsyncRecord();
             break;
         default:
             break;
     }
 
     if (record && record->kind == Record::Result) {
         auto * result = static_cast<ResultRecord *>(record.get());
         result->token = token;
     } else {
         Q_ASSERT(token == 0);
     }
 
     return record;
 }
 
 std::unique_ptr<Record> MIParser::parsePrompt()
 {
     ADVANCE_PTR('(');
     MATCH_PTR(Token_identifier);
     if (m_lex->currentTokenText() != "gdb")
         return {};
     m_lex->nextToken();
     ADVANCE_PTR(')');
 
     return std::unique_ptr<Record>(new PromptRecord);
 }
 
 std::unique_ptr<Record> MIParser::parseStreamRecord()
 {
     StreamRecord::Subkind subkind;
 
     switch (m_lex->lookAhead()) {
     case '~': subkind = StreamRecord::Console; break;
     case '@': subkind = StreamRecord::Target; break;
     case '&': subkind = StreamRecord::Log; break;
     default:
         Q_ASSERT(false);
         return {};
     }
 
     std::unique_ptr<StreamRecord> stream(new StreamRecord(subkind));
 
     m_lex->nextToken();
     MATCH_PTR(Token_string_literal);
     stream->message = parseStringLiteral();
     return stream;
 }
 
 std::unique_ptr<Record> MIParser::parseResultOrAsyncRecord()
 {
     std::unique_ptr<TupleRecord> result;
 
     char c = m_lex->lookAhead();
     m_lex->nextToken();
     MATCH_PTR(Token_identifier);
     QString reason = QString::fromUtf8(m_lex->currentTokenText());
     m_lex->nextToken();
 
     if (c == '^') {
         result.reset(new ResultRecord(reason));
     } else {
         AsyncRecord::Subkind subkind;
         switch (c) {
         case '*': subkind = AsyncRecord::Exec; break;
         case '=': subkind = AsyncRecord::Notify; break;
         case '+': subkind = AsyncRecord::Status; break;
         default:
             Q_ASSERT(false);
             return {};
         }
         result.reset(new AsyncRecord(subkind, reason));
     }
 
     if (m_lex->lookAhead() == ',') {
         m_lex->nextToken();
 
         if (!parseCSV(*result))
             return {};
     }
 
     return result;
 }
 
 bool MIParser::parseResult(Result *&result)
 {
     // be less strict about the format, see e.g.:
     // https://bugs.kde.org/show_bug.cgi?id=304730
     // https://sourceware.org/bugzilla/show_bug.cgi?id=9659
 
     std::unique_ptr<Result> res(new Result);
 
     if (m_lex->lookAhead() == Token_identifier) {
         res->variable = QString::fromUtf8(m_lex->currentTokenText());
         m_lex->nextToken();
 
         if (m_lex->lookAhead() != '=') {
             result = res.release();
             return true;
         }
 
         m_lex->nextToken();
     }
 
     Value *value = nullptr;
     if (!parseValue(value))
         return false;
 
     res->value = value;
     result = res.release();
 
     return true;
 }
 
 bool MIParser::parseValue(Value *&value)
 {
     value = nullptr;
 
     switch (m_lex->lookAhead()) {
         case Token_string_literal: {
             value = new StringLiteralValue(parseStringLiteral());
         }
         return true;
 
         case '{':
             return parseTuple(value);
 
         case '[':
             return parseList(value);
 
         default:
             break;
     }
 
     return false;
 }
 
 bool MIParser::parseTuple(Value *&value)
 {
     TupleValue* val;
 
     if (!parseCSV(&val, '{', '}'))
         return false;
 
     value = val;
     return true;
 }
 
 bool MIParser::parseList(Value *&value)
 {
     ADVANCE('[');
 
     std::unique_ptr<ListValue> lst(new ListValue);
 
     // Note: can't use parseCSV here because of nested
     // "is this Value or Result" guessing. Too lazy to factor
     // that out too using function pointers.
     int tok = m_lex->lookAhead();
     while (tok && tok != ']') {
         Result *result = nullptr;
         Value *val = nullptr;
 
         if (tok == Token_identifier)
         {
             if (!parseResult(result))
                 return false;
         }
         else if (!parseValue(val))
             return false;
 
         Q_ASSERT(result || val);
 
         if (!result) {
             result = new Result;
             result->value = val;
         }
         lst->results.append(result);
 
         if (m_lex->lookAhead() == ',')
             m_lex->nextToken();
 
         tok = m_lex->lookAhead();
     }
     ADVANCE(']');
 
     value = lst.release();
 
     return true;
 }
 
 bool MIParser::parseCSV(TupleValue** value,
                         char start, char end)
 {
     std::unique_ptr<TupleValue> tuple(new TupleValue);
 
     if (!parseCSV(*tuple, start, end))
         return false;
  
     *value = tuple.get();
     tuple.release();
     return true;
 }
 
 bool MIParser::parseCSV(TupleValue& value,
                         char start, char end)
 {
    if (start)
         ADVANCE(start);
 
     int tok = m_lex->lookAhead();
     while (tok) {
         if (end && tok == end)
             break;
 
         Result *result;
         if (!parseResult(result))
             return false;
 
         value.results.append(result);
         value.results_by_name.insert(result->variable, result);      
 
         if (m_lex->lookAhead() == ',')
             m_lex->nextToken();
 
         tok = m_lex->lookAhead();
     }
 
     if (end)
         ADVANCE(end);
 
     return true;
 }
 
 QString MIParser::parseStringLiteral()
 {
     QByteArray messageByteArray = m_lex->currentTokenText();
     QString message = QString::fromUtf8(messageByteArray.constData());
 
     int length = message.length();
     QString message2;
     message2.reserve(length);
     // The [1,length-1] range removes quotes without extra
     // call to 'mid'
     for(int i = 1, e = length-1; i != e; ++i)
     {
         int translated = -1;
         if (message[i] == QLatin1Char('\\')) {
             if (i+1 < length)
             {
                 // TODO: implement all the other escapes, maybe
                 if (message[i+1] == QLatin1Char('n')) {
                     translated = '\n';
                 }
                 else if (message[i+1] == QLatin1Char('\\')) {
                     translated = '\\';
                 }
                 else if (message[i+1] == QLatin1Char('"')) {
                     translated = '"';
                 }
                 else if (message[i+1] == QLatin1Char('t')) {
                     translated = '\t';
                 }
                 else if (message[i+1] == QLatin1Char('r')) {
                     translated = '\r';
                 }
             }
         }
 
         if (translated != -1)
         {
             message2.append(translated);
             ++i;
         }
         else
         {
             message2.append(message[i]);
         }
     }
 
     m_lex->nextToken();
     return message2;
 }