View Javadoc

    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