mcs/mcs/report.cs

   1 //
   2 // report.cs: report errors and warnings.
   3 //
   4 // Author: Miguel de Icaza (miguel@ximian.com)
   5 //
   6 // (C) 2001 Ximian, Inc. (http://www.ximian.com)
   7 //
   8
   9 //
  10 // FIXME: currently our class library does not support custom number format strings
  11 //
  12 using System;
  13 using System.Collections;
  14 using System.Diagnostics;
  15
  16 namespace Mono.CSharp {
  17
  18         /// <summary>
  19         ///   This class is used to report errors and warnings t te user.
  20         /// </summary>
  21         public class Report {
  22                 /// <summary>
  23                 ///   Errors encountered so far
  24                 /// </summary>
  25                 static public int Errors;
  26
  27                 /// <summary>
  28                 ///   Warnings encountered so far
  29                 /// </summary>
  30                 static public int Warnings;
  31
  32                 /// <summary>
  33                 ///   Whether errors should be throw an exception
  34                 /// </summary>
  35                 static public bool Fatal;
  36
  37                 /// <summary>
  38                 ///   Whether warnings should be considered errors
  39                 /// </summary>
  40                 static public bool WarningsAreErrors;
  41
  42                 /// <summary>
  43                 ///   Whether to dump a stack trace on errors.
  44                 /// </summary>
  45                 static public bool Stacktrace;
  46
  47                 //
  48                 // If the error code is reported on the given line,
  49                 // then the process exits with a unique error code.
  50                 //
  51                 // Used for the test suite to excercise the error codes
  52                 //
  53                 static int probe_error = 0;
  54
  55                 //
  56                 // Keeps track of the warnings that we are ignoring
  57                 //
  58                 static Hashtable warning_ignore_table;
  59
  60                 static void Check (int code)
  61                 {
  62                         if (code == probe_error){
  63                                 if (Fatal)
  64                                         throw new Exception ();
  65
  66                                 Environment.Exit (123);
  67                         }
  68                 }
  69
  70                 static public void RealError (string msg)
  71                 {
  72                         Errors++;
  73                         Console.WriteLine (msg);
  74
  75                         if (Stacktrace)
  76                                 Console.WriteLine (new StackTrace ().ToString ());
  77                         if (Fatal)
  78                                 throw new Exception (msg);
  79                 }
  80
  81                 static public void Error (int code, Location l, string text)
  82                 {
  83                         string msg = String.Format (
  84 //                              "{0}({1}) error CS{2:0000}: {3}", l.Name, l.Row, code, text);
  85                                 "{0}({1}) error CS{2}: {3}", l.Name, l.Row, code, text);
  86
  87                         RealError (msg);
  88                         Check (code);
  89                 }
  90
  91                 static public void Warning (int code, Location l, string text)
  92                 {
  93                         if (warning_ignore_table != null){
  94                                 if (warning_ignore_table.Contains (code))
  95                                         return;
  96                         }
  97
  98                         if (WarningsAreErrors)
  99                                 Error (code, l, text);
 100                         else {
 101                                 string row;
 102
 103                                 if (Location.IsNull (l))
 104                                         row = "";
 105                                 else
 106                                         row = l.Row.ToString ();
 107
 108                                 Console.WriteLine (String.Format (
 109 //                                      "{0}({1}) warning CS{2:0000}: {3}",
 110                                         "{0}({1}) warning CS{2}: {3}",
 111                                         l.Name,  row, code, text));
 112                                 Warnings++;
 113                                 Check (code);
 114                         }
 115                 }
 116
 117                 static public void Warning (int code, string text)
 118                 {
 119                         Warning (code, Location.Null, text);
 120                 }
 121
 122                 static public void Error (int code, string text)
 123                 {
 124 //                      string msg = String.Format ("error CS{0:0000}: {1}", code, text);
 125                         string msg = String.Format ("error CS{0}: {1}", code, text);
 126
 127                         RealError (msg);
 128                         Check (code);
 129                 }
 130
 131                 static public void Message (Message m)
 132                 {
 133                         if (m is ErrorMessage)
 134                                 Error (m.code, m.text);
 135                         else
 136                                 Warning (m.code, m.text);
 137                 }
 138
 139                 static public void SetIgnoreWarning (int code)
 140                 {
 141                         if (warning_ignore_table == null)
 142                                 warning_ignore_table = new Hashtable ();
 143
 144                         warning_ignore_table [code] = true;
 145                 }
 146
 147                 static public void SetProbe (int code)
 148                 {
 149                         probe_error = code;
 150                 }
 151
 152                 static public int ProbeCode {
 153                         get {
 154                                 return probe_error;
 155                         }
 156                 }
 157         }
 158
 159         public class Message {
 160                 public int code;
 161                 public string text;
 162
 163                 public Message (int code, string text)
 164                 {
 165                         this.code = code;
 166                         this.text = text;
 167                 }
 168         }
 169
 170         public class WarningMessage : Message {
 171                 public WarningMessage (int code, string text) : base (code, text)
 172                 {
 173                 }
 174         }
 175
 176         public class ErrorMessage : Message {
 177                 public ErrorMessage (int code, string text) : base (code, text)
 178                 {
 179                 }
 180
 181                 //
 182                 // For compatibility reasons with old code.
 183                 //
 184                 public static void report_error (string error)
 185                 {
 186                         Console.Write ("ERROR: ");
 187                         Console.WriteLine (error);
 188                 }
 189         }
 190 }
 191
 192