eclipse-ecj-gccmain.patch

   1 Index: src/org/eclipse/jdt/internal/compiler/batch/messages.properties
   2 ===================================================================
   3 RCS file: /cvsroot/eclipse/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties,v
   4 retrieving revision 1.546.2.23
   5 diff -u -r1.546.2.23 messages.properties
   6 --- src/org/eclipse/jdt/internal/compiler/batch/messages.properties     8 Feb 2007 15:04:43 -0000       1.546.2.23
   7 +++ src/org/eclipse/jdt/internal/compiler/batch/messages.properties     26 Feb 2007 18:21:06 -0000
   8 @@ -249,3 +249,8 @@
   9  template.restrictedAccess.constructor = The constructor {0} is not accessible due to restriction on classpath entry {1}
  10  template.restrictedAccess.field = The field {0} from the type {1} is not accessible due to restriction on classpath entry {2}
  11  template.restrictedAccess.method = The method {0} from the type {1} is not accessible due to restriction on classpath entry {2}
  12 +
  13 +# GCCMain messages.
  14 +gcc.zipArg=-fzip-target requires argument
  15 +gcc.zipDepArg=-fzip-dependency requires argument
  16 +gcc.noClasspath=no classpath specified
  17 Index: src/org/eclipse/jdt/internal/compiler/batch/GCCMain.java
  18 ===================================================================
  19 RCS file: batch/org/eclipse/jdt/internal/compiler/batch/GCCMain.java
  20 diff -N src/org/eclipse/jdt/internal/compiler/batch/GCCMain.java
  21 --- /dev/null   1 Jan 1970 00:00:00 -0000
  22 +++ src/org/eclipse/jdt/internal/compiler/batch/GCCMain.java    1 Jan 1970 00:00:00 -0000
  23 @@ -0,0 +1,495 @@
  24 +/**
  25 + *
  26 + */
  27 +package org.eclipse.jdt.internal.compiler.batch;
  28 +
  29 +import java.io.BufferedOutputStream;
  30 +import java.io.BufferedReader;
  31 +import java.io.ByteArrayInputStream;
  32 +import java.io.File;
  33 +import java.io.FileOutputStream;
  34 +import java.io.FileReader;
  35 +import java.io.IOException;
  36 +import java.io.InputStreamReader;
  37 +import java.io.OutputStream;
  38 +import java.io.PrintWriter;
  39 +import java.io.UnsupportedEncodingException;
  40 +import java.util.ArrayList;
  41 +import java.util.HashSet;
  42 +import java.util.Iterator;
  43 +import java.util.Map;
  44 +import java.util.StringTokenizer;
  45 +import java.util.zip.CRC32;
  46 +import java.util.zip.ZipEntry;
  47 +import java.util.zip.ZipOutputStream;
  48 +
  49 +import org.eclipse.jdt.core.compiler.InvalidInputException;
  50 +import org.eclipse.jdt.internal.compiler.ClassFile;
  51 +import org.eclipse.jdt.internal.compiler.CompilationResult;
  52 +import org.eclipse.jdt.internal.compiler.env.AccessRule;
  53 +import org.eclipse.jdt.internal.compiler.env.AccessRuleSet;
  54 +import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
  55 +import org.eclipse.jdt.internal.compiler.util.Messages;
  56 +import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
  57 +
  58 +/**
  59 + * This is an alternate entry point for the command-line compiler which
  60 + * is simpler to integrate into GCC.  In particular the option processing
  61 + * is more GNU-like and the recognized options are similar to those supported
  62 + * by other GCC front ends.
  63 + */
  64 +public class GCCMain extends Main {
  65 +
  66 +       // All the compilation units specified on the command line.
  67 +       private HashSet commandLineCompilationUnits = new HashSet();
  68 +       // True if we are only checking syntax.
  69 +       private boolean syntaxOnly;
  70 +       // If not null, the name of the output zip file.
  71 +       // If null, we are generating class files in the file system,
  72 +       // not a zip file.
  73 +       private String zipDestination;
  74 +       // The zip stream to which we're writing, or null if it hasn't been opened.
  75 +       private ZipOutputStream zipStream;
  76 +
  77 +       // If not null, the name of the zip file to which dependency class files
  78 +       // should be written.
  79 +       private String zipDependencyDestination;
  80 +       // The zip stream to which dependency files should be written.
  81 +       private ZipOutputStream zipDependencyStream;
  82 +
  83 +       public GCCMain(PrintWriter outWriter, PrintWriter errWriter,
  84 +                       boolean systemExitWhenFinished) {
  85 +               super(outWriter, errWriter, systemExitWhenFinished);
  86 +               this.logger.setEmacs();
  87 +       }
  88 +
  89 +       public GCCMain(PrintWriter outWriter, PrintWriter errWriter,
  90 +                       boolean systemExitWhenFinished, Map customDefaultOptions) {
  91 +               super(outWriter, errWriter, systemExitWhenFinished,
  92 +                               customDefaultOptions);
  93 +               this.logger.setEmacs();
  94 +       }
  95 +
  96 +       private void fail(Exception t) {
  97 +               this.logger.logException(t);
  98 +               System.exit(1);
  99 +       }
 100 +
 101 +       public CompilationUnit[] getCompilationUnits() throws InvalidInputException {
 102 +               CompilationUnit[] units = super.getCompilationUnits();
 103 +               for (int i = 0; i < units.length; ++i)
 104 +                       this.commandLineCompilationUnits.add(units[i]);
 105 +               return units;
 106 +       }
 107 +
 108 +       private String combine(char[] one, char[] two) {
 109 +               StringBuffer b = new StringBuffer();
 110 +               b.append(one);
 111 +               b.append(two);
 112 +               return b.toString();
 113 +       }
 114 +
 115 +       private ZipOutputStream getZipOutput() throws IOException {
 116 +               if (this.zipDestination != null && this.zipStream == null) {
 117 +                       OutputStream os;
 118 +                       if ("-".equals(this.zipDestination)) { //$NON-NLS-1$
 119 +                               os = System.out;
 120 +                       } else {
 121 +                               os = new FileOutputStream(this.zipDestination);
 122 +                       }
 123 +                       zipStream = new ZipOutputStream(new BufferedOutputStream(os));
 124 +                       zipStream.setMethod(ZipOutputStream.STORED);
 125 +               }
 126 +               return zipStream;
 127 +       }
 128 +
 129 +       private ZipOutputStream getDependencyOutput() throws IOException {
 130 +               if (this.zipDependencyDestination != null && this.zipDependencyStream == null) {
 131 +                       OutputStream os = new FileOutputStream(zipDependencyDestination);
 132 +                       zipDependencyStream = new ZipOutputStream(new BufferedOutputStream(os));
 133 +                       zipDependencyStream.setMethod(ZipOutputStream.STORED);
 134 +               }
 135 +               return zipDependencyStream;
 136 +       }
 137 +
 138 +       public void outputClassFiles(CompilationResult unitResult) {
 139 +               if (this.syntaxOnly) {
 140 +                       return;
 141 +               }
 142 +               if (this.zipDestination == null) {
 143 +                       // Nothing special to do here.
 144 +                       super.outputClassFiles(unitResult);
 145 +                       return;
 146 +               }
 147 +               if (unitResult == null || unitResult.hasErrors()) {
 148 +                       return;
 149 +               }
 150 +
 151 +               // If we are compiling with indirect dispatch, we don't need
 152 +               // any dependent classes.  If we are using the C++ ABI, then we
 153 +               // do need the dependencies in order to do proper layout.
 154 +               boolean gcjCompile = this.commandLineCompilationUnits.contains(unitResult.getCompilationUnit());
 155 +               if (this.zipDependencyDestination == null && !gcjCompile) {
 156 +                       return;
 157 +               }
 158 +
 159 +               try {
 160 +                       ZipOutputStream dest = gcjCompile ? getZipOutput() : getDependencyOutput();
 161 +                       ClassFile[] classFiles = unitResult.getClassFiles();
 162 +                       for (int i = 0; i < classFiles.length; ++i) {
 163 +                               ClassFile classFile = classFiles[i];
 164 +                               String filename = combine(classFile.fileName(), SuffixConstants.SUFFIX_class);
 165 +                               if (this.verbose)
 166 +                                       this.out.println(
 167 +                                                       Messages.bind(
 168 +                                                                       Messages.compilation_write,
 169 +                                                                       new String[] {
 170 +                                                               String.valueOf(this.exportedClassFilesCounter+1),
 171 +                                                               filename
 172 +                                                       }));
 173 +                               ZipEntry entry = new ZipEntry(filename);
 174 +                               byte[] contents = classFile.getBytes();
 175 +                               CRC32 crc = new CRC32();
 176 +                               crc.update(contents);
 177 +                               entry.setSize(contents.length);
 178 +                               entry.setCrc(crc.getValue());
 179 +                               dest.putNextEntry(entry);
 180 +                               dest.write(contents);
 181 +                               dest.closeEntry();
 182 +                       }
 183 +               } catch (IOException err) {
 184 +                       fail(err);
 185 +               }
 186 +       }
 187 +
 188 +       private String getArgument(String option) {
 189 +               int index = option.indexOf('=');
 190 +               return option.substring(index + 1);
 191 +       }
 192 +
 193 +       private void addPath(ArrayList result, String currentClasspathName) {
 194 +               String customEncoding = null;
 195 +               AccessRule[] accessRules = new AccessRule[0];
 196 +               String templates[] = new String[AccessRuleSet.MESSAGE_TEMPLATES_LENGTH];
 197 +               templates[0] = this.bind(
 198 +                       "template.restrictedAccess.type", //$NON-NLS-1$
 199 +                       new String[] {"{0}", currentClasspathName}); //$NON-NLS-1$
 200 +               templates[1] = this.bind(
 201 +                       "template.restrictedAccess.constructor", //$NON-NLS-1$
 202 +                       new String[] {"{0}", currentClasspathName}); //$NON-NLS-1$
 203 +               templates[2] = this.bind(
 204 +                       "template.restrictedAccess.method", //$NON-NLS-1$
 205 +                       new String[] {"{0}", "{1}", currentClasspathName}); //$NON-NLS-1$ //$NON-NLS-2$
 206 +               templates[3] = this.bind(
 207 +                       "template.restrictedAccess.field", //$NON-NLS-1$
 208 +                       new String[] {"{0}", "{1}", currentClasspathName}); //$NON-NLS-1$ //$NON-NLS-2$
 209 +               AccessRuleSet accessRuleSet = new AccessRuleSet(accessRules, templates);
 210 +               FileSystem.Classpath currentClasspath = FileSystem
 211 +                               .getClasspath(currentClasspathName,
 212 +                                               customEncoding, accessRuleSet);
 213 +               if (currentClasspath != null) {
 214 +                       result.add(currentClasspath);
 215 +               }
 216 +       }
 217 +
 218 +       private void parsePath(ArrayList result, String path) {
 219 +               StringTokenizer iter = new StringTokenizer(path, File.pathSeparator);
 220 +               while (iter.hasMoreTokens()) {
 221 +                       addPath(result, iter.nextToken());
 222 +               }
 223 +       }
 224 +
 225 +       protected void handleWarningToken(String token, boolean isEnabling,
 226 +                       boolean useEnableJavadoc) throws InvalidInputException {
 227 +               // Recognize this for compatibility with older versions of gcj.
 228 +               if ("deprecated".equals(token)) //$NON-NLS-1$
 229 +                       token = "deprecation"; //$NON-NLS-1$
 230 +               else if ("static-access".equals(token)   //$NON-NLS-1$
 231 +                               || "dep-ann".equals(token) //$NON-NLS-1$
 232 +                               || "over-ann".equals(token)) { //$NON-NLS-1$
 233 +                       // Some exceptions to the warning naming rule.
 234 +               } else if ("extraneous-semicolon".equals(token)) { //$NON-NLS-1$
 235 +                       // Compatibility with earlier versions of gcj.
 236 +                       token = "semicolon"; //$NON-NLS-1$
 237 +               } else {
 238 +                       // Turn "foo-bar-baz" into eclipse-style "fooBarBaz".
 239 +                       StringBuffer newToken = new StringBuffer(token.length());
 240 +                       StringTokenizer t = new StringTokenizer(token, "-"); //$NON-NLS-1$
 241 +                       boolean first = true;
 242 +                       while (t.hasMoreTokens()) {
 243 +                               String next = t.nextToken();
 244 +                               if (first) {
 245 +                                       newToken.append(next);
 246 +                                       first = false;
 247 +                               } else {
 248 +                                       newToken.append(Character.toUpperCase(next.charAt(0)));
 249 +                                       newToken.append(next.substring(1));
 250 +                               }
 251 +                       }
 252 +                       token = newToken.toString();
 253 +               }
 254 +               super.handleWarningToken(token, isEnabling, useEnableJavadoc);
 255 +       }
 256 +
 257 +       private void turnWarningsToErrors() {
 258 +               Object[] entries = this.options.entrySet().toArray();
 259 +               for (int i = 0, max = entries.length; i < max; i++) {
 260 +                       Map.Entry entry = (Map.Entry) entries[i];
 261 +                       if (!(entry.getKey() instanceof String))
 262 +                               continue;
 263 +                       if (!(entry.getValue() instanceof String))
 264 +                               continue;
 265 +                       if (((String) entry.getValue()).equals(CompilerOptions.WARNING)) {
 266 +                               this.options.put(entry.getKey(), CompilerOptions.ERROR);
 267 +                       }
 268 +               }
 269 +       }
 270 +
 271 +       /**
 272 +        * Set the debug level to the indicated value.  The level should be
 273 +        * between 0 and 2, inclusive, but this is not checked.
 274 +        * @param level the debug level
 275 +        */
 276 +       private void setDebugLevel(int level) {
 277 +               this.options.put(
 278 +                               CompilerOptions.OPTION_LocalVariableAttribute,
 279 +                               level > 1 ? CompilerOptions.GENERATE : CompilerOptions.DO_NOT_GENERATE);
 280 +               this.options.put(
 281 +                               CompilerOptions.OPTION_LineNumberAttribute,
 282 +                               level > 0 ? CompilerOptions.GENERATE : CompilerOptions.DO_NOT_GENERATE);
 283 +               this.options.put(
 284 +                               CompilerOptions.OPTION_SourceFileAttribute,
 285 +                               CompilerOptions.GENERATE);
 286 +       }
 287 +
 288 +       private void readFileList(String file, ArrayList result) {
 289 +               try {
 290 +                       BufferedReader b = new BufferedReader(new FileReader(file));
 291 +                       String line;
 292 +                       while ((line = b.readLine()) != null) {
 293 +                               if (line.endsWith(SUFFIX_STRING_java))
 294 +                                       result.add(line);
 295 +                       }
 296 +                       b.close();
 297 +               } catch (IOException err) {
 298 +                       fail(err);
 299 +               }
 300 +       }
 301 +
 302 +       private void readAllFileListFiles(ArrayList fileList, ArrayList result) {
 303 +               Iterator it = fileList.iterator();
 304 +               while (it.hasNext()) {
 305 +                       readFileList((String) it.next(), result);
 306 +               }
 307 +       }
 308 +
 309 +       private void handleWall(boolean enable) throws InvalidInputException {
 310 +               // A somewhat arbitrary list.  We use the GCC names
 311 +               // here, and the local handleWarningToken translates
 312 +               // for us.
 313 +               handleWarningToken("constructor-name", enable, false);
 314 +               handleWarningToken("pkg-default-method", enable, false);
 315 +               handleWarningToken("masked-catch-block", enable, false);
 316 +               handleWarningToken("all-deprecation", enable, false);
 317 +               handleWarningToken("unused-local", enable, false);
 318 +               handleWarningToken("unused-label", enable, false);
 319 +               handleWarningToken("static-receiver", enable, false);
 320 +               handleWarningToken("indirect-static", enable, false);
 321 +               handleWarningToken("no-effect-assign", enable, false);
 322 +               handleWarningToken("char-concat", enable, false);
 323 +               handleWarningToken("useless-type-check", enable, false);
 324 +               handleWarningToken("final-bound", enable, false);
 325 +               handleWarningToken("assert-identifier", enable, false);
 326 +               handleWarningToken("enum-identifier", enable, false);
 327 +               handleWarningToken("finally", enable, false);
 328 +               handleWarningToken("varargs-cast", enable, false);
 329 +               handleWarningToken("unused", enable, false);
 330 +               handleWarningToken("forbidden", enable, false);
 331 +       }
 332 +
 333 +       public void configure(String[] argv) throws InvalidInputException {
 334 +               if ((argv == null) || (argv.length == 0)) {
 335 +                       // This is a "can't happen".
 336 +                       System.exit(1);
 337 +               }
 338 +
 339 +               ArrayList files = new ArrayList();
 340 +               ArrayList otherFiles = new ArrayList();
 341 +               String classpath = null;
 342 +               boolean haveFileList = false;
 343 +               boolean inhibitAllWarnings = false;
 344 +               boolean treatWarningsAsErrors = false;
 345 +
 346 +               for (int i = 0; i < argv.length; ++i) {
 347 +                       String currentArg = argv[i];
 348 +
 349 +                       if (currentArg.startsWith("-fencoding=")) { //$NON-NLS-1$
 350 +                               // Simply accept the last one.
 351 +                               String encoding = getArgument(currentArg);
 352 +                               try { // ensure encoding is supported
 353 +                                       new InputStreamReader(new ByteArrayInputStream(new byte[0]), encoding);
 354 +                               } catch (UnsupportedEncodingException e) {
 355 +                                       throw new InvalidInputException(
 356 +                                               this.bind("configure.unsupportedEncoding", encoding)); //$NON-NLS-1$
 357 +                               }
 358 +                               this.options.put(CompilerOptions.OPTION_Encoding, encoding);
 359 +                       } else if (currentArg.startsWith("-foutput-class-dir=")) { //$NON-NLS-1$
 360 +                               String arg = getArgument(currentArg);
 361 +                               if (this.destinationPath != null) {
 362 +                                       StringBuffer errorMessage = new StringBuffer();
 363 +                                       errorMessage.append("-d"); //$NON-NLS-1$
 364 +                                       errorMessage.append(' ');
 365 +                                       errorMessage.append(arg);
 366 +                                       throw new InvalidInputException(
 367 +                                               this.bind("configure.duplicateOutputPath", errorMessage.toString())); //$NON-NLS-1$
 368 +                               }
 369 +                               this.destinationPath = arg;
 370 +                               // this.generatePackagesStructure = true;
 371 +                       } else if (currentArg.startsWith("-fbootclasspath=")) { //$NON-NLS-1$
 372 +                               classpath = getArgument(currentArg);
 373 +                       } else if (currentArg.equals("-fzip-target")) { //$NON-NLS-1$
 374 +                               ++i;
 375 +                               if (i >= argv.length)
 376 +                                       throw new InvalidInputException(this.bind("gcc.zipArg")); //$NON-NLS-1$
 377 +                               this.zipDestination = argv[i];
 378 +                       } else if (currentArg.equals("-fzip-dependency")) { //$NON-NLS-1$
 379 +                               ++i;
 380 +                               if (i >= argv.length)
 381 +                                       throw new InvalidInputException(this.bind("gcc.zipDepArg")); //$NON-NLS-1$
 382 +                               this.zipDependencyDestination = argv[i];
 383 +                       } else if (currentArg.startsWith("-g")) { //$NON-NLS-1$
 384 +                               if (currentArg.equals("-g0")) { //$NON-NLS-1$
 385 +                                       setDebugLevel(0);
 386 +                               } else if (currentArg.equals("-g2") || currentArg.equals("-g3") //$NON-NLS-1$ //$NON-NLS-2$
 387 +                                               || currentArg.equals("-g")) { //$NON-NLS-1$
 388 +                                       setDebugLevel(2);
 389 +                               } else {
 390 +                                       // Handle -g1 but also things like -gstabs.
 391 +                                       setDebugLevel(1);
 392 +                               }
 393 +                       } else if (currentArg.equals("-Werror")) { //$NON-NLS-1$
 394 +                               treatWarningsAsErrors = true;
 395 +                       } else if (currentArg.equals("-Wno-error")) { //$NON-NLS-1$
 396 +                               treatWarningsAsErrors = false;
 397 +                       } else if (currentArg.equals("-Wall")) { //$NON-NLS-1$
 398 +                               handleWall(true);
 399 +                       } else if (currentArg.equals("-Wno-all")) { //$NON-NLS-1$
 400 +                               handleWall(false);
 401 +                       } else if (currentArg.startsWith("-Wno-")) { //$NON-NLS-1$
 402 +                               handleWarningToken(currentArg.substring(5), false, false);
 403 +                       } else if (currentArg.startsWith("-W")) { //$NON-NLS-1$
 404 +                               handleWarningToken(currentArg.substring(2), true, false);
 405 +                       } else if (currentArg.equals("-w")) { //$NON-NLS-1$
 406 +                               inhibitAllWarnings = true;
 407 +                       } else if (currentArg.startsWith("-O")) { //$NON-NLS-1$
 408 +                               // Ignore.
 409 +                       } else if (currentArg.equals("-v")) { //$NON-NLS-1$
 410 +                               this.verbose = true;
 411 +                       } else if (currentArg.equals("-fsyntax-only")) { //$NON-NLS-1$
 412 +                               this.syntaxOnly = true;
 413 +                       } else if (currentArg.startsWith("-fsource=")) { //$NON-NLS-1$
 414 +                               currentArg = getArgument(currentArg);
 415 +                               if (currentArg.equals("1.3")) { //$NON-NLS-1$
 416 +                                       this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_3);
 417 +                               } else if (currentArg.equals("1.4")) { //$NON-NLS-1$
 418 +                                       this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4);
 419 +                               } else if (currentArg.equals("1.5") || currentArg.equals("5") || currentArg.equals("5.0")) { //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
 420 +                                       this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_5);
 421 +                               } else if (currentArg.equals("1.6") || currentArg.equals("6") || currentArg.equals("6.0")) { //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
 422 +                                       this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_6);
 423 +                               } else {
 424 +                                       throw new InvalidInputException(this.bind("configure.source", currentArg)); //$NON-NLS-1$
 425 +                               }
 426 +                       } else if (currentArg.startsWith("-ftarget=")) { //$NON-NLS-1$
 427 +                               currentArg = getArgument(currentArg);
 428 +                               if (currentArg.equals("1.1")) { //$NON-NLS-1$
 429 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_1);
 430 +                               } else if (currentArg.equals("1.2")) { //$NON-NLS-1$
 431 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_2);
 432 +                               } else if (currentArg.equals("1.3")) { //$NON-NLS-1$
 433 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_3);
 434 +                               } else if (currentArg.equals("1.4")) { //$NON-NLS-1$
 435 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_4);
 436 +                               } else if (currentArg.equals("1.5") || currentArg.equals("5") || currentArg.equals("5.0")) { //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
 437 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_5);
 438 +                               } else if (currentArg.equals("1.6") || currentArg.equals("6") || currentArg.equals("6.0")) { //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
 439 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_6);
 440 +                               } else if (currentArg.equals("jsr14")) { //$NON-NLS-1$
 441 +                                       this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_JSR14);
 442 +                               } else {
 443 +                                       throw new InvalidInputException(this.bind("configure.targetJDK", currentArg)); //$NON-NLS-1$
 444 +                               }
 445 +                       } else if (currentArg.equals("-ffilelist-file")) { //$NON-NLS-1$
 446 +                               haveFileList = true;
 447 +                       } else if (currentArg.endsWith(SuffixConstants.SUFFIX_STRING_java)) {
 448 +                               files.add(currentArg);
 449 +                       } else if (currentArg.charAt(0) == '-'){
 450 +                               // FIXME: error if not a file?
 451 +                       } else {
 452 +                               otherFiles.add(currentArg);
 453 +                       }
 454 +               }
 455 +
 456 +               // Read the file list file.  We read them all, but really there
 457 +               // will only be one.
 458 +               if (haveFileList)
 459 +                       readAllFileListFiles(otherFiles, files);
 460 +
 461 +               this.filenames = (String[]) files.toArray(new String[0]);
 462 +               this.encodings = new String[this.filenames.length];
 463 +               this.destinationPaths = new String[this.filenames.length];
 464 +               for (int i = 0; i < this.filenames.length; ++i)
 465 +                       this.destinationPaths[i] = this.destinationPath;
 466 +
 467 +               // Classpath processing.
 468 +               ArrayList result = new ArrayList();
 469 +               if (classpath == null)
 470 +                       throw new InvalidInputException(this.bind("gcc.noClasspath")); //$NON-NLS-1$
 471 +               parsePath(result, classpath);
 472 +
 473 +               // We must always create both output files, even if one is not used.
 474 +               // That way we will always pass valid zip file on to jc1.
 475 +               try {
 476 +                       getZipOutput();
 477 +                       getDependencyOutput();
 478 +               } catch (IOException err) {
 479 +                       fail(err);
 480 +               }
 481 +
 482 +               if (inhibitAllWarnings)
 483 +                       disableWarnings();
 484 +               if (treatWarningsAsErrors)
 485 +                       turnWarningsToErrors();
 486 +
 487 +               this.checkedClasspaths = new FileSystem.Classpath[result.size()];
 488 +               result.toArray(this.checkedClasspaths);
 489 +
 490 +               this.logger.logCommandLineArguments(argv);
 491 +               this.logger.logOptions(this.options);
 492 +               this.logger.logClasspath(this.checkedClasspaths);
 493 +
 494 +               this.repetitions = 1;
 495 +       }
 496 +
 497 +       public boolean compile(String[] argv) {
 498 +               boolean result = super.compile(argv);
 499 +               try {
 500 +                       if (zipStream != null) {
 501 +                               zipStream.finish();
 502 +                               zipStream.close();
 503 +                       }
 504 +                       if (zipDependencyStream != null) {
 505 +                               zipDependencyStream.finish();
 506 +                               zipDependencyStream.close();
 507 +                       }
 508 +               } catch (IOException err) {
 509 +                       fail(err);
 510 +               }
 511 +               return result;
 512 +       }
 513 +
 514 +       public static void main(String[] argv) {
 515 +               boolean result = new GCCMain(new PrintWriter(System.out), new PrintWriter(System.err), false).compile(argv);
 516 +               System.exit(result ? 0 : 1);
 517 +       }
 518 +}