message.cc

// Copyright 2015 The Shaderc Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "libshaderc_util/message.h"

#include <algorithm>
#include <cstring>
#include <iostream>
#include <iterator>

namespace shaderc_util {

namespace {

// Given a message, deduces and returns its type. If the message type is
// recognized, advances *message past the prefix indicating the type. Otherwise,
// leaves *message unchanged and returns MessageType::Unknown.
MessageType DeduceMessageType(string_piece* message) {
  static const char kErrorMessage[] = "ERROR: ";
  static const char kWarningMessage[] = "WARNING: ";
  static const char kGlobalWarningMessage[] = "Warning, ";

  if (message->starts_with(kErrorMessage)) {
    *message = message->substr(::strlen(kErrorMessage));
    return MessageType::Error;
  } else if (message->starts_with(kWarningMessage)) {
    *message = message->substr(::strlen(kWarningMessage));
    return MessageType::Warning;
  } else if (message->starts_with(kGlobalWarningMessage)) {
    *message = message->substr(::strlen(kGlobalWarningMessage));
    return MessageType::GlobalWarning;
  }
  return MessageType::Unknown;
}

// Deduces a location specification from the given message. A location
// specification is of the form "<source-name>:<line-number>:" and a trailing
// space.  If the deduction is successful, returns true and updates source_name
// and line_number to the deduced source name and line numer respectively. The
// prefix standing for the location specification in message is skipped.
// Otherwise, returns false and keeps all parameters untouched.
bool DeduceLocationSpec(string_piece* message, string_piece* source_name,
                        string_piece* line_number) {
  if (!message || message->empty()) {
    return false;
  }

  // When we find a pattern like this:
  //     colon
  //     digits
  //     colon
  //     space
  // Then deduce that the source_name is the text before the first colon,
  // the line number is the digits, and the message is the text after the
  // second colon.

  const size_t size = message->size();
  if (size <= 4) {
    // A valid message must have a colon, a digit, a colon, and a space.
    return false;
  }
  // The last possible position of the first colon.
  const size_t first_colon_cutoff = size - 4;
  // The last possible position of the second colon.
  const size_t next_colon_cutoff = size - 2;

  for (size_t first_colon_pos = message->find_first_of(':'), next_colon_pos = 0;

       // There is a first colon, and it's not too close to the end
       (first_colon_pos != string_piece::npos) &&
       (first_colon_pos <= first_colon_cutoff);

       // Try the next pair of colons.
       first_colon_pos = next_colon_pos) {
    // We're guaranteed to have at least 3 more characters.
    // Guarantee progress toward the end of the string.
    next_colon_pos = message->find_first_of(':', first_colon_pos + 1);
    if ((next_colon_pos == string_piece::npos) ||
        (next_colon_pos > next_colon_cutoff)) {
      // No valid solution.
      return false;
    }
    if (first_colon_pos + 1 == next_colon_pos) {
      // There is no room for digits.
      continue;
    }
    if ((message->data()[next_colon_pos + 1] != ' ')) {
      // There is no space character after the second colon.
      continue;
    }
    if (message->find_first_not_of("0123456789", first_colon_pos + 1) ==
        next_colon_pos) {
      // We found the first solution.
      *source_name = message->substr(0, first_colon_pos);
      *line_number = message->substr(first_colon_pos + 1,
                                     next_colon_pos - 1 - first_colon_pos);
      *message = message->substr(next_colon_pos + 2);
      return true;
    }
  }

  return false;
}

// Returns true if the given message is a summary message.
bool IsSummaryMessage(const string_piece& message) {
  const size_t space_loc = message.find_first_of(' ');
  if (space_loc == string_piece::npos) return false;
  const string_piece number = message.substr(0, space_loc);
  const string_piece rest = message.substr(space_loc + 1);
  if (!std::all_of(number.begin(), number.end(), ::isdigit)) return false;
  if (!rest.starts_with("compilation errors.")) return false;
  return true;
}

}  // anonymous namespace

MessageType ParseGlslangOutput(const string_piece& message,
                               bool warnings_as_errors, bool suppress_warnings,
                               string_piece* source_name,
                               string_piece* line_number, string_piece* rest) {
  string_piece rest_of_message(message);
  source_name->clear();
  line_number->clear();
  rest->clear();

  // The glslang warning/error messages are typically of the following form:
  //   <message-type> <location-specification> <message-body>
  //
  // <message-type> can be "WARNING:", "ERROR:", or "Warning, ". "WARNING:"
  // means a warning message for a certain line, while "Warning, " means a
  // global one.
  //
  // <location-specification> is of the form:
  //   <filename-or-string-number>:<line-number>:
  // It doesn't exist if the warning/error message is a global one.
  //
  // See Glslang's TInfoSink class implementation for details.

  bool is_error = false;

  // Handle <message-type>.
  switch (DeduceMessageType(&rest_of_message)) {
    case MessageType::Warning:
      if (suppress_warnings) return MessageType::Ignored;
      break;
    case MessageType::Error:
      is_error = true;
      break;
    case MessageType::GlobalWarning:
      if (suppress_warnings) return MessageType::Ignored;
      *rest = rest_of_message;
      return warnings_as_errors ? MessageType::GlobalError
                                : MessageType::GlobalWarning;
    case MessageType::Unknown:
      *rest = rest_of_message;
      return MessageType::Unknown;
    default:
      break;
  }

  rest_of_message = rest_of_message.strip_whitespace();
  if (rest_of_message.empty()) return MessageType::Unknown;

  // Now we have stripped the <message-type>. Try to see if we can find
  // a <location-specification>.
  if (DeduceLocationSpec(&rest_of_message, source_name, line_number)) {
    *rest = rest_of_message;
    return (is_error || warnings_as_errors) ? MessageType::Error
                                            : MessageType::Warning;
  } else {
    // No <location-specification>. This is a global warning/error message.
    // A special kind of global message is summary message, which should
    // start with a number.
    *rest = rest_of_message;
    if (IsSummaryMessage(rest_of_message)) {
      return (is_error || warnings_as_errors) ? MessageType::ErrorSummary
                                              : MessageType::WarningSummary;
    }
    return (is_error || warnings_as_errors) ? MessageType::GlobalError
                                            : MessageType::GlobalWarning;
  }
  return MessageType::Unknown;
}

bool PrintFilteredErrors(const string_piece& file_name,
                         std::ostream* error_stream, bool warnings_as_errors,
                         bool suppress_warnings, const char* error_list,
                         size_t* total_warnings, size_t* total_errors) {
  const char* ignored_error_strings[] = {
      "Warning, version 310 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 400 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 410 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 420 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 430 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 440 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Warning, version 450 is not yet complete; most version-specific "
      "features are present, but some are missing.",
      "Linked vertex stage:", "Linked fragment stage:",
      "Linked tessellation control stage:",
      "Linked tessellation evaluation stage:", "Linked geometry stage:",
      "Linked compute stage:", ""};
  size_t existing_total_errors = *total_errors;
  string_piece error_messages(error_list);
  for (const string_piece& message : error_messages.get_fields('\n')) {
    if (std::find(std::begin(ignored_error_strings),
                  std::end(ignored_error_strings),
                  message) == std::end(ignored_error_strings)) {
      string_piece source_name;
      string_piece line_number;
      string_piece rest;
      const MessageType type =
          ParseGlslangOutput(message, warnings_as_errors, suppress_warnings,
                             &source_name, &line_number, &rest);
      string_piece name = file_name;
      if (!source_name.empty()) {
        // -1 is the string number for the preamble injected by us.
        name = source_name == "-1" ? "<command line>" : source_name;
      }
      switch (type) {
        case MessageType::Error:
        case MessageType::Warning:
          assert(!name.empty() && !line_number.empty() && !rest.empty());
          *error_stream << name << ":" << line_number << ": "
                        << (type == MessageType::Error ? "error: "
                                                       : "warning: ")
                        << rest.strip_whitespace() << std::endl;
          *total_errors += type == MessageType::Error;
          *total_warnings += type == MessageType::Warning;
          break;
        case MessageType::ErrorSummary:
        case MessageType::WarningSummary:
          break;
        case MessageType::GlobalError:
        case MessageType::GlobalWarning:
          assert(!rest.empty());
          *total_errors += type == MessageType::GlobalError;
          *total_warnings += type == MessageType::GlobalWarning;
          *error_stream << name << ": "
                        << (type == MessageType::GlobalError ? "error"
                                                             : "warning")
                        << ": " << rest.strip_whitespace() << std::endl;
          break;
        case MessageType::Unknown:
          *error_stream << name << ":";
          *error_stream << " " << message << std::endl;
          break;
        case MessageType::Ignored:
          break;
      }
    }
  }
  return (existing_total_errors == *total_errors);
}

// Outputs the number of warnings and errors if there are any.
void OutputMessages(std::ostream* error_stream, size_t total_warnings,
                    size_t total_errors) {
  if (total_warnings > 0 || total_errors > 0) {
    if (total_warnings > 0 && total_errors > 0) {
      *error_stream << total_warnings << " warning"
                    << (total_warnings > 1 ? "s" : "") << " and "
                    << total_errors << " error" << (total_errors > 1 ? "s" : "")
                    << " generated." << std::endl;
    } else if (total_warnings > 0) {
      *error_stream << total_warnings << " warning"
                    << (total_warnings > 1 ? "s" : "") << " generated."
                    << std::endl;
    } else if (total_errors > 0) {
      *error_stream << total_errors << " error" << (total_errors > 1 ? "s" : "")
                    << " generated." << std::endl;
    }
  }
}

}  // namespace glslc