source/diagnostic.cpp

   1 // Copyright (c) 2015-2016 The Khronos Group Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "source/diagnostic.h"
  16
  17 #include <cassert>
  18 #include <cstring>
  19 #include <iostream>
  20 #include <sstream>
  21 #include <utility>
  22
  23 #include "source/table.h"
  24
  25 // Diagnostic API
  26
  27 spv_diagnostic spvDiagnosticCreate(const spv_position position,
  28                                    const char* message) {
  29   spv_diagnostic diagnostic = new spv_diagnostic_t;
  30   if (!diagnostic) return nullptr;
  31   size_t length = strlen(message) + 1;
  32   diagnostic->error = new char[length];
  33   if (!diagnostic->error) {
  34     delete diagnostic;
  35     return nullptr;
  36   }
  37   diagnostic->position = *position;
  38   diagnostic->isTextSource = false;
  39   memset(diagnostic->error, 0, length);
  40   strcpy(diagnostic->error, message);
  41   return diagnostic;
  42 }
  43
  44 void spvDiagnosticDestroy(spv_diagnostic diagnostic) {
  45   if (!diagnostic) return;
  46   delete[] diagnostic->error;
  47   delete diagnostic;
  48 }
  49
  50 spv_result_t spvDiagnosticPrint(const spv_diagnostic diagnostic) {
  51   if (!diagnostic) return SPV_ERROR_INVALID_DIAGNOSTIC;
  52
  53   if (diagnostic->isTextSource) {
  54     // NOTE: This is a text position
  55     // NOTE: add 1 to the line as editors start at line 1, we are counting new
  56     // line characters to start at line 0
  57     std::cerr << "error: " << diagnostic->position.line + 1 << ": "
  58               << diagnostic->position.column + 1 << ": " << diagnostic->error
  59               << "\n";
  60     return SPV_SUCCESS;
  61   }
  62
  63   // NOTE: Assume this is a binary position
  64   std::cerr << "error: ";
  65   if (diagnostic->position.index > 0)
  66     std::cerr << diagnostic->position.index << ": ";
  67   std::cerr << diagnostic->error << "\n";
  68   return SPV_SUCCESS;
  69 }
  70
  71 namespace spvtools {
  72
  73 DiagnosticStream::DiagnosticStream(DiagnosticStream&& other)
  74     : stream_(),
  75       position_(other.position_),
  76       consumer_(other.consumer_),
  77       disassembled_instruction_(std::move(other.disassembled_instruction_)),
  78       error_(other.error_) {
  79   // Prevent the other object from emitting output during destruction.
  80   other.error_ = SPV_FAILED_MATCH;
  81   // Some platforms are missing support for std::ostringstream functionality,
  82   // including:  move constructor, swap method.  Either would have been a
  83   // better choice than copying the string.
  84   stream_ << other.stream_.str();
  85 }
  86
  87 DiagnosticStream::~DiagnosticStream() {
  88   if (error_ != SPV_FAILED_MATCH && consumer_ != nullptr) {
  89     auto level = SPV_MSG_ERROR;
  90     switch (error_) {
  91       case SPV_SUCCESS:
  92       case SPV_REQUESTED_TERMINATION:  // Essentially success.
  93         level = SPV_MSG_INFO;
  94         break;
  95       case SPV_WARNING:
  96         level = SPV_MSG_WARNING;
  97         break;
  98       case SPV_UNSUPPORTED:
  99       case SPV_ERROR_INTERNAL:
 100       case SPV_ERROR_INVALID_TABLE:
 101         level = SPV_MSG_INTERNAL_ERROR;
 102         break;
 103       case SPV_ERROR_OUT_OF_MEMORY:
 104         level = SPV_MSG_FATAL;
 105         break;
 106       default:
 107         break;
 108     }
 109     if (disassembled_instruction_.size() > 0)
 110       stream_ << std::endl << "  " << disassembled_instruction_ << std::endl;
 111
 112     consumer_(level, "input", position_, stream_.str().c_str());
 113   }
 114 }
 115
 116 void UseDiagnosticAsMessageConsumer(spv_context context,
 117                                     spv_diagnostic* diagnostic) {
 118   assert(diagnostic && *diagnostic == nullptr);
 119
 120   auto create_diagnostic = [diagnostic](spv_message_level_t, const char*,
 121                                         const spv_position_t& position,
 122                                         const char* message) {
 123     auto p = position;
 124     spvDiagnosticDestroy(*diagnostic);  // Avoid memory leak.
 125     *diagnostic = spvDiagnosticCreate(&p, message);
 126   };
 127   SetContextMessageConsumer(context, std::move(create_diagnostic));
 128 }
 129
 130 std::string spvResultToString(spv_result_t res) {
 131   std::string out;
 132   switch (res) {
 133     case SPV_SUCCESS:
 134       out = "SPV_SUCCESS";
 135       break;
 136     case SPV_UNSUPPORTED:
 137       out = "SPV_UNSUPPORTED";
 138       break;
 139     case SPV_END_OF_STREAM:
 140       out = "SPV_END_OF_STREAM";
 141       break;
 142     case SPV_WARNING:
 143       out = "SPV_WARNING";
 144       break;
 145     case SPV_FAILED_MATCH:
 146       out = "SPV_FAILED_MATCH";
 147       break;
 148     case SPV_REQUESTED_TERMINATION:
 149       out = "SPV_REQUESTED_TERMINATION";
 150       break;
 151     case SPV_ERROR_INTERNAL:
 152       out = "SPV_ERROR_INTERNAL";
 153       break;
 154     case SPV_ERROR_OUT_OF_MEMORY:
 155       out = "SPV_ERROR_OUT_OF_MEMORY";
 156       break;
 157     case SPV_ERROR_INVALID_POINTER:
 158       out = "SPV_ERROR_INVALID_POINTER";
 159       break;
 160     case SPV_ERROR_INVALID_BINARY:
 161       out = "SPV_ERROR_INVALID_BINARY";
 162       break;
 163     case SPV_ERROR_INVALID_TEXT:
 164       out = "SPV_ERROR_INVALID_TEXT";
 165       break;
 166     case SPV_ERROR_INVALID_TABLE:
 167       out = "SPV_ERROR_INVALID_TABLE";
 168       break;
 169     case SPV_ERROR_INVALID_VALUE:
 170       out = "SPV_ERROR_INVALID_VALUE";
 171       break;
 172     case SPV_ERROR_INVALID_DIAGNOSTIC:
 173       out = "SPV_ERROR_INVALID_DIAGNOSTIC";
 174       break;
 175     case SPV_ERROR_INVALID_LOOKUP:
 176       out = "SPV_ERROR_INVALID_LOOKUP";
 177       break;
 178     case SPV_ERROR_INVALID_ID:
 179       out = "SPV_ERROR_INVALID_ID";
 180       break;
 181     case SPV_ERROR_INVALID_CFG:
 182       out = "SPV_ERROR_INVALID_CFG";
 183       break;
 184     case SPV_ERROR_INVALID_LAYOUT:
 185       out = "SPV_ERROR_INVALID_LAYOUT";
 186       break;
 187     default:
 188       out = "Unknown Error";
 189   }
 190   return out;
 191 }
 192
 193 }  // namespace spvtools