gcc/rust/rust-diagnostics.cc

   1 // rust-diagnostics.cc -- GCC implementation of rust diagnostics interface.
   2 // Copyright (C) 2016-2023 Free Software Foundation, Inc.
   3 // Contributed by Than McIntosh, Google.
   4
   5 // This file is part of GCC.
   6
   7 // GCC is free software; you can redistribute it and/or modify it under
   8 // the terms of the GNU General Public License as published by the Free
   9 // Software Foundation; either version 3, or (at your option) any later
  10 // version.
  11
  12 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 // for more details.
  16
  17 // You should have received a copy of the GNU General Public License
  18 // along with GCC; see the file COPYING3.  If not see
  19 // <http://www.gnu.org/licenses/>.
  20
  21 #include "rust-system.h"
  22 #include "rust-diagnostics.h"
  23
  24 static std::string
  25 mformat_value ()
  26 {
  27   return std::string (xstrerror (errno));
  28 }
  29
  30 // Rewrite a format string to expand any extensions not
  31 // supported by sprintf(). See comments in rust-diagnostics.h
  32 // for list of supported format specifiers.
  33
  34 static std::string
  35 expand_format (const char *fmt)
  36 {
  37   std::stringstream ss;
  38   for (const char *c = fmt; *c; ++c)
  39     {
  40       if (*c != '%')
  41         {
  42           ss << *c;
  43           continue;
  44         }
  45       c++;
  46       switch (*c)
  47         {
  48           case '\0': {
  49             // malformed format string
  50             rust_unreachable ();
  51           }
  52           case '%': {
  53             ss << "%";
  54             break;
  55           }
  56           case 'm': {
  57             ss << mformat_value ();
  58             break;
  59           }
  60           case '<': {
  61             ss << rust_open_quote ();
  62             break;
  63           }
  64           case '>': {
  65             ss << rust_close_quote ();
  66             break;
  67           }
  68           case 'q': {
  69             ss << rust_open_quote ();
  70             c++;
  71             if (*c == 'm')
  72               {
  73                 ss << mformat_value ();
  74               }
  75             else
  76               {
  77                 ss << "%" << *c;
  78               }
  79             ss << rust_close_quote ();
  80             break;
  81           }
  82           default: {
  83             ss << "%" << *c;
  84           }
  85         }
  86     }
  87   return ss.str ();
  88 }
  89
  90 // Expand message format specifiers, using a combination of
  91 // expand_format above to handle extensions (ex: %m, %q) and vasprintf()
  92 // to handle regular printf-style formatting. A pragma is being used here to
  93 // suppress this warning:
  94 //
  95 //   warning: function ‘std::__cxx11::string expand_message(const char*,
  96 //   __va_list_tag*)’ might be a candidate for ‘gnu_printf’ format attribute
  97 //   [-Wsuggest-attribute=format]
  98 //
  99 // What appears to be happening here is that the checker is deciding that
 100 // because of the call to vasprintf() (which has attribute gnu_printf), the
 101 // calling function must need to have attribute gnu_printf as well, even
 102 // though there is already an attribute declaration for it.
 103
 104 static std::string
 105 expand_message (const char *fmt, va_list ap) RUST_ATTRIBUTE_GCC_DIAG (1, 0);
 106
 107 #pragma GCC diagnostic push
 108 #pragma GCC diagnostic ignored "-Wsuggest-attribute=format"
 109
 110 static std::string
 111 expand_message (const char *fmt, va_list ap)
 112 {
 113   char *mbuf = 0;
 114   std::string expanded_fmt = expand_format (fmt);
 115   int nwr = vasprintf (&mbuf, expanded_fmt.c_str (), ap);
 116   if (nwr == -1)
 117     {
 118       // memory allocation failed
 119       rust_be_error_at (Linemap::unknown_location (),
 120                         "memory allocation failed in vasprintf");
 121       rust_assert (0);
 122     }
 123   std::string rval = std::string (mbuf);
 124   free (mbuf);
 125   return rval;
 126 }
 127
 128 #pragma GCC diagnostic pop
 129
 130 static const char *cached_open_quote = NULL;
 131 static const char *cached_close_quote = NULL;
 132
 133 const char *
 134 rust_open_quote ()
 135 {
 136   if (cached_open_quote == NULL)
 137     rust_be_get_quotechars (&cached_open_quote, &cached_close_quote);
 138   return cached_open_quote;
 139 }
 140
 141 const char *
 142 rust_close_quote ()
 143 {
 144   if (cached_close_quote == NULL)
 145     rust_be_get_quotechars (&cached_open_quote, &cached_close_quote);
 146   return cached_close_quote;
 147 }
 148
 149 void
 150 rust_internal_error_at (const Location location, const char *fmt, ...)
 151 {
 152   va_list ap;
 153
 154   va_start (ap, fmt);
 155   rust_be_internal_error_at (location, expand_message (fmt, ap));
 156   va_end (ap);
 157 }
 158
 159 void
 160 rust_error_at (const Location location, const char *fmt, ...)
 161 {
 162   va_list ap;
 163
 164   va_start (ap, fmt);
 165   rust_be_error_at (location, expand_message (fmt, ap));
 166   va_end (ap);
 167 }
 168
 169 void
 170 rust_warning_at (const Location location, int opt, const char *fmt, ...)
 171 {
 172   va_list ap;
 173
 174   va_start (ap, fmt);
 175   rust_be_warning_at (location, opt, expand_message (fmt, ap));
 176   va_end (ap);
 177 }
 178
 179 void
 180 rust_fatal_error (const Location location, const char *fmt, ...)
 181 {
 182   va_list ap;
 183
 184   va_start (ap, fmt);
 185   rust_be_fatal_error (location, expand_message (fmt, ap));
 186   va_end (ap);
 187 }
 188
 189 void
 190 rust_inform (const Location location, const char *fmt, ...)
 191 {
 192   va_list ap;
 193
 194   va_start (ap, fmt);
 195   rust_be_inform (location, expand_message (fmt, ap));
 196   va_end (ap);
 197 }
 198
 199 // Rich Locations
 200 void
 201 rust_error_at (const RichLocation &location, const char *fmt, ...)
 202 {
 203   va_list ap;
 204
 205   va_start (ap, fmt);
 206   rust_be_error_at (location, expand_message (fmt, ap));
 207   va_end (ap);
 208 }
 209
 210 void
 211 rust_debug_loc (const Location location, const char *fmt, ...)
 212 {
 213   if (!rust_be_debug_p ())
 214     return;
 215
 216   va_list ap;
 217
 218   va_start (ap, fmt);
 219   char *mbuf = NULL;
 220   int nwr = vasprintf (&mbuf, fmt, ap);
 221   va_end (ap);
 222   if (nwr == -1)
 223     {
 224       rust_be_error_at (Linemap::unknown_location (),
 225                         "memory allocation failed in vasprintf");
 226       rust_assert (0);
 227     }
 228   std::string rval = std::string (mbuf);
 229   free (mbuf);
 230   rust_be_inform (location, rval);
 231 }
 232
 233 namespace Rust {
 234
 235 /**
 236  * This function takes ownership of `args` and calls `va_end` on it
 237  */
 238 static Error
 239 va_constructor (Error::Kind kind, Location locus, const char *fmt, va_list args)
 240   RUST_ATTRIBUTE_GCC_DIAG (3, 0);
 241
 242 static Error
 243 va_constructor (Error::Kind kind, Location locus, const char *fmt, va_list args)
 244 {
 245   std::string message = expand_message (fmt, args);
 246   message.shrink_to_fit ();
 247   va_end (args);
 248
 249   return Error (kind, locus, message);
 250 }
 251
 252 Error::Error (const Location location, const char *fmt, ...)
 253   : kind (Kind::Err), locus (location)
 254 {
 255   va_list ap;
 256   va_start (ap, fmt);
 257
 258   *this = va_constructor (Kind::Err, location, fmt, ap);
 259 }
 260
 261 Error
 262 Error::Hint (const Location location, const char *fmt, ...)
 263 {
 264   va_list ap;
 265   va_start (ap, fmt);
 266
 267   return va_constructor (Kind::Hint, location, fmt, ap);
 268 }
 269
 270 Error
 271 Error::Fatal (const Location location, const char *fmt, ...)
 272 {
 273   va_list ap;
 274   va_start (ap, fmt);
 275
 276   return va_constructor (Kind::FatalErr, location, fmt, ap);
 277 }
 278
 279 } // namespace Rust