Coverage Report - org.codehaus.plexus.compiler.eclipse.EclipseJavaCompiler
 
Classes in this File Line Coverage Branch Coverage Complexity
EclipseJavaCompiler
63%
89/141
47%
33/70
4,346
EclipseJavaCompiler$CompilationUnit
75%
24/32
83%
5/6
4,346
EclipseJavaCompiler$EclipseCompilerICompilerRequestor
88%
37/42
88%
16/18
4,346
EclipseJavaCompiler$EclipseCompilerINameEnvironment
82%
48/58
83%
15/18
4,346
 
 1  
 package org.codehaus.plexus.compiler.eclipse;
 2  
 
 3  
 /**
 4  
  * The MIT License
 5  
  *
 6  
  * Copyright (c) 2005, The Codehaus
 7  
  *
 8  
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 9  
  * this software and associated documentation files (the "Software"), to deal in
 10  
  * the Software without restriction, including without limitation the rights to
 11  
  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 12  
  * of the Software, and to permit persons to whom the Software is furnished to do
 13  
  * so, subject to the following conditions:
 14  
  *
 15  
  * The above copyright notice and this permission notice shall be included in all
 16  
  * copies or substantial portions of the Software.
 17  
  *
 18  
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19  
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20  
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 21  
  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 22  
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 23  
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 24  
  * SOFTWARE.
 25  
  */
 26  
 
 27  
 import org.codehaus.plexus.compiler.AbstractCompiler;
 28  
 import org.codehaus.plexus.compiler.CompilerConfiguration;
 29  
 import org.codehaus.plexus.compiler.CompilerException;
 30  
 import org.codehaus.plexus.compiler.CompilerMessage;
 31  
 import org.codehaus.plexus.compiler.CompilerOutputStyle;
 32  
 import org.codehaus.plexus.compiler.CompilerResult;
 33  
 import org.codehaus.plexus.util.FileUtils;
 34  
 import org.codehaus.plexus.util.IOUtil;
 35  
 import org.codehaus.plexus.util.StringUtils;
 36  
 import org.eclipse.jdt.core.compiler.IProblem;
 37  
 import org.eclipse.jdt.internal.compiler.ClassFile;
 38  
 import org.eclipse.jdt.internal.compiler.CompilationResult;
 39  
 import org.eclipse.jdt.internal.compiler.Compiler;
 40  
 import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
 41  
 import org.eclipse.jdt.internal.compiler.ICompilerRequestor;
 42  
 import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
 43  
 import org.eclipse.jdt.internal.compiler.IProblemFactory;
 44  
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
 45  
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
 46  
 import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
 47  
 import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
 48  
 import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
 49  
 import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
 50  
 import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
 51  
 
 52  
 import java.io.BufferedInputStream;
 53  
 import java.io.File;
 54  
 import java.io.FileInputStream;
 55  
 import java.io.FileNotFoundException;
 56  
 import java.io.FileOutputStream;
 57  
 import java.io.IOException;
 58  
 import java.io.InputStream;
 59  
 import java.net.MalformedURLException;
 60  
 import java.net.URL;
 61  
 import java.net.URLClassLoader;
 62  
 import java.util.ArrayList;
 63  
 import java.util.HashMap;
 64  
 import java.util.Iterator;
 65  
 import java.util.LinkedList;
 66  
 import java.util.List;
 67  
 import java.util.Locale;
 68  
 import java.util.LinkedHashMap;
 69  
 import java.util.Map;
 70  
 import java.util.Properties;
 71  
 import java.util.Set;
 72  
 import java.util.StringTokenizer;
 73  
 
 74  
 /**
 75  
  * @plexus.component role="org.codehaus.plexus.compiler.Compiler" role-hint="eclipse"
 76  
  */
 77  14
 public class EclipseJavaCompiler
 78  
     extends AbstractCompiler
 79  
 {
 80  
     public EclipseJavaCompiler()
 81  
     {
 82  7
         super( CompilerOutputStyle.ONE_OUTPUT_FILE_PER_INPUT_FILE, ".java", ".class", null );
 83  7
     }
 84  
 
 85  
     // ----------------------------------------------------------------------
 86  
     // Compiler Implementation
 87  
     // ----------------------------------------------------------------------
 88  7
     boolean errorsAsWarnings = false;
 89  
 
 90  
     public CompilerResult performCompile( CompilerConfiguration config )
 91  
         throws CompilerException
 92  
     {
 93  18
         List<CompilerMessage> errors = new LinkedList<CompilerMessage>();
 94  
 
 95  18
         List<String> classpathEntries = config.getClasspathEntries();
 96  
 
 97  18
         URL[] urls = new URL[1 + classpathEntries.size()];
 98  
 
 99  18
         int i = 0;
 100  
 
 101  
         try
 102  
         {
 103  18
             urls[i++] = new File( config.getOutputLocation() ).toURL();
 104  
 
 105  18
             for ( String entry : classpathEntries )
 106  
             {
 107  14
                 urls[i++] = new File( entry ).toURL();
 108  14
             }
 109  
         }
 110  0
         catch ( MalformedURLException e )
 111  
         {
 112  0
             throw new CompilerException( "Error while converting the classpath entries to URLs.", e );
 113  18
         }
 114  
 
 115  18
         ClassLoader classLoader = new URLClassLoader( urls );
 116  
 
 117  18
         SourceCodeLocator sourceCodeLocator = new SourceCodeLocator( config.getSourceLocations() );
 118  
 
 119  18
         INameEnvironment env = new EclipseCompilerINameEnvironment( sourceCodeLocator, classLoader, errors );
 120  
 
 121  18
         IErrorHandlingPolicy policy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
 122  
 
 123  
         // ----------------------------------------------------------------------
 124  
         // Build settings from configuration
 125  
         // ----------------------------------------------------------------------
 126  
 
 127  18
         Map<String, String> settings = new HashMap<String, String>();
 128  
 
 129  18
         if ( config.isDebug() )
 130  
         {
 131  14
             settings.put( CompilerOptions.OPTION_LocalVariableAttribute, CompilerOptions.GENERATE );
 132  14
             settings.put( CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE );
 133  14
             settings.put( CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE );
 134  
         }
 135  
 
 136  18
         if ( !config.isShowWarnings() )
 137  
         {
 138  0
             Map opts = new CompilerOptions().getMap();
 139  0
             for (Object optKey : opts.keySet()) {
 140  0
                 if (opts.get(optKey).equals(CompilerOptions.WARNING)) {
 141  0
                     settings.put((String) optKey, CompilerOptions.IGNORE);
 142  
                 }
 143  0
             }
 144  
         }
 145  
 
 146  18
         String sourceVersion = decodeVersion( config.getSourceVersion() );
 147  
 
 148  18
         if ( sourceVersion != null )
 149  
         {
 150  0
             settings.put( CompilerOptions.OPTION_Source, sourceVersion );
 151  
         }
 152  
 
 153  18
         String targetVersion = decodeVersion( config.getTargetVersion() );
 154  
 
 155  18
         if ( targetVersion != null )
 156  
         {
 157  0
             settings.put( CompilerOptions.OPTION_TargetPlatform, targetVersion );
 158  0
             settings.put( CompilerOptions.OPTION_Compliance, targetVersion );
 159  
         }
 160  
 
 161  18
         if ( StringUtils.isNotEmpty( config.getSourceEncoding() ) )
 162  
         {
 163  0
             settings.put( CompilerOptions.OPTION_Encoding, config.getSourceEncoding() );
 164  
         }
 165  
 
 166  18
         if ( config.isShowDeprecation() )
 167  
         {
 168  15
             settings.put( CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.WARNING );
 169  
         }
 170  
         else
 171  
         {
 172  3
             settings.put( CompilerOptions.OPTION_ReportDeprecation, CompilerOptions.IGNORE );
 173  
         }
 174  
 
 175  18
         if ( config.isParameters() )
 176  
         {
 177  0
             settings.put( CompilerOptions.OPTION_MethodParametersAttribute, CompilerOptions.GENERATE );
 178  
         }
 179  
 
 180  
         // ----------------------------------------------------------------------
 181  
         // Set Eclipse-specific options
 182  
         // ----------------------------------------------------------------------
 183  
 
 184  18
         settings.put( CompilerOptions.OPTION_LineNumberAttribute, CompilerOptions.GENERATE );
 185  18
         settings.put( CompilerOptions.OPTION_SourceFileAttribute, CompilerOptions.GENERATE );
 186  
 
 187  
         // compiler-specific extra options override anything else in the config object...
 188  18
         Map<String, String> extras = cleanKeyNames( config.getCustomCompilerArgumentsAsMap() );
 189  18
         if( extras.containsKey( "errorsAsWarnings" ) )
 190  
         {
 191  7
                 extras.remove( "errorsAsWarnings" );
 192  7
                 this.errorsAsWarnings = true;
 193  
         }
 194  
 
 195  18
         settings.putAll( extras );
 196  
 
 197  18
         if ( settings.containsKey( "properties" ) )
 198  
         {
 199  1
             initializeWarnings( settings.get( "properties" ), settings );
 200  0
             settings.remove( "properties" );
 201  
         }
 202  
 
 203  17
         IProblemFactory problemFactory = new DefaultProblemFactory( Locale.getDefault() );
 204  
 
 205  17
         ICompilerRequestor requestor = new EclipseCompilerICompilerRequestor( config.getOutputLocation(), errors );
 206  
 
 207  17
         List<CompilationUnit> compilationUnits = new ArrayList<CompilationUnit>();
 208  
 
 209  17
         for ( String sourceRoot : config.getSourceLocations() )
 210  
         {
 211  
             // annotations directory does not always exist and the below scanner fails on non existing directories
 212  16
             File potentialSourceDirectory = new File( sourceRoot );
 213  16
             if ( potentialSourceDirectory.exists() )
 214  
             {
 215  16
                 Set<String> sources = getSourceFilesForSourceRoot( config, sourceRoot );
 216  
 
 217  16
                 for ( String source : sources )
 218  
                 {
 219  16
                     CompilationUnit unit = new CompilationUnit( source, makeClassName( source, sourceRoot ), errors,
 220  16
                                                                 config.getSourceEncoding() );
 221  
 
 222  16
                     compilationUnits.add( unit );
 223  16
                 }
 224  
             }
 225  16
         }
 226  
 
 227  
         // ----------------------------------------------------------------------
 228  
         // Compile!
 229  
         // ----------------------------------------------------------------------
 230  
 
 231  17
         CompilerOptions options = new CompilerOptions( settings );
 232  17
         Compiler compiler = new Compiler( env, policy, options, requestor, problemFactory );
 233  
 
 234  17
         ICompilationUnit[] units = compilationUnits.toArray( new ICompilationUnit[compilationUnits.size()] );
 235  
 
 236  17
         compiler.compile( units );
 237  
 
 238  17
         CompilerResult compilerResult = new CompilerResult().compilerMessages( errors );
 239  
 
 240  17
         for ( CompilerMessage compilerMessage : errors )
 241  
         {
 242  14
             if ( compilerMessage.isError() )
 243  
             {
 244  4
                 compilerResult.setSuccess( false );
 245  4
                 continue;
 246  
             }
 247  10
         }
 248  
 
 249  17
         return compilerResult;
 250  
     }
 251  
 
 252  
     // The compiler mojo adds a dash to all keys which does not make sense for the eclipse compiler
 253  
     Map<String, String> cleanKeyNames( Map<String, String> customCompilerArgumentsAsMap )
 254  
     {
 255  19
         LinkedHashMap<String, String> cleanedMap = new LinkedHashMap<String, String>();
 256  
 
 257  19
         for ( Map.Entry<String, String> entry : customCompilerArgumentsAsMap.entrySet() )
 258  
         {
 259  11
             String key = entry.getKey();
 260  11
             if ( key.startsWith( "-" ) )
 261  
             {
 262  10
                 key = key.substring( 1 );
 263  
             }
 264  11
             cleanedMap.put( key, entry.getValue() );
 265  11
         }
 266  
 
 267  19
         return cleanedMap;
 268  
     }
 269  
 
 270  
     public String[] createCommandLine( CompilerConfiguration config )
 271  
         throws CompilerException
 272  
     {
 273  0
         return null;
 274  
     }
 275  
 
 276  
     private CompilerMessage handleError( String className, int line, int column, Object errorMessage )
 277  
     {
 278  4
         if ( className.endsWith( ".java" ) )
 279  
         {
 280  4
             className = className.substring( 0, className.lastIndexOf( '.' ) );
 281  
         }
 282  4
         String fileName = className.replace( '.', File.separatorChar ) + ".java";
 283  
 
 284  4
         if ( column < 0 )
 285  
         {
 286  4
             column = 0;
 287  
         }
 288  
 
 289  
         String message;
 290  
 
 291  4
         if ( errorMessage != null )
 292  
         {
 293  4
             message = errorMessage.toString();
 294  
         }
 295  
         else
 296  
         {
 297  0
             message = "No message";
 298  
         }
 299  
 
 300  4
         return new CompilerMessage( fileName, CompilerMessage.Kind.ERROR, line, column, line, column, message );
 301  
 
 302  
     }
 303  
 
 304  
     private CompilerMessage handleWarning( String fileName, IProblem warning )
 305  
     {
 306  20
         return new CompilerMessage( fileName, CompilerMessage.Kind.WARNING,
 307  10
                                     warning.getSourceLineNumber(), warning.getSourceStart(),
 308  10
                                     warning.getSourceLineNumber(), warning.getSourceEnd(), warning.getMessage() );
 309  
     }
 310  
 
 311  
     private String decodeVersion( String versionSpec )
 312  
     {
 313  36
         if ( StringUtils.isEmpty( versionSpec ) )
 314  
         {
 315  36
             return null;
 316  
         }
 317  0
         else if ( "1.1".equals( versionSpec ) )
 318  
         {
 319  0
             return CompilerOptions.VERSION_1_1;
 320  
         }
 321  0
         else if ( "1.2".equals( versionSpec ) )
 322  
         {
 323  0
             return CompilerOptions.VERSION_1_2;
 324  
         }
 325  0
         else if ( "1.3".equals( versionSpec ) )
 326  
         {
 327  0
             return CompilerOptions.VERSION_1_3;
 328  
         }
 329  0
         else if ( "1.4".equals( versionSpec ) )
 330  
         {
 331  0
             return CompilerOptions.VERSION_1_4;
 332  
         }
 333  0
         else if ( "1.5".equals( versionSpec ) )
 334  
         {
 335  0
             return CompilerOptions.VERSION_1_5;
 336  
         }
 337  0
         else if ( "1.6".equals( versionSpec ) )
 338  
         {
 339  0
             return CompilerOptions.VERSION_1_6;
 340  
         }
 341  0
         else if ( "1.7".equals( versionSpec ) )
 342  
         {
 343  0
             return CompilerOptions.VERSION_1_7;
 344  
         }
 345  0
         else if ( "1.8".equals( versionSpec ) )
 346  
         {
 347  0
             return CompilerOptions.VERSION_1_8;
 348  
         }
 349  0
         else if ( "9".equals( versionSpec ) )
 350  
         {
 351  0
                 return CompilerOptions.VERSION_9;
 352  
         }
 353  
         else
 354  
         {
 355  0
             getLogger().warn(
 356  
                 "Unknown version '" + versionSpec + "', no version setting will be given to the compiler." );
 357  
 
 358  0
             return null;
 359  
         }
 360  
     }
 361  
 
 362  
     // ----------------------------------------------------------------------
 363  
     // Classes
 364  
     // ----------------------------------------------------------------------
 365  
 
 366  
     private class CompilationUnit
 367  
         implements ICompilationUnit
 368  
     {
 369  
         private final String className;
 370  
 
 371  
         private final String sourceFile;
 372  
 
 373  
         private final String sourceEncoding;
 374  
 
 375  
         private final List<CompilerMessage> errors;
 376  
 
 377  
         CompilationUnit( String sourceFile, String className, List<CompilerMessage> errors )
 378  
         {
 379  0
             this( sourceFile, className, errors, null );
 380  0
         }
 381  
 
 382  
         CompilationUnit( String sourceFile, String className, List<CompilerMessage> errors, String sourceEncoding )
 383  16
         {
 384  16
             this.className = className;
 385  16
             this.sourceFile = sourceFile;
 386  16
             this.errors = errors;
 387  16
             this.sourceEncoding = sourceEncoding;
 388  16
         }
 389  
 
 390  
         public char[] getFileName()
 391  
         {
 392  16
             String fileName = sourceFile;
 393  
 
 394  16
             int lastSeparator = fileName.lastIndexOf( File.separatorChar );
 395  
 
 396  16
             if ( lastSeparator > 0 )
 397  
             {
 398  16
                 fileName = fileName.substring( lastSeparator + 1 );
 399  
             }
 400  
 
 401  16
             return fileName.toCharArray();
 402  
         }
 403  
 
 404  
         String getAbsolutePath()
 405  
         {
 406  14
             return sourceFile;
 407  
         }
 408  
 
 409  
         public char[] getContents()
 410  
         {
 411  
             try
 412  
             {
 413  32
                 return FileUtils.fileRead( sourceFile, sourceEncoding ).toCharArray();
 414  
             }
 415  0
             catch ( FileNotFoundException e )
 416  
             {
 417  0
                 errors.add( handleError( className, -1, -1, e.getMessage() ) );
 418  
 
 419  0
                 return null;
 420  
             }
 421  0
             catch ( IOException e )
 422  
             {
 423  0
                 errors.add( handleError( className, -1, -1, e.getMessage() ) );
 424  
 
 425  0
                 return null;
 426  
             }
 427  
         }
 428  
 
 429  
         public char[] getMainTypeName()
 430  
         {
 431  96
             int dot = className.lastIndexOf( '.' );
 432  
 
 433  96
             if ( dot > 0 )
 434  
             {
 435  84
                 return className.substring( dot + 1 ).toCharArray();
 436  
             }
 437  
 
 438  12
             return className.toCharArray();
 439  
         }
 440  
 
 441  
         public char[][] getPackageName()
 442  
         {
 443  16
             StringTokenizer izer = new StringTokenizer( className, "." );
 444  
 
 445  16
             char[][] result = new char[izer.countTokens() - 1][];
 446  
 
 447  58
             for ( int i = 0; i < result.length; i++ )
 448  
             {
 449  42
                 String tok = izer.nextToken();
 450  
 
 451  42
                 result[i] = tok.toCharArray();
 452  
             }
 453  
 
 454  16
             return result;
 455  
         }
 456  
 
 457  
         public boolean ignoreOptionalProblems()
 458  
         {
 459  6
             return false;
 460  
         }
 461  
     }
 462  
 
 463  
     private class EclipseCompilerINameEnvironment
 464  
         implements INameEnvironment
 465  
     {
 466  
         private SourceCodeLocator sourceCodeLocator;
 467  
 
 468  
         private ClassLoader classLoader;
 469  
 
 470  
         private List<CompilerMessage> errors;
 471  
 
 472  
         public EclipseCompilerINameEnvironment( SourceCodeLocator sourceCodeLocator, ClassLoader classLoader,
 473  
                                                 List<CompilerMessage> errors )
 474  18
         {
 475  18
             this.sourceCodeLocator = sourceCodeLocator;
 476  18
             this.classLoader = classLoader;
 477  18
             this.errors = errors;
 478  18
         }
 479  
 
 480  
         public NameEnvironmentAnswer findType( char[][] compoundTypeName )
 481  
         {
 482  28
             String result = "";
 483  
 
 484  28
             String sep = "";
 485  
 
 486  112
             for ( int i = 0; i < compoundTypeName.length; i++ )
 487  
             {
 488  84
                 result += sep;
 489  84
                 result += new String( compoundTypeName[i] );
 490  84
                 sep = ".";
 491  
             }
 492  
 
 493  28
             return findType( result );
 494  
         }
 495  
 
 496  
         public NameEnvironmentAnswer findType( char[] typeName, char[][] packageName )
 497  
         {
 498  133
             String result = "";
 499  
 
 500  133
             String sep = "";
 501  
 
 502  396
             for ( int i = 0; i < packageName.length; i++ )
 503  
             {
 504  263
                 result += sep;
 505  263
                 result += new String( packageName[i] );
 506  263
                 sep = ".";
 507  
             }
 508  
 
 509  133
             result += sep;
 510  133
             result += new String( typeName );
 511  133
             return findType( result );
 512  
         }
 513  
 
 514  
         private NameEnvironmentAnswer findType( String className )
 515  
         {
 516  
             try
 517  
             {
 518  161
                 File f = sourceCodeLocator.findSourceCodeForClass( className );
 519  
 
 520  161
                 if ( f != null )
 521  
                 {
 522  0
                     ICompilationUnit compilationUnit = new CompilationUnit( f.getAbsolutePath(), className, errors );
 523  
 
 524  0
                     return new NameEnvironmentAnswer( compilationUnit, null );
 525  
                 }
 526  
 
 527  161
                 String resourceName = className.replace( '.', '/' ) + ".class";
 528  
 
 529  161
                 InputStream is = classLoader.getResourceAsStream( resourceName );
 530  
 
 531  161
                 if ( is == null )
 532  
                 {
 533  110
                     return null;
 534  
                 }
 535  
 
 536  51
                 byte[] classBytes = IOUtil.toByteArray( is );
 537  
 
 538  51
                 char[] fileName = className.toCharArray();
 539  
 
 540  51
                 ClassFileReader classFileReader = new ClassFileReader( classBytes, fileName, true );
 541  
 
 542  51
                 return new NameEnvironmentAnswer( classFileReader, null );
 543  
             }
 544  0
             catch ( IOException e )
 545  
             {
 546  0
                 errors.add( handleError( className, -1, -1, e.getMessage() ) );
 547  
 
 548  0
                 return null;
 549  
             }
 550  0
             catch ( ClassFormatException e )
 551  
             {
 552  0
                 errors.add( handleError( className, -1, -1, e.getMessage() ) );
 553  
 
 554  0
                 return null;
 555  
             }
 556  
         }
 557  
 
 558  
         private boolean isPackage( String result )
 559  
         {
 560  47
             if ( sourceCodeLocator.findSourceCodeForClass( result ) != null )
 561  
             {
 562  0
                 return false;
 563  
             }
 564  
 
 565  47
             String resourceName = "/" + result.replace( '.', '/' ) + ".class";
 566  
 
 567  47
             InputStream is = classLoader.getResourceAsStream( resourceName );
 568  
 
 569  47
             return is == null;
 570  
         }
 571  
 
 572  
         public boolean isPackage( char[][] parentPackageName, char[] packageName )
 573  
         {
 574  67
             String result = "";
 575  
 
 576  67
             String sep = "";
 577  
 
 578  67
             if ( parentPackageName != null )
 579  
             {
 580  152
                 for ( int i = 0; i < parentPackageName.length; i++ )
 581  
                 {
 582  103
                     result += sep;
 583  103
                     result += new String( parentPackageName[i] );
 584  103
                     sep = ".";
 585  
                 }
 586  
             }
 587  
 
 588  67
             if ( Character.isUpperCase( packageName[0] ) )
 589  
             {
 590  20
                 return false;
 591  
             }
 592  
 
 593  47
             String str = new String( packageName );
 594  
 
 595  47
             result += sep;
 596  
 
 597  47
             result += str;
 598  
 
 599  47
             return isPackage( result );
 600  
         }
 601  
 
 602  
         public void cleanup()
 603  
         {
 604  
             // nothing to do
 605  0
         }
 606  
     }
 607  
 
 608  
     private class EclipseCompilerICompilerRequestor
 609  
         implements ICompilerRequestor
 610  
     {
 611  
         private String destinationDirectory;
 612  
 
 613  
         private List<CompilerMessage> errors;
 614  
 
 615  
         public EclipseCompilerICompilerRequestor( String destinationDirectory, List<CompilerMessage> errors )
 616  17
         {
 617  17
             this.destinationDirectory = destinationDirectory;
 618  17
             this.errors = errors;
 619  17
         }
 620  
 
 621  
         public void acceptResult( CompilationResult result )
 622  
         {
 623  16
             boolean hasErrors = false;
 624  
 
 625  16
             if ( result.hasProblems() )
 626  
             {
 627  12
                 IProblem[] problems = result.getProblems();
 628  
 
 629  26
                 for ( IProblem problem : problems )
 630  
                 {
 631  14
                     String name = getFileName( result.getCompilationUnit(), problem.getOriginatingFileName() );
 632  
 
 633  14
                     if ( problem.isWarning() )
 634  
                     {
 635  6
                         errors.add( handleWarning( name, problem ) );
 636  
                     }
 637  
                     else
 638  
                     {
 639  8
                             if( errorsAsWarnings )
 640  
                             {
 641  4
                                     errors.add( handleWarning( name, problem ) );
 642  
                             }
 643  
                             else
 644  
                             {
 645  4
                                     hasErrors = true;
 646  4
                                     errors.add( handleError( name, problem.getSourceLineNumber(), -1, problem.getMessage() ) );
 647  
                             }
 648  
                     }
 649  
                 }
 650  
             }
 651  
 
 652  16
             if ( !hasErrors )
 653  
             {
 654  13
                 ClassFile[] classFiles = result.getClassFiles();
 655  
 
 656  26
                 for ( ClassFile classFile : classFiles )
 657  
                 {
 658  13
                     char[][] compoundName = classFile.getCompoundName();
 659  13
                     String className = "";
 660  13
                     String sep = "";
 661  
 
 662  59
                     for ( int j = 0; j < compoundName.length; j++ )
 663  
                     {
 664  46
                         className += sep;
 665  46
                         className += new String( compoundName[j] );
 666  46
                         sep = ".";
 667  
                     }
 668  
 
 669  13
                     byte[] bytes = classFile.getBytes();
 670  
 
 671  13
                     File outFile = new File( destinationDirectory, className.replace( '.', '/' ) + ".class" );
 672  
 
 673  13
                     if ( !outFile.getParentFile().exists() )
 674  
                     {
 675  13
                         outFile.getParentFile().mkdirs();
 676  
                     }
 677  
 
 678  13
                     FileOutputStream fout = null;
 679  
 
 680  
                     try
 681  
                     {
 682  13
                         fout = new FileOutputStream( outFile );
 683  
 
 684  13
                         fout.write( bytes );
 685  
                     }
 686  0
                     catch ( FileNotFoundException e )
 687  
                     {
 688  0
                         errors.add( handleError( className, -1, -1, e.getMessage() ) );
 689  
                     }
 690  0
                     catch ( IOException e )
 691  
                     {
 692  0
                         errors.add( handleError( className, -1, -1, e.getMessage() ) );
 693  
                     }
 694  
                     finally
 695  
                     {
 696  13
                         IOUtil.close( fout );
 697  13
                     }
 698  
                 }
 699  
             }
 700  16
         }
 701  
 
 702  
         private String getFileName( ICompilationUnit compilationUnit, char[] originalFileName )
 703  
         {
 704  14
             if ( compilationUnit instanceof CompilationUnit )
 705  
             {
 706  14
                 return ( (CompilationUnit) compilationUnit ).getAbsolutePath();
 707  
             }
 708  
             else
 709  
             {
 710  0
                 return String.valueOf( originalFileName );
 711  
             }
 712  
         }
 713  
     }
 714  
 
 715  
     private void initializeWarnings( String propertiesFile, Map<String, String> setting )
 716  
     {
 717  1
         File file = new File( propertiesFile );
 718  1
         if ( !file.exists() )
 719  
         {
 720  1
             throw new IllegalArgumentException( "Properties file not exist" );
 721  
         }
 722  0
         BufferedInputStream stream = null;
 723  0
         Properties properties = null;
 724  
         try
 725  
         {
 726  0
             stream = new BufferedInputStream( new FileInputStream( propertiesFile ) );
 727  0
             properties = new Properties();
 728  0
             properties.load( stream );
 729  
         }
 730  0
         catch ( IOException e )
 731  
         {
 732  0
             throw new IllegalArgumentException( "Properties file load error" );
 733  
         }
 734  
         finally
 735  
         {
 736  0
             if ( stream != null )
 737  
             {
 738  
                 try
 739  
                 {
 740  0
                     stream.close();
 741  
                 }
 742  0
                 catch ( IOException e )
 743  
                 {
 744  
                     // ignore
 745  0
                 }
 746  
             }
 747  
         }
 748  0
         for ( Iterator iterator = properties.entrySet().iterator(); iterator.hasNext(); )
 749  
         {
 750  0
             Map.Entry entry = (Map.Entry) iterator.next();
 751  0
             final String key = (String) entry.getKey();
 752  0
             setting.put( key, entry.getValue().toString() );
 753  0
         }
 754  0
     }
 755  
 }