Java > Open Source Codes > org > codehaus > groovy > control > CompilerConfiguration


1 /*
2  $Id: CompilerConfiguration.java,v 1.2 2004/04/20 01:32:07 cpoirier Exp $
3
4  Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
5
6  Redistribution and use of this software and associated documentation
7  ("Software"), with or without modification, are permitted provided
8  that the following conditions are met:
9
10  1. Redistributions of source code must retain copyright
11     statements and notices. Redistributions must also contain a
12     copy of this document.
13
14  2. Redistributions in binary form must reproduce the
15     above copyright notice, this list of conditions and the
16     following disclaimer in the documentation and/or other
17     materials provided with the distribution.
18
19  3. The name "groovy" must not be used to endorse or promote
20     products derived from this Software without prior written
21     permission of The Codehaus. For written permission,
22     please contact info@codehaus.org.
23
24  4. Products derived from this Software may not be called "groovy"
25     nor may "groovy" appear in their names without prior written
26     permission of The Codehaus. "groovy" is a registered
27     trademark of The Codehaus.
28
29  5. Due credit should be given to The Codehaus -
30     http://groovy.codehaus.org/
31
32  THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
33  ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
34  NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
35  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
36  THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41  STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43  OF THE POSSIBILITY OF SUCH DAMAGE.
44
45  */
46
47 package org.codehaus.groovy.control;
48
49 import java.io.File ;
50 import java.io.PrintWriter ;
51 import java.util.LinkedList ;
52 import java.util.List ;
53 import java.util.Properties ;
54 import java.util.StringTokenizer ;
55
56 import org.codehaus.groovy.control.io.NullWriter;
57 import org.codehaus.groovy.control.messages.WarningMessage;
58
59
60
61
62 /**
63  * Compilation control flags and coordination stuff.
64  *
65  * @author <a HREF="mailto:cpoirier@dreaming.org">Chris Poirier</a>
66  *
67  * @version $Id: CompilerConfiguration.java,v 1.2 2004/04/20 01:32:07 cpoirier Exp $
68  */
69
70 public class CompilerConfiguration
71 {
72     public static final CompilerConfiguration DEFAULT = new CompilerConfiguration();
73     
74     private int warningLevel; // See WarningMessage for levels
75 private String sourceEncoding; // Encoding for source files
76 private PrintWriter output; // A PrintWriter for communicating with the user
77 private File targetDirectory; // Directory into which to write classes
78 private LinkedList classpath; // Classpath for use during compilation
79 private boolean verbose; // If true, the compiler should produce action information
80 private boolean debug; // If true, debugging code should be activated
81 private int tolerance; // The number of non-fatal errors to allow before bailing
82 private String scriptBaseClass; // Base class name for scripts (must derive from Script)
83
84     
85     
86    /**
87     * Sets the Flags to defaults.
88     */
89     
90     public CompilerConfiguration()
91     {
92         //
93 // Set in safe defaults
94
95         setWarningLevel( WarningMessage.LIKELY_ERRORS );
96         setSourceEncoding( "US-ASCII" );
97         setOutput( null );
98         setTargetDirectory( (File )null );
99         setClasspath( "" );
100         setVerbose( false );
101         setDebug( false );
102         setTolerance( 10 );
103         setScriptBaseClass( null );
104
105         
106         //
107 // Try for better defaults, ignore errors.
108
109         try { setSourceEncoding( System.getProperty("file.encoding", "US-ASCII") ); } catch( Exception e ) {}
110         try { setOutput( new PrintWriter (System.err) ); } catch( Exception e ) {}
111         try { setClasspath( System.getProperty("java.class.path") ); } catch( Exception e ) {}
112
113         try
114         {
115             String target = System.getProperty( "groovy.target.directory" );
116             if( target != null )
117             {
118                 setTargetDirectory( target );
119             }
120         }
121         catch( Exception e ) {}
122     }
123     
124    
125    /**
126     * Sets the Flags to the specified configuration, with defaults
127     * for those not supplied.
128     */
129     
130     public CompilerConfiguration( Properties configuration ) throws ConfigurationException
131     {
132         this();
133         
134         String text = null;
135         int numeric = 0;
136
137         
138         //
139 // Warning level
140
141         numeric = getWarningLevel();
142         try
143         {
144             text = configuration.getProperty( "groovy.warnings", "likely errors" );
145             numeric = Integer.parseInt( text );
146         }
147         catch( NumberFormatException e )
148         {
149             if( text.equals("none") )
150             {
151                 numeric = WarningMessage.NONE;
152             }
153             else if( text.startsWith("likely") )
154             {
155                 numeric = WarningMessage.LIKELY_ERRORS;
156             }
157             else if( text.startsWith("possible") )
158             {
159                 numeric = WarningMessage.POSSIBLE_ERRORS;
160             }
161             else if( text.startsWith("paranoia") )
162             {
163                 numeric = WarningMessage.PARANOIA;
164             }
165             else
166             {
167                 throw new ConfigurationException( "unrecogized groovy.warnings: " + text );
168             }
169         }
170         
171         setWarningLevel( numeric );
172         
173         
174         //
175 // Source file encoding
176
177         text = configuration.getProperty( "groovy.source.encoding" );
178         if( text != null )
179         {
180             setSourceEncoding( text );
181         }
182         
183         
184         //
185 // Target directory for classes
186
187         text = configuration.getProperty( "groovy.target.directory" );
188         if( text != null )
189         {
190             setTargetDirectory( text );
191         }
192         
193         
194         //
195 // Classpath
196
197         text = configuration.getProperty( "groovy.classpath" );
198         if( text != null )
199         {
200             setClasspath( text );
201         }
202             
203         
204         //
205 // Verbosity
206
207         text = configuration.getProperty( "groovy.output.verbose" );
208         if( text != null && text.equals("true") )
209         {
210             setVerbose( true );
211         }
212         
213         
214         //
215 // Debugging
216
217         text = configuration.getProperty( "groovy.output.debug" );
218         if( text != null && text.equals("true") )
219         {
220             setDebug( true );
221         }
222         
223         
224         //
225 // Tolerance
226
227         numeric = 10;
228         
229         try
230         {
231             text = configuration.getProperty( "groovy.errors.tolerance", "10" );
232             numeric = Integer.parseInt( text );
233         }
234         catch( NumberFormatException e )
235         {
236             throw new ConfigurationException( e );
237         }
238         
239         setTolerance( numeric );
240         
241         
242         //
243 // Script Base Class
244
245         text = configuration.getProperty( "groovy.script.base" );
246         setScriptBaseClass( text );
247     }
248
249
250     
251    /**
252     * Gets the currently configured warning level. See WarningMessage
253     * for level details.
254     */
255     
256     public int getWarningLevel()
257     {
258         return this.warningLevel;
259     }
260     
261     
262    /**
263     * Sets the warning level. See WarningMessage for level details.
264     */
265     
266     public void setWarningLevel( int level )
267     {
268         if( level < WarningMessage.NONE || level > WarningMessage.PARANOIA )
269         {
270             this.warningLevel = WarningMessage.LIKELY_ERRORS;
271         }
272         else
273         {
274             this.warningLevel = level;
275         }
276     }
277
278     
279     
280    /**
281     * Gets the currently configured source file encoding.
282     */
283     
284     public String getSourceEncoding()
285     {
286         return this.sourceEncoding;
287     }
288     
289     
290    /**
291     * Sets the encoding to be used when reading source files.
292     */
293     
294     public void setSourceEncoding( String encoding )
295     {
296         this.sourceEncoding = encoding;
297     }
298     
299
300     
301    /**
302     * Gets the currently configured output writer.
303     */
304     
305     public PrintWriter getOutput()
306     {
307         return this.output;
308     }
309     
310     
311    /**
312     * Sets the output writer.
313     */
314     
315     public void setOutput( PrintWriter output )
316     {
317         if( this.output == null )
318         {
319             this.output = new PrintWriter ( NullWriter.DEFAULT );
320         }
321         else
322         {
323             this.output = output;
324         }
325     }
326     
327
328     
329    /**
330     * Gets the target directory for writing classes.
331     */
332     
333     public File getTargetDirectory()
334     {
335         return this.targetDirectory;
336     }
337     
338     
339    /**
340     * Sets the target directory.
341     */
342     
343     public void setTargetDirectory( String directory )
344     {
345         if( directory != null && directory.length() > 0 )
346         {
347             this.targetDirectory = new File ( directory );
348         }
349         else
350         {
351             this.targetDirectory = null;
352         }
353     }
354
355     
356    /**
357     * Sets the target directory.
358     */
359     
360     public void setTargetDirectory( File directory )
361     {
362         this.targetDirectory = directory;
363     }
364     
365     
366
367     
368
369    /**
370     * Gets the classpath.
371     */
372     
373     public List getClasspath()
374     {
375         return this.classpath;
376     }
377     
378     
379    /**
380     * Sets the output writer.
381     */
382     
383     public void setClasspath( String classpath )
384     {
385         this.classpath = new LinkedList ();
386         
387         StringTokenizer tokenizer = new StringTokenizer ( classpath, File.pathSeparator );
388         while( tokenizer.hasMoreTokens() )
389         {
390             this.classpath.add( tokenizer.nextToken() );
391         }
392     }
393     
394
395
396    /**
397     * Returns true if verbose operation has been requested.
398     */
399     
400     public boolean getVerbose()
401     {
402         return this.verbose;
403     }
404     
405     
406    /**
407     * Turns verbose operation on or off.
408     */
409     
410     public void setVerbose( boolean verbose )
411     {
412         this.verbose = verbose;
413     }
414
415
416
417    /**
418     * Returns true if debugging operation has been requested.
419     */
420     
421     public boolean getDebug()
422     {
423         return this.debug;
424     }
425     
426     
427    /**
428     * Turns debugging operation on or off.
429     */
430     
431     public void setDebug( boolean debug )
432     {
433         this.debug = debug;
434     }
435
436
437
438
439    /**
440     * Returns the requested error tolerance.
441     */
442     
443     public int getTolerance()
444     {
445         return this.tolerance;
446     }
447     
448     
449    /**
450     * Sets the error tolerance, which is the number of
451     * non-fatal errors (per unit) that should be tolerated before
452     * compilation is aborted.
453     */
454     
455     public void setTolerance( int tolerance )
456     {
457         this.tolerance = tolerance;
458     }
459
460
461     
462    /**
463     * Gets the name of the base class for scripts. It must be a subclass
464     * of Script.
465     */
466
467     public String getScriptBaseClass()
468     {
469         return this.scriptBaseClass;
470     }
471
472     
473    /**
474     * Sets the name of the base class for scripts. It must be a subclass
475     * of Script.
476     */
477     public void setScriptBaseClass( String scriptBaseClass )
478     {
479         this.scriptBaseClass = scriptBaseClass;
480     }
481
482
483 }
484
485
486
487
488

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags