undoAppSTOutput.hpp

Go to the documentation of this file.

 
#ifndef UNDOSTUDIO_UNDOAPP_STOUTPUTFILTER_HPP
#define UNDOSTUDIO_UNDOAPP_STOUTPUTFILTER_HPP
 
#include <cctype>
#include <cstddef>
#include <string>
#include <vector>
 
namespace undoApp {
namespace ST {
 
namespace detail {
 
inline std::string toLowerText(const std::string& text)
{
   std::string lower = text;
   for (char& c : lower) {
      c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
   }
   return lower;
}
 
inline bool startsWith(const std::string& text, const std::string& prefix)
{
   return text.size() >= prefix.size() && text.compare(0, prefix.size(), prefix) == 0;
}
 
} // namespace detail
 
enum class OutSeverity
{
   Info,    
   Success, 
   Warning, 
   Error    
};
 
struct OutputLine
{
   OutSeverity severity = OutSeverity::Info;
   std::string text;
};
 
struct OutputFilter
{
   bool showErrors = true;
   bool showWarnings = true;
   bool showSuccess = true;
   bool showInfo = true;
 
   bool passes(OutSeverity severity) const
   {
      switch (severity) {
      case OutSeverity::Error: return showErrors;
      case OutSeverity::Warning: return showWarnings;
      case OutSeverity::Success: return showSuccess;
      case OutSeverity::Info: return showInfo;
      }
      return true;
   }
 
   std::vector<OutputLine> visible(const std::vector<OutputLine>& lines) const
   {
      std::vector<OutputLine> kept;
      kept.reserve(lines.size());
      for (const OutputLine& line : lines) {
         if (passes(line.severity)) {
            kept.push_back(line);
         }
      }
      return kept;
   }
 
   static size_t count(const std::vector<OutputLine>& lines, OutSeverity severity)
   {
      size_t total = 0;
      for (const OutputLine& line : lines) {
         if (line.severity == severity) {
            ++total;
         }
      }
      return total;
   }
};
 
inline std::vector<OutputLine> searchOutput(const std::vector<OutputLine>& lines, const std::string& needle)
{
   if (needle.empty()) {
      return lines;
   }
   std::vector<OutputLine> found;
   for (const OutputLine& line : lines) {
      if (line.text.find(needle) != std::string::npos) {
         found.push_back(line);
      }
   }
   return found;
}
 
inline bool isCountSummary(const std::string& line)
{
   for (size_t i = 0; i < line.size(); ++i) {
      if (!std::isdigit(static_cast<unsigned char>(line[i]))) {
         continue;
      }
      size_t after = i;
      while (after < line.size() && std::isdigit(static_cast<unsigned char>(line[after]))) {
         ++after;
      }
      size_t word = after;
      while (word < line.size() && line[word] == ' ') {
         ++word;
      }
      const std::string tail = detail::toLowerText(line.substr(word, 12));
      if (detail::startsWith(tail, "error") || detail::startsWith(tail, "warning")) {
         return true;
      }
      i = after - 1;
   }
   return false;
}
 
inline OutSeverity classifyCompilerLine(const std::string& line)
{
   if (isCountSummary(line)) {
      return OutSeverity::Info;
   }
 
   const std::string lower = detail::toLowerText(line);
 
   // "file.st:12:5: error: message", or a line that opens with the word.
   for (const char* marker : {": error", ": warning", "error:", "warning:"}) {
      if (lower.find(marker) != std::string::npos) {
         return (marker[0] == 'e' || marker == std::string(": error")) ? OutSeverity::Error
                                                                      : OutSeverity::Warning;
      }
   }
 
   return OutSeverity::Info;
}
 
} // namespace ST
} // namespace undoApp
 
#endif // UNDOSTUDIO_UNDOAPP_STOUTPUTFILTER_HPP