vala/valareport.vala

   1 /* valareport.vala
   2  *
   3  * Copyright (C) 2006-2010  Jürg Billeter
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  18  *
  19  * Author:
  20  *      Jürg Billeter <j@bitron.ch>
  21  */
  22
  23 using GLib;
  24
  25
  26 /**
  27  * Namespace to centralize reporting warnings and errors.
  28  */
  29 public class Vala.Report : Object {
  30         /**
  31          * SGR (Select Graphic Rendition) end tag
  32          */
  33         private const string ANSI_COLOR_END = "\x1b[0m";
  34
  35         /**
  36          * SGR (Select Graphic Rendition) start tag for source location
  37          */
  38         private string locus_color_start = "";
  39
  40         /**
  41          * SGR (Select Graphic Rendition) end tag for source location
  42          */
  43         private unowned string locus_color_end = "";
  44
  45         /**
  46          * SGR (Select Graphic Rendition) start tag for warning titles
  47          */
  48         private string warning_color_start = "";
  49
  50         /**
  51          * SGR (Select Graphic Rendition) end tag for warning titles
  52          */
  53         private unowned string warning_color_end = "";
  54
  55         /**
  56          * SGR (Select Graphic Rendition) start tag for error titles
  57          */
  58         private string error_color_start = "";
  59
  60         /**
  61          * SGR (Select Graphic Rendition) end tag for error titles
  62          */
  63         private unowned string error_color_end = "";
  64
  65         /**
  66          * SGR (Select Graphic Rendition) start tag for note titles
  67          */
  68         private string note_color_start = "";
  69
  70         /**
  71          * SGR (Select Graphic Rendition) end tag for note titles
  72          */
  73         private unowned string note_color_end = "";
  74
  75         /**
  76          * SGR (Select Graphic Rendition) start tag for caret line (^^^)
  77          */
  78         private string caret_color_start = "";
  79
  80         /**
  81          * SGR (Select Graphic Rendition) end tag for caret line (^^^)
  82          */
  83         private unowned string caret_color_end = "";
  84
  85         /**
  86          * SGR (Select Graphic Rendition) start tag for quotes line ('...', `...`, `...')
  87          */
  88         private string quote_color_start = "";
  89
  90         /**
  91          * SGR (Select Graphic Rendition) end tag for quotes line ('...', `...`, `...')
  92          */
  93         private unowned string quote_color_end = "";
  94
  95
  96         protected int warnings;
  97         protected int errors;
  98
  99         private bool verbose_errors;
 100
 101         public bool enable_warnings { get; set; default = true; }
 102
 103         static GLib.Regex val_regex;
 104
 105         /**
 106          * Set all colors by string
 107          *
 108          * {{{
 109          *   "error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01"
 110          * }}}
 111          */
 112         public bool set_colors (string str) {
 113                 try {
 114                         if (val_regex == null)
 115                                 val_regex = new Regex ("^\\s*[0-9]+(;[0-9]*)*\\s*$");
 116                 } catch (RegexError e) {
 117                         assert_not_reached ();
 118                 }
 119
 120                 string error_color = null;
 121                 string warning_color = null;
 122                 string note_color = null;
 123                 string caret_color = null;
 124                 string locus_color = null;
 125                 string quote_color = null;
 126
 127                 string[] fragments = str.split (":");
 128                 foreach (unowned string fragment in fragments) {
 129                         string[] eq = fragment.split ("=", 2);
 130                         if (eq.length != 2) {
 131                                 return false;
 132                         }
 133
 134                         if (!val_regex.match (eq[1])) {
 135                                 return false;
 136                         }
 137
 138
 139                         unowned string checked_value = eq[1]._strip ();
 140                         switch (eq[0]._strip ()) {
 141                         case "error":
 142                                 error_color = checked_value;
 143                                 break;
 144
 145                         case "warning":
 146                                 warning_color = checked_value;
 147                                 break;
 148
 149                         case "note":
 150                                 note_color = checked_value;
 151                                 break;
 152
 153                         case "caret":
 154                                 caret_color = checked_value;
 155                                 break;
 156
 157                         case "locus":
 158                                 locus_color = checked_value;
 159                                 break;
 160
 161                         case "quote":
 162                                 quote_color = checked_value;
 163                                 break;
 164
 165                         default:
 166                                 return false;
 167                         }
 168                 }
 169
 170                 if (is_atty (stderr.fileno ())) {
 171                         if (error_color != null) {
 172                                 this.error_color_start = "\x1b[0" + error_color + "m";
 173                                 this.error_color_end = ANSI_COLOR_END;
 174                         }
 175
 176                         if (warning_color != null) {
 177                                 this.warning_color_start = "\x1b[0" + warning_color + "m";
 178                                 this.warning_color_end = ANSI_COLOR_END;
 179                         }
 180
 181                         if (note_color != null) {
 182                                 this.note_color_start = "\x1b[0" + note_color + "m";
 183                                 this.note_color_end = ANSI_COLOR_END;
 184                         }
 185
 186                         if (caret_color != null) {
 187                                 this.caret_color_start = "\x1b[0" + caret_color + "m";
 188                                 this.caret_color_end = ANSI_COLOR_END;
 189                         }
 190
 191                         if (locus_color != null) {
 192                                 this.locus_color_start = "\x1b[0" + locus_color + "m";
 193                                 this.locus_color_end = ANSI_COLOR_END;
 194                         }
 195
 196                         if (quote_color != null) {
 197                                 this.quote_color_start = "\x1b[0" + quote_color + "m";
 198                                 this.quote_color_end = ANSI_COLOR_END;
 199                         }
 200                 }
 201                 return true;
 202         }
 203
 204         /**
 205          * Set the error verbosity.
 206          */
 207         public void set_verbose_errors (bool verbose) {
 208                 verbose_errors = verbose;
 209         }
 210
 211         /**
 212          * Returns the total number of warnings reported.
 213          */
 214         public int get_warnings () {
 215                 return warnings;
 216         }
 217
 218         /**
 219          * Returns the total number of errors reported.
 220          */
 221         public int get_errors () {
 222                 return errors;
 223         }
 224
 225         /**
 226          * Pretty-print the actual line of offending code if possible.
 227          */
 228         private void report_source (SourceReference source) {
 229                 if (source.begin.line != source.end.line) {
 230                         // FIXME Cannot report multi-line issues currently
 231                         return;
 232                 }
 233
 234                 string offending_line = source.file.get_source_line (source.begin.line);
 235
 236                 if (offending_line != null) {
 237                         stderr.printf ("%s\n", offending_line);
 238                         int idx;
 239
 240                         /* We loop in this manner so that we don't fall over on differing
 241                          * tab widths. This means we get the ^s in the right places.
 242                          */
 243                         for (idx = 1; idx < source.begin.column; ++idx) {
 244                                 if (offending_line[idx - 1] == '\t') {
 245                                         stderr.printf ("\t");
 246                                 } else {
 247                                         stderr.printf (" ");
 248                                 }
 249                         }
 250
 251                         stderr.puts (caret_color_start);
 252                         for (idx = source.begin.column; idx <= source.end.column; ++idx) {
 253                                 if (offending_line[idx - 1] == '\t') {
 254                                         stderr.printf ("\t");
 255                                 } else {
 256                                         stderr.printf ("^");
 257                                 }
 258                         }
 259                         stderr.puts (caret_color_end);
 260
 261                         stderr.printf ("\n");
 262                 }
 263         }
 264
 265         private void print_highlighted_message (string message) {
 266                 int start = 0;
 267                 int cur = 0;
 268
 269                 while (message[cur] != '\0') {
 270                         if (message[cur] == '\'' || message[cur] == '`') {
 271                                 unowned string end_chars = (message[cur] == '`')? "`'" : "'";
 272                                 stderr.puts (message.substring (start, cur - start));
 273                                 start = cur;
 274                                 cur++;
 275
 276                                 while (message[cur] != '\0' && end_chars.index_of_char (message[cur]) < 0) {
 277                                         cur++;
 278                                 }
 279                                 if (message[cur] == '\0') {
 280                                         stderr.puts (message.substring (start, cur - start));
 281                                         start = cur;
 282                                 } else {
 283                                         cur++;
 284                                         stderr.printf ("%s%s%s", quote_color_start, message.substring (start, cur - start), quote_color_end);
 285                                         start = cur;
 286                                 }
 287                         } else {
 288                                 cur++;
 289                         }
 290                 }
 291
 292                 stderr.puts (message.offset (start));
 293         }
 294
 295         private void print_message (SourceReference? source, string type, string type_color_start, string type_color_end, string message, bool do_report_source) {
 296                 if (source != null) {
 297                         stderr.printf ("%s%s:%s ", locus_color_start, source.to_string (), locus_color_end);
 298                 }
 299
 300                 stderr.printf ("%s%s:%s ", type_color_start, type, type_color_end);
 301
 302                 // highlight '', `', ``
 303                 print_highlighted_message (message);
 304                 stderr.putc ('\n');
 305
 306                 if (do_report_source && source != null) {
 307                         report_source (source);
 308                 }
 309         }
 310
 311         /**
 312          * Reports the specified message as note.
 313          *
 314          * @param source  reference to source code
 315          * @param message note message
 316          */
 317         public virtual void note (SourceReference? source, string message) {
 318                 if (!enable_warnings) {
 319                         return;
 320                 }
 321
 322                 print_message (source, "note", note_color_start, note_color_end, message, verbose_errors);
 323         }
 324
 325         /**
 326          * Reports the specified message as deprecation warning.
 327          *
 328          * @param source  reference to source code
 329          * @param message warning message
 330          */
 331         public virtual void depr (SourceReference? source, string message) {
 332                 if (!enable_warnings) {
 333                         return;
 334                 }
 335
 336                 warnings++;
 337
 338                 print_message (source, "warning", warning_color_start, warning_color_end, message, false);
 339         }
 340
 341         /**
 342          * Reports the specified message as warning.
 343          *
 344          * @param source  reference to source code
 345          * @param message warning message
 346          */
 347         public virtual void warn (SourceReference? source, string message) {
 348                 if (!enable_warnings) {
 349                         return;
 350                 }
 351
 352                 warnings++;
 353
 354                 print_message (source, "warning", warning_color_start, warning_color_end, message, verbose_errors);
 355         }
 356
 357         /**
 358          * Reports the specified message as error.
 359          *
 360          * @param source  reference to source code
 361          * @param message error message
 362          */
 363         public virtual void err (SourceReference? source, string message) {
 364                 errors++;
 365
 366                 print_message (source, "error", error_color_start, error_color_end, message, verbose_errors);
 367         }
 368
 369         /* Convenience methods calling warn and err on correct instance */
 370         public static void notice (SourceReference? source, string message) {
 371                 CodeContext.get ().report.note (source, message);
 372         }
 373         public static void deprecated (SourceReference? source, string message) {
 374                 CodeContext.get ().report.depr (source, message);
 375         }
 376         public static void experimental (SourceReference? source, string message) {
 377                 CodeContext.get ().report.depr (source, message);
 378         }
 379         public static void warning (SourceReference? source, string message) {
 380                 CodeContext.get ().report.warn (source, message);
 381         }
 382         public static void error (SourceReference? source, string message) {
 383                 CodeContext.get ().report.err (source, message);
 384         }
 385
 386
 387         [CCode (has_target = false)]
 388         private delegate int AttyFunc (int fd);
 389
 390         private bool is_atty (int fd) {
 391                 Module module = Module.open (null, ModuleFlags.BIND_LAZY);
 392                 if (module == null) {
 393                         return false;
 394                 }
 395
 396                 void* _func;
 397                 module.symbol ("isatty", out _func);
 398                 if (_func == null) {
 399                         return false;
 400                 }
 401
 402                 AttyFunc? func = (AttyFunc) _func;
 403                 return func (fd) == 1;
 404         }
 405 }