1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48 package org.codehaus.groovy.tools;
49
50 import java.io.PrintStream;
51 import java.io.PrintWriter;
52
53 import org.codehaus.groovy.GroovyExceptionInterface;
54 import org.codehaus.groovy.control.CompilationFailedException;
55 import groovy.lang.GroovyRuntimeException;
56
57
58 /***
59 * Provides services for reporting compilation errors to the
60 * user. Primary entry point is <code>write()</code>.
61 *
62 * @author <a href="mailto:cpoirier%20AT%20tapestry_os%20DOT%20org">Chris Poirier</a>
63 * @version $Revision: 1.6 $
64 */
65
66 public class ErrorReporter
67 {
68 private Throwable base = null;
69 private boolean debug = false;
70
71 private Object output = null;
72
73
74 /***
75 * Configures a new Reporter. Default mode is not to report a stack trace unless
76 * the error was not of one of the supported types.
77 *
78 * @param e the exception on which to report
79 */
80
81 public ErrorReporter( Throwable e )
82 {
83 this.base = e;
84 }
85
86
87 /***
88 * Configures a new Reporter.
89 *
90 * @param e the exception on which to report
91 * @param debug if set, stack traces will be output for all reports
92 */
93
94 public ErrorReporter( Throwable e, boolean debug )
95 {
96 this.base = e;
97 this.debug = debug;
98 }
99
100
101 /***
102 * Writes the error to the specified <code>PrintStream</code>.
103 */
104
105 public void write( PrintStream stream )
106 {
107 this.output = stream;
108 dispatch( base, false );
109 stream.flush();
110 }
111
112
113 /***
114 * Writes the error to the specified <code>PrintWriter</code>.
115 */
116
117 public void write( PrintWriter writer )
118 {
119 this.output = writer;
120 dispatch( base, false );
121 writer.flush();
122 }
123
124
125 /***
126 * Runs the report once all initialization is complete.
127 */
128
129 protected void dispatch( Throwable object, boolean child )
130 {
131 if( object instanceof CompilationFailedException )
132 {
133 report( (CompilationFailedException)object, child );
134 }
135 else if( object instanceof GroovyExceptionInterface )
136 {
137 report( (GroovyExceptionInterface)object, child );
138 }
139 else if( object instanceof GroovyRuntimeException )
140 {
141 report( (GroovyRuntimeException)object, child );
142 }
143 else if( object instanceof Exception )
144 {
145 report( (Exception)object, child );
146 }
147 else
148 {
149 report( object, child );
150 }
151
152 }
153
154
155
156
157
158
159
160 /***
161 * For CompilationFailedException.
162 */
163
164 protected void report( CompilationFailedException e, boolean child )
165 {
166 println( e.toString() );
167 stacktrace( e, false );
168 }
169
170
171
172 /***
173 * For GroovyException.
174 */
175
176 protected void report( GroovyExceptionInterface e, boolean child )
177 {
178 println( ((Exception)e).getMessage() );
179 stacktrace( (Exception)e, false );
180 }
181
182
183
184 /***
185 * For Exception.
186 */
187
188 protected void report( Exception e, boolean child )
189 {
190 println( e.getMessage() );
191 stacktrace( e, false );
192 }
193
194
195
196 /***
197 * For everything else.
198 */
199
200 protected void report( Throwable e, boolean child )
201 {
202 println( ">>> a serious error occurred: " + e.getMessage() );
203 stacktrace( e, true );
204 }
205
206
207
208
209
210
211
212 /***
213 * Prints a line to the underlying <code>PrintStream</code>
214 */
215
216 protected void println( String line )
217 {
218 if( output instanceof PrintStream )
219 {
220 ((PrintStream)output).println( line );
221 }
222 else
223 {
224 ((PrintWriter)output).println( line );
225 }
226 }
227
228 protected void println( StringBuffer line )
229 {
230 if( output instanceof PrintStream )
231 {
232 ((PrintStream)output).println( line );
233 }
234 else
235 {
236 ((PrintWriter)output).println( line );
237 }
238 }
239
240
241 /***
242 * Displays an exception's stack trace, if <code>debug</code> or
243 * <code>always</code>.
244 */
245
246 protected void stacktrace( Throwable e, boolean always )
247 {
248 if( debug || always )
249 {
250 println( ">>> stacktrace:" );
251 if( output instanceof PrintStream )
252 {
253 e.printStackTrace( (PrintStream)output );
254 }
255 else
256 {
257 e.printStackTrace( (PrintWriter)output );
258 }
259 }
260 }
261
262
263
264 }