?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* Version.cs (CompareTo, Equals): Make sure the versions for
[mono-project.git] / mcs / gmcs / report.cs
blobd3a533c83498942f3e6dced42112ed51ccb1267a
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.Text;
14 using System.Collections;
15 using System.Collections.Specialized;
16 using System.Diagnostics;
17 using System.Reflection;
18
19 namespace Mono.CSharp {
20
21 /// <summary>
22 /// This class is used to report errors and warnings t te user.
23 /// </summary>
24 public class Report {
25 /// <summary>
26 /// Errors encountered so far
27 /// </summary>
28 static public int Errors;
29
30 /// <summary>
31 /// Warnings encountered so far
32 /// </summary>
33 static public int Warnings;
34
35 /// <summary>
36 /// Whether errors should be throw an exception
37 /// </summary>
38 static public bool Fatal;
39
40 /// <summary>
41 /// Whether warnings should be considered errors
42 /// </summary>
43 static public bool WarningsAreErrors;
44
45 /// <summary>
46 /// Whether to dump a stack trace on errors.
47 /// </summary>
48 static public bool Stacktrace;
49
50 //
51 // If the 'expected' error code is reported then the
52 // compilation succeeds.
53 //
54 // Used for the test suite to excercise the error codes
55 //
56 static int expected_error = 0;
57
58 //
59 // Keeps track of the warnings that we are ignoring
60 //
61 static Hashtable warning_ignore_table;
62
63 static Hashtable warning_regions_table;
64
65 /// <summary>
66 /// List of symbols related to reported error/warning. You have to fill it before error/warning is reported.
67 /// </summary>
68 static StringCollection extra_information = new StringCollection ();
69
70 abstract class AbstractMessage {
71
72 static void Check (int code)
73 {
74 if (code == expected_error) {
75 Environment.Exit (0);
76 }
77 }
78
79 public abstract bool IsWarning { get; }
80
81 public abstract string MessageType { get; }
82
83 public virtual void Print (int code, string location, string text)
84 {
85 if (code < 0)
86 code = 8000-code;
87
88 StringBuilder msg = new StringBuilder ();
89 if (location.Length != 0) {
90 msg.Append (location);
91 msg.Append (' ');
92 }
93 msg.AppendFormat ("{0} CS{1:0000}: {2}", MessageType, code, text);
94 Console.Error.WriteLine (msg.ToString ());
95
96 foreach (string s in extra_information)
97 Console.Error.WriteLine (s + MessageType);
98
99 extra_information.Clear ();
100
101 if (Stacktrace)
102 Console.WriteLine (FriendlyStackTrace (new StackTrace (true)));
103
104 if (Fatal) {
105 if (!IsWarning || WarningsAreErrors)
106 throw new Exception (text);
107 }
108
109 Check (code);
110 }
111
112 public virtual void Print (int code, Location location, string text)
113 {
114 if (location.Equals (Location.Null)) {
115 Print (code, "", text);
116 return;
117 }
118 Print (code, String.Format ("{0}({1})", location.Name, location.Row), text);
119 }
120 }
121
122 sealed class WarningMessage: AbstractMessage {
123 Location loc = Location.Null;
124 readonly int Level;
125
126 public WarningMessage ():
127 this (-1) {}
128
129 public WarningMessage (int level)
130 {
131 Level = level;
132 }
133
134 public override bool IsWarning {
135 get { return true; }
136 }
137
138 bool IsEnabled (int code)
139 {
140 if (RootContext.WarningLevel < Level)
141 return false;
142
143 if (warning_ignore_table != null) {
144 if (warning_ignore_table.Contains (code)) {
145 return false;
146 }
147 }
148
149 if (warning_regions_table == null || loc.Equals (Location.Null))
150 return true;
151
152 WarningRegions regions = (WarningRegions)warning_regions_table [loc.Name];
153 return regions.IsWarningEnabled (code, loc.Row);
154 }
155
156 public override void Print(int code, string location, string text)
157 {
158 if (!IsEnabled (code)) {
159 extra_information.Clear ();
160 return;
161 }
162
163 if (WarningsAreErrors) {
164 new ErrorMessage ().Print (code, location, text);
165 return;
166 }
167
168 Warnings++;
169 base.Print (code, location, text);
170 }
171
172 public override void Print(int code, Location location, string text)
173 {
174 loc = location;
175 base.Print (code, location, text);
176 }
177
178 public override string MessageType {
179 get {
180 return "warning";
181 }
182 }
183 }
184
185 sealed class ErrorMessage: AbstractMessage {
186
187 public override void Print(int code, string location, string text)
188 {
189 Errors++;
190 base.Print (code, location, text);
191 }
192
193 public override bool IsWarning {
194 get { return false; }
195 }
196
197 public override string MessageType {
198 get {
199 return "error";
200 }
201 }
202
203 }
204
205 public static void FeatureIsNotStandardized (Location loc, string feature)
206 {
207 Report.Error (1644, loc, "Feature '{0}' cannot be used because it is not part of the standardized ISO C# language specification", feature);
208 }
209
210 public static string FriendlyStackTrace (Exception e)
211 {
212 return FriendlyStackTrace (new StackTrace (e, true));
213 }
214
215 static string FriendlyStackTrace (StackTrace t)
216 {
217 StringBuilder sb = new StringBuilder ();
218
219 bool foundUserCode = false;
220
221 for (int i = 0; i < t.FrameCount; i++) {
222 StackFrame f = t.GetFrame (i);
223 MethodBase mb = f.GetMethod ();
224
225 if (!foundUserCode && mb.ReflectedType == typeof (Report))
226 continue;
227
228 foundUserCode = true;
229
230 sb.Append ("\tin ");
231
232 if (f.GetFileLineNumber () > 0)
233 sb.AppendFormat ("(at {0}:{1}) ", f.GetFileName (), f.GetFileLineNumber ());
234
235 sb.AppendFormat ("{0}.{1} (", mb.ReflectedType.Name, mb.Name);
236
237 bool first = true;
238 foreach (ParameterInfo pi in mb.GetParameters ()) {
239 if (!first)
240 sb.Append (", ");
241 first = false;
242
243 sb.Append (TypeManager.CSharpName (pi.ParameterType));
244 }
245 sb.Append (")\n");
246 }
247
248 return sb.ToString ();
249 }
250
251 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
252 // IF YOU ADD A NEW WARNING YOU HAVE TO DUPLICATE ITS ID HERE
253 //
254 public static bool IsValidWarning (int code)
255 {
256 int[] all_warnings = new int[] {
257 28, 67, 78, 105, 108, 109, 114, 192, 168, 169, 183, 184, 219, 251, 612, 618, 626, 628, 642, 649,
258 659, 660, 661, 672, 1030, 1522, 1616, 1691, 1692, 1901, 2002, 2023, 3012, 3019, 8024, 8028
259 };
260
261 foreach (int i in all_warnings) {
262 if (i == code)
263 return true;
264 }
265 return false;
266 }
267
268 static public void LocationOfPreviousError (Location loc)
269 {
270 Console.Error.WriteLine (String.Format ("{0}({1}) (Location of symbol related to previous error)", loc.Name, loc.Row));
271 }
272
273 static public void RuntimeMissingSupport (Location loc, string feature)
274 {
275 Report.Error (-88, loc, "Your .NET Runtime does not support '{0}'. Please use the latest Mono runtime instead.", feature);
276 }
277
278 /// <summary>
279 /// In most error cases is very useful to have information about symbol that caused the error.
280 /// Call this method before you call Report.Error when it makes sense.
281 /// </summary>
282 static public void SymbolRelatedToPreviousError (Location loc, string symbol)
283 {
284 SymbolRelatedToPreviousError (String.Format ("{0}({1})", loc.Name, loc.Row), symbol);
285 }
286
287 static public void SymbolRelatedToPreviousError (MemberInfo mi)
288 {
289 TypeContainer temp_ds = TypeManager.LookupGenericTypeContainer (mi.DeclaringType);
290 if (temp_ds == null) {
291 SymbolRelatedToPreviousError (mi.DeclaringType.Assembly.Location, TypeManager.GetFullNameSignature (mi));
292 } else {
293 MethodBase mb = mi as MethodBase;
294 if (mb != null) {
295 while (mb.Mono_IsInflatedMethod)
296 mb = mb.GetGenericMethodDefinition ();
297 IMethodData md = TypeManager.GetMethod (mb);
298 SymbolRelatedToPreviousError (md.Location, md.GetSignatureForError (temp_ds));
299 return;
300 }
301
302 string name = String.Concat (temp_ds.Name, ".", mi.Name);
303 MemberCore mc = temp_ds.GetDefinition (name);
304 SymbolRelatedToPreviousError (mc);
305 }
306 }
307
308 static public void SymbolRelatedToPreviousError (MemberCore mc)
309 {
310 SymbolRelatedToPreviousError (mc.Location, mc.GetSignatureForError ());
311 }
312
313 static public void SymbolRelatedToPreviousError (Type type)
314 {
315 DeclSpace temp_ds = TypeManager.LookupDeclSpace (type);
316 if (temp_ds == null)
317 SymbolRelatedToPreviousError (type.Assembly.Location, TypeManager.CSharpName (type));
318 else
319 SymbolRelatedToPreviousError (temp_ds.Location, TypeManager.CSharpName (type));
320 }
321
322 static void SymbolRelatedToPreviousError (string loc, string symbol)
323 {
324 extra_information.Add (String.Format ("{0}: '{1}' (name of symbol related to previous ", loc, symbol));
325 }
326
327 public static void ExtraInformation (Location loc, string msg)
328 {
329 extra_information.Add (String.Format ("{0}({1}) {2}", loc.Name, loc.Row, msg));
330 }
331
332 public static WarningRegions RegisterWarningRegion (Location location)
333 {
334 if (warning_regions_table == null)
335 warning_regions_table = new Hashtable ();
336
337 WarningRegions regions = (WarningRegions)warning_regions_table [location.Name];
338 if (regions == null) {
339 regions = new WarningRegions ();
340 warning_regions_table.Add (location.Name, regions);
341 }
342 return regions;
343 }
344
345 static public void Warning (int code, int level, Location loc, string format, params object[] args)
346 {
347 WarningMessage w = new WarningMessage (level);
348 w.Print (code, loc, String.Format (format, args));
349 }
350
351 static public void Warning (int code, Location loc, string format, params object[] args)
352 {
353 WarningMessage w = new WarningMessage ();
354 w.Print (code, loc, String.Format (format, args));
355 }
356
357 static public void Warning (int code, string format, params object[] args)
358 {
359 Warning (code, Location.Null, String.Format (format, args));
360 }
361
362 /// <summary>
363 /// Did you test your WarningLevel, that you use this method
364 /// </summary>
365 static public void Warning (int code, string text)
366 {
367 Warning (code, Location.Null, text);
368 }
369
370 static public void Error (int code, string format, params object[] args)
371 {
372 Error (code, Location.Null, String.Format (format, args));
373 }
374
375 static public void Error (int code, Location loc, string format, params object[] args)
376 {
377 ErrorMessage e = new ErrorMessage ();
378 e.Print (code, loc, String.Format (format, args));
379 }
380
381 static public void SetIgnoreWarning (int code)
382 {
383 if (warning_ignore_table == null)
384 warning_ignore_table = new Hashtable ();
385
386 warning_ignore_table [code] = true;
387 }
388
389 static public int ExpectedError {
390 set {
391 expected_error = value;
392 }
393 get {
394 return expected_error;
395 }
396 }
397
398 public static int DebugFlags = 0;
399
400 [Conditional ("MCS_DEBUG")]
401 static public void Debug (string message, params object[] args)
402 {
403 Debug (4, message, args);
404 }
405
406 [Conditional ("MCS_DEBUG")]
407 static public void Debug (int category, string message, params object[] args)
408 {
409 if ((category & DebugFlags) == 0)
410 return;
411
412 StringBuilder sb = new StringBuilder (message);
413
414 if ((args != null) && (args.Length > 0)) {
415 sb.Append (": ");
416
417 bool first = true;
418 foreach (object arg in args) {
419 if (first)
420 first = false;
421 else
422 sb.Append (", ");
423 if (arg == null)
424 sb.Append ("null");
425 else if (arg is ICollection)
426 sb.Append (PrintCollection ((ICollection) arg));
427 else
428 sb.Append (arg);
429 }
430 }
431
432 Console.WriteLine (sb.ToString ());
433 }
434
435 static public string PrintCollection (ICollection collection)
436 {
437 StringBuilder sb = new StringBuilder ();
438
439 sb.Append (collection.GetType ());
440 sb.Append ("(");
441
442 bool first = true;
443 foreach (object o in collection) {
444 if (first)
445 first = false;
446 else
447 sb.Append (", ");
448 sb.Append (o);
449 }
450
451 sb.Append (")");
452 return sb.ToString ();
453 }
454 }
455
456 public enum TimerType {
457 FindMembers = 0,
458 TcFindMembers = 1,
459 MemberLookup = 2,
460 CachedLookup = 3,
461 CacheInit = 4,
462 MiscTimer = 5,
463 CountTimers = 6
464 }
465
466 public enum CounterType {
467 FindMembers = 0,
468 MemberCache = 1,
469 MiscCounter = 2,
470 CountCounters = 3
471 }
472
473 public class Timer
474 {
475 static DateTime[] timer_start;
476 static TimeSpan[] timers;
477 static long[] timer_counters;
478 static long[] counters;
479
480 static Timer ()
481 {
482 timer_start = new DateTime [(int) TimerType.CountTimers];
483 timers = new TimeSpan [(int) TimerType.CountTimers];
484 timer_counters = new long [(int) TimerType.CountTimers];
485 counters = new long [(int) CounterType.CountCounters];
486
487 for (int i = 0; i < (int) TimerType.CountTimers; i++) {
488 timer_start [i] = DateTime.Now;
489 timers [i] = TimeSpan.Zero;
490 }
491 }
492
493 [Conditional("TIMER")]
494 static public void IncrementCounter (CounterType which)
495 {
496 ++counters [(int) which];
497 }
498
499 [Conditional("TIMER")]
500 static public void StartTimer (TimerType which)
501 {
502 timer_start [(int) which] = DateTime.Now;
503 }
504
505 [Conditional("TIMER")]
506 static public void StopTimer (TimerType which)
507 {
508 timers [(int) which] += DateTime.Now - timer_start [(int) which];
509 ++timer_counters [(int) which];
510 }
511
512 [Conditional("TIMER")]
513 static public void ShowTimers ()
514 {
515 ShowTimer (TimerType.FindMembers, "- FindMembers timer");
516 ShowTimer (TimerType.TcFindMembers, "- TypeContainer.FindMembers timer");
517 ShowTimer (TimerType.MemberLookup, "- MemberLookup timer");
518 ShowTimer (TimerType.CachedLookup, "- CachedLookup timer");
519 ShowTimer (TimerType.CacheInit, "- Cache init");
520 ShowTimer (TimerType.MiscTimer, "- Misc timer");
521
522 ShowCounter (CounterType.FindMembers, "- Find members");
523 ShowCounter (CounterType.MemberCache, "- Member cache");
524 ShowCounter (CounterType.MiscCounter, "- Misc counter");
525 }
526
527 static public void ShowCounter (CounterType which, string msg)
528 {
529 Console.WriteLine ("{0} {1}", counters [(int) which], msg);
530 }
531
532 static public void ShowTimer (TimerType which, string msg)
533 {
534 Console.WriteLine (
535 "[{0:00}:{1:000}] {2} (used {3} times)",
536 (int) timers [(int) which].TotalSeconds,
537 timers [(int) which].Milliseconds, msg,
538 timer_counters [(int) which]);
539 }
540 }
541
542 public class InternalErrorException : Exception {
543 public InternalErrorException ()
544 : base ("Internal error")
545 {
546 }
547
548 public InternalErrorException (string message)
549 : base (message)
550 {
551 }
552 }
553
554 /// <summary>
555 /// Handles #pragma warning
556 /// </summary>
557 public class WarningRegions {
558
559 abstract class PragmaCmd
560 {
561 public int Line;
562
563 protected PragmaCmd (int line)
564 {
565 Line = line;
566 }
567
568 public abstract bool IsEnabled (int code, bool previous);
569 }
570
571 class Disable: PragmaCmd
572 {
573 int code;
574 public Disable (int line, int code)
575 : base (line)
576 {
577 this.code = code;
578 }
579
580 public override bool IsEnabled (int code, bool previous)
581 {
582 return this.code == code ? false : previous;
583 }
584 }
585
586 class DisableAll: PragmaCmd
587 {
588 public DisableAll (int line)
589 : base (line) {}
590
591 public override bool IsEnabled(int code, bool previous)
592 {
593 return false;
594 }
595 }
596
597 class Enable: PragmaCmd
598 {
599 int code;
600 public Enable (int line, int code)
601 : base (line)
602 {
603 this.code = code;
604 }
605
606 public override bool IsEnabled(int code, bool previous)
607 {
608 return this.code == code ? true : previous;
609 }
610 }
611
612 class EnableAll: PragmaCmd
613 {
614 public EnableAll (int line)
615 : base (line) {}
616
617 public override bool IsEnabled(int code, bool previous)
618 {
619 return true;
620 }
621 }
622
623
624 ArrayList regions = new ArrayList ();
625
626 public void WarningDisable (int line)
627 {
628 regions.Add (new DisableAll (line));
629 }
630
631 public void WarningDisable (Location location, int code)
632 {
633 if (CheckWarningCode (code, location))
634 regions.Add (new Disable (location.Row, code));
635 }
636
637 public void WarningEnable (int line)
638 {
639 regions.Add (new EnableAll (line));
640 }
641
642 public void WarningEnable (Location location, int code)
643 {
644 if (CheckWarningCode (code, location))
645 regions.Add (new Enable (location.Row, code));
646 }
647
648 public bool IsWarningEnabled (int code, int src_line)
649 {
650 bool result = true;
651 foreach (PragmaCmd pragma in regions) {
652 if (src_line < pragma.Line)
653 break;
654
655 result = pragma.IsEnabled (code, result);
656 }
657 return result;
658 }
659
660 bool CheckWarningCode (int code, Location loc)
661 {
662 if (Report.IsValidWarning (code))
663 return true;
664
665 Report.Warning (1691, 1, loc, "'{0}' is not a valid warning number", code);
666 return false;
667 }
668 }
669 }
Mirror of the official Mono project git repository