Attachment #118371 for bug #255974

View | Details | Raw Unified | Return to bug 255974
Collapse All | Expand All




import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.CompilationProgress;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.ClassFile;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;

				// request compilation
				performCompilation();
			}
		} catch(IllegalArgumentException e) {
			this.logger.logException(e);
			if (this.systemExitWhenFinished) {
				cleanup();
				System.exit(-1);
			}
			return false;
		} catch(IllegalArgumentException e) {
			throw e;
		} catch (RuntimeException e) { // internal compiler failure
			this.logger.logException(e);
			return false;

			ArrayList classpaths,
			ArrayList extdirsClasspaths,
			ArrayList endorsedDirClasspaths,
			String customEncoding) {

		ArrayList<FileSystem.Classpath> fileSystemClasspaths = new ArrayList<FileSystem.Classpath>();
		EclipseFileManager javaFileManager = null;

Lines 35-41 Link Here

(-)src/org/eclipse/jdt/internal/compiler/tool/EclipseCompiler.java (-3 / +2 lines)
35	import javax.tools.StandardJavaFileManager;	35	import javax.tools.StandardJavaFileManager;
36	import javax.tools.StandardLocation;	36	import javax.tools.StandardLocation;
37		37
38	import org.eclipse.jdt.core.compiler.InvalidInputException;
39	import org.eclipse.jdt.internal.compiler.batch.Main;	38	import org.eclipse.jdt.internal.compiler.batch.Main;
40	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	39	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
41		40
Lines 167-174 Link Here
167	allOptions.toArray(optionsToProcess);	166	allOptions.toArray(optionsToProcess);
168	try {	167	try {
169	eclipseCompiler2.configure(optionsToProcess);	168	eclipseCompiler2.configure(optionsToProcess);
170	} catch (InvalidInputException e) {	169	} catch (IllegalArgumentException e) {
171	throw new RuntimeException(e);	170	throw e;
172	}	171	}
173		172
174	if (eclipseCompiler2.fileManager instanceof StandardJavaFileManager) {	173	if (eclipseCompiler2.fileManager instanceof StandardJavaFileManager) {




import javax.tools.JavaFileObject.Kind;

import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.batch.FileSystem;
import org.eclipse.jdt.internal.compiler.batch.Main;
import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

	@SuppressWarnings("unchecked")
	public void processPathEntries(final int defaultSize, final ArrayList paths,
			final String currentPath, String customEncoding, boolean isSourceOnly,
			boolean rejectDestinationPathOnJars) {

		String currentClasspathName = null;
		String currentDestinationPath = null;
		ArrayList currentRuleSpecs = new ArrayList(defaultSize);

					state = rulesNeedAnotherRule;
					break;
				case destinationPathReadyToClose:
					throw new IllegalArgumentException(
							this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
									currentPath));
				case bracketClosed:

				case rulesStart:
					if (token.startsWith("-d ")) { //$NON-NLS-1$
						if (currentDestinationPath != null) {
							throw new IllegalArgumentException(
									this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$
											currentPath));
						}

					} // else we proceed with a rule
				case rulesNeedAnotherRule:
					if (currentDestinationPath != null) {
						throw new IllegalArgumentException(
								this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$
									currentPath));
					}

	protected void addNewEntry(ArrayList paths, String currentClasspathName,
			ArrayList currentRuleSpecs, String customEncoding,
			String destPath, boolean isSourceOnly,
			boolean rejectDestinationPathOnJars) {

		int rulesSpecsSize = currentRuleSpecs.size();
		AccessRuleSet accessRuleSet = null;

		if (rejectDestinationPathOnJars && destPath != null &&
				(currentClasspathName.endsWith(".jar") || //$NON-NLS-1$
					currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
			throw new IllegalArgumentException(
					this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
								currentClasspathName));
			}




import javax.tools.JavaFileObject.Kind;

import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.internal.compiler.batch.FileSystem;
import org.eclipse.jdt.internal.compiler.batch.Main;
import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

		ArrayList<File> files = new ArrayList<File>();
		try {
			this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
		} catch (IllegalArgumentException e) {
			return null;
		}
		for (FileSystem.Classpath classpath : paths) {

	@SuppressWarnings("unchecked")
	public void processPathEntries(final int defaultSize, final ArrayList paths,
			final String currentPath, String customEncoding, boolean isSourceOnly,
			boolean rejectDestinationPathOnJars) {
		throws InvalidInputException {
		String currentClasspathName = null;
		String currentDestinationPath = null;
		ArrayList currentRuleSpecs = new ArrayList(defaultSize);

					state = rulesNeedAnotherRule;
					break;
				case destinationPathReadyToClose:
					throw new IllegalArgumentException(
							this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
									currentPath));
				case bracketClosed:

				case rulesStart:
					if (token.startsWith("-d ")) { //$NON-NLS-1$
						if (currentDestinationPath != null) {
							throw new IllegalArgumentException(
									this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$
											currentPath));
						}

					} // else we proceed with a rule
				case rulesNeedAnotherRule:
					if (currentDestinationPath != null) {
						throw new IllegalArgumentException(
								this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$
									currentPath));
					}

	protected void addNewEntry(ArrayList paths, String currentClasspathName,
			ArrayList currentRuleSpecs, String customEncoding,
			String destPath, boolean isSourceOnly,
			boolean rejectDestinationPathOnJars) {

		int rulesSpecsSize = currentRuleSpecs.size();
		AccessRuleSet accessRuleSet = null;

		if (rejectDestinationPathOnJars && destPath != null &&
				(currentClasspathName.endsWith(".jar") || //$NON-NLS-1$
					currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
			throw new IllegalArgumentException(
					this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
								currentClasspathName));
			}




import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.CompilationProgress;
import org.eclipse.jdt.core.compiler.IProblem;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.core.compiler.batch.BatchCompiler;
import org.eclipse.jdt.internal.compiler.AbstractAnnotationProcessorManager;
import org.eclipse.jdt.internal.compiler.ClassFile;

		public void setEmacs() {
			this.tagBits |= Logger.EMACS;
		}
		public void setLog(String logFileName) {
			final Date date = new Date();
			final DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.LONG, Locale.getDefault());
			try {

					this.log.println("# " + dateFormat.format(date));//$NON-NLS-1$
				}
			} catch (FileNotFoundException e) {
				throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLog", logFileName)); //$NON-NLS-1$
			} catch (UnsupportedEncodingException e) {
				throw new IllegalArgumentException(this.main.bind("configure.cannotOpenLogInvalidEncoding", logFileName)); //$NON-NLS-1$
			}
		}
		private void startLoggingExtraProblems(int count) {

protected void addNewEntry(ArrayList paths, String currentClasspathName,
		ArrayList currentRuleSpecs, String customEncoding,
		String destPath, boolean isSourceOnly,
		boolean rejectDestinationPathOnJars) {

	int rulesSpecsSize = currentRuleSpecs.size();
	AccessRuleSet accessRuleSet = null;

	}
	if (rejectDestinationPathOnJars && destPath != null &&
			Util.isPotentialZipArchive(currentClasspathName)) {
		throw new IllegalArgumentException(
			this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
						currentClasspathName));
	}

			this.logger.close();
			System.exit(this.globalErrorsCount > 0 ? -1 : 0);
		}
	} catch (IllegalArgumentException e) {
		this.logger.logException(e);
		if (this.systemExitWhenFinished) {
			this.logger.flush();

/*
Decode the command line arguments
 */
public void configure(String[] argv) {

	if ((argv == null) || (argv.length == 0)) {
		printUsage();

					}
					newArgs = tokenize(buffer.toString());
				} catch(IOException e) {
					throw new IllegalArgumentException(
						this.bind("configure.invalidexpansionargumentname", arg)); //$NON-NLS-1$
				}
			}

	while (++index < argCount) {

		if (customEncoding != null) {
			throw new IllegalArgumentException(
				this.bind("configure.unexpectedCustomEncoding", currentArg, customEncoding)); //$NON-NLS-1$
		}


		switch(mode) {
			case DEFAULT :
				if (currentArg.startsWith("[")) { //$NON-NLS-1$
					throw new IllegalArgumentException(
						this.bind("configure.unexpectedBracket", //$NON-NLS-1$
									currentArg));
				}

					// look for encoding specification
					int encodingStart = currentArg.indexOf('[') + 1;
					if (encodingStart <= 1) {
						throw new IllegalArgumentException(
								this.bind("configure.unexpectedBracket", currentArg)); //$NON-NLS-1$
					}
					int encodingEnd = currentArg.length() - 1;

							try { // ensure encoding is supported
								new InputStreamReader(new ByteArrayInputStream(new byte[0]), customEncoding);
							} catch (UnsupportedEncodingException e) {
								throw new IllegalArgumentException(
									this.bind("configure.unsupportedEncoding", customEncoding)); //$NON-NLS-1$
							}
						}

				}
				if (currentArg.equals("-log")) { //$NON-NLS-1$
					if (this.log != null)
						throw new IllegalArgumentException(
							this.bind("configure.duplicateLog", currentArg)); //$NON-NLS-1$
					mode = INSIDE_LOG;
					continue;
				}
				if (currentArg.equals("-repeat")) { //$NON-NLS-1$
					if (this.maxRepetition > 0)
						throw new IllegalArgumentException(
							this.bind("configure.duplicateRepeat", currentArg)); //$NON-NLS-1$
					mode = INSIDE_REPETITION;
					continue;
				}
				if (currentArg.equals("-maxProblems")) { //$NON-NLS-1$
					if (this.maxProblems > 0)
						throw new IllegalArgumentException(
							this.bind("configure.duplicateMaxProblems", currentArg)); //$NON-NLS-1$
					mode = INSIDE_MAX_PROBLEMS;
					continue;

				}
				if (currentArg.equals("-1.3")) { //$NON-NLS-1$
					if (didSpecifyCompliance) {
						throw new IllegalArgumentException(
							this.bind("configure.duplicateCompliance", currentArg));//$NON-NLS-1$
					}
					didSpecifyCompliance = true;

				}
				if (currentArg.equals("-1.4")) { //$NON-NLS-1$
					if (didSpecifyCompliance) {
						throw new IllegalArgumentException(
							this.bind("configure.duplicateCompliance", currentArg)); //$NON-NLS-1$
					}
					didSpecifyCompliance = true;

				}
				if (currentArg.equals("-1.5") || currentArg.equals("-5") || currentArg.equals("-5.0")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
					if (didSpecifyCompliance) {
						throw new IllegalArgumentException(
							this.bind("configure.duplicateCompliance", currentArg)); //$NON-NLS-1$
					}
					didSpecifyCompliance = true;

				}
				if (currentArg.equals("-1.6") || currentArg.equals("-6") || currentArg.equals("-6.0")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
					if (didSpecifyCompliance) {
						throw new IllegalArgumentException(
							this.bind("configure.duplicateCompliance", currentArg)); //$NON-NLS-1$
					}
					didSpecifyCompliance = true;

				}
				if (currentArg.equals("-1.7") || currentArg.equals("-7") || currentArg.equals("-7.0")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
					if (didSpecifyCompliance) {
						throw new IllegalArgumentException(
							this.bind("configure.duplicateCompliance", currentArg)); //$NON-NLS-1$
					}
					didSpecifyCompliance = true;

							errorMessage.append(' ');
							errorMessage.append(newCommandLineArgs[index + 1]);
						}
						throw new IllegalArgumentException(
							this.bind("configure.duplicateOutputPath", errorMessage.toString())); //$NON-NLS-1$
					}
					mode = INSIDE_DESTINATION_PATH;

							errorMessage.append(' ');
							errorMessage.append(newCommandLineArgs[index + 1]);
						}
						throw new IllegalArgumentException(
							this.bind("configure.duplicateBootClasspath", errorMessage.toString())); //$NON-NLS-1$
					}
					mode = INSIDE_BOOTCLASSPATH_start;

							errorMessage.append(' ');
							errorMessage.append(newCommandLineArgs[index + 1]);
						}
						throw new IllegalArgumentException(
							this.bind("configure.duplicateSourcepath", errorMessage.toString())); //$NON-NLS-1$
					}
					mode = INSIDE_SOURCE_PATH_start;

							errorMessage.append(' ');
							errorMessage.append(newCommandLineArgs[index + 1]);
						}
						throw new IllegalArgumentException(
							this.bind("configure.duplicateExtDirs", errorMessage.toString())); //$NON-NLS-1$
					}
					mode = INSIDE_EXT_DIRS;

							errorMessage.append(' ');
							errorMessage.append(newCommandLineArgs[index + 1]);
						}
						throw new IllegalArgumentException(
							this.bind("configure.duplicateEndorsedDirs", errorMessage.toString())); //$NON-NLS-1$
					}
					mode = INSIDE_ENDORSED_DIRS;

									CompilerOptions.OPTION_SourceFileAttribute,
									CompilerOptions.GENERATE);
							} else {
								throw new IllegalArgumentException(
									this.bind("configure.invalidDebugOption", debugOption)); //$NON-NLS-1$
							}
						}
						continue;
					}
					throw new IllegalArgumentException(
						this.bind("configure.invalidDebugOption", debugOption)); //$NON-NLS-1$
				}
				if (currentArg.startsWith("-nowarn")) { //$NON-NLS-1$

						continue;
					}
					if (length <= 6) {
						throw new IllegalArgumentException(
							this.bind("configure.invalidWarningConfiguration", warningOption)); //$NON-NLS-1$
					}
					int warnTokenStart;

						handleWarningToken(token, isEnabling);
					}
					if (tokenCounter == 0) {
						throw new IllegalArgumentException(
							this.bind("configure.invalidWarningOption", currentArg)); //$NON-NLS-1$
					}
					continue;

				break;
			case INSIDE_TARGET :
				if (this.didSpecifyTarget) {
					throw new IllegalArgumentException(
						this.bind("configure.duplicateTarget", currentArg));//$NON-NLS-1$
				}
				this.didSpecifyTarget = true;

					this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_CLDC1_1);
					this.options.put(CompilerOptions.OPTION_InlineJsr, CompilerOptions.ENABLED);
				}else {
					throw new IllegalArgumentException(this.bind("configure.targetJDK", currentArg)); //$NON-NLS-1$
				}
				mode = DEFAULT;
				continue;

				try {
					this.maxRepetition = Integer.parseInt(currentArg);
					if (this.maxRepetition <= 0) {
						throw new IllegalArgumentException(this.bind("configure.repetition", currentArg)); //$NON-NLS-1$
					}
				} catch (NumberFormatException e) {
					throw new IllegalArgumentException(this.bind("configure.repetition", currentArg)); //$NON-NLS-1$
				}
				mode = DEFAULT;
				continue;

				try {
					this.maxProblems = Integer.parseInt(currentArg);
					if (this.maxProblems <= 0) {
						throw new IllegalArgumentException(this.bind("configure.maxProblems", currentArg)); //$NON-NLS-1$
					}
					this.options.put(CompilerOptions.OPTION_MaxProblemPerUnit, currentArg);
				} catch (NumberFormatException e) {
					throw new IllegalArgumentException(this.bind("configure.maxProblems", currentArg)); //$NON-NLS-1$
				}
				mode = DEFAULT;
				continue;
			case INSIDE_SOURCE :
				if (this.didSpecifySource) {
					throw new IllegalArgumentException(
						this.bind("configure.duplicateSource", currentArg));//$NON-NLS-1$
				}
				this.didSpecifySource = true;

				} else if (currentArg.equals("1.7") || currentArg.equals("7") || currentArg.equals("7.0")) { //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
					this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_7);
				} else {
					throw new IllegalArgumentException(this.bind("configure.source", currentArg)); //$NON-NLS-1$
				}
				mode = DEFAULT;
				continue;
			case INSIDE_DEFAULT_ENCODING :
				if (didSpecifyDefaultEncoding) {
					throw new IllegalArgumentException(
						this.bind("configure.duplicateDefaultEncoding", currentArg)); //$NON-NLS-1$
				}
				try { // ensure encoding is supported
					new InputStreamReader(new ByteArrayInputStream(new byte[0]), currentArg);
				} catch (UnsupportedEncodingException e) {
					throw new IllegalArgumentException(
						this.bind("configure.unsupportedEncoding", currentArg)); //$NON-NLS-1$
				}
				this.options.put(CompilerOptions.OPTION_Encoding, currentArg);

				continue;
			case INSIDE_EXT_DIRS:
				if (currentArg.indexOf("[-d") != -1) { //$NON-NLS-1$
					throw new IllegalArgumentException(
						this.bind("configure.unexpectedDestinationPathEntry", //$NON-NLS-1$
							"-extdir")); //$NON-NLS-1$
				}

				continue;
			case INSIDE_ENDORSED_DIRS:
				if (currentArg.indexOf("[-d") != -1) { //$NON-NLS-1$
					throw new IllegalArgumentException(
						this.bind("configure.unexpectedDestinationPathEntry", //$NON-NLS-1$
							"-endorseddirs")); //$NON-NLS-1$
				}				tokenizer = new StringTokenizer(currentArg,	File.pathSeparator, false);

					customDestinationPath = currentArg.substring(0,
						currentArg.length() - 1);
				} else {
					throw new IllegalArgumentException(
						this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
							"[-d " + currentArg)); //$NON-NLS-1$
				}

		}
		File dir = new File(currentSourceDirectory);
		if (!dir.isDirectory()) {
			throw new IllegalArgumentException(
				this.bind("configure.unrecognizedOption", currentSourceDirectory)); //$NON-NLS-1$
		}
		String[] result = FileFinder.find(dir, SuffixConstants.SUFFIX_STRING_JAVA);

/*
 *  Build the set of compilation source units
 */
public CompilationUnit[] getCompilationUnits() {
	throws InvalidInputException {
	int fileCount = this.filenames.length;
	CompilationUnit[] units = new CompilationUnit[fileCount];
	HashtableOfObject knownFileNames = new HashtableOfObject(fileCount);

	for (int i = 0; i < fileCount; i++) {
		char[] charName = this.filenames[i].toCharArray();
		if (knownFileNames.get(charName) != null)
			throw new IllegalArgumentException(this.bind("unit.more", this.filenames[i])); //$NON-NLS-1$
		knownFileNames.put(charName, charName);
		File file = new File(this.filenames[i]);
		if (!file.exists())
			throw new IllegalArgumentException(this.bind("unit.missing", this.filenames[i])); //$NON-NLS-1$
		String encoding = this.encodings[i];
		if (encoding == null)
			encoding = defaultEncoding;

/*
 * External API
 */
protected ArrayList handleBootclasspath(ArrayList bootclasspaths, String customEncoding) {
 	final int bootclasspathsSize = bootclasspaths == null ? 0 : bootclasspaths.size();
	if (bootclasspathsSize != 0) {
		String[] paths = new String[bootclasspathsSize];

/*
 * External API
 */
protected ArrayList handleClasspath(ArrayList classpaths, String customEncoding) {
	final int classpathsSize = classpaths == null ? 0 : classpaths.size();
	if (classpathsSize != 0) {
		String[] paths = new String[classpathsSize];

 * External API
 * Handle a single warning token.
*/
protected void handleWarningToken(String token, boolean isEnabling) {
	if (token.length() == 0) return;
	switch(token.charAt(0)) {
		case 'a' :

					taskTags = taskTags.replace('|',',');
				}
				if (taskTags.length() == 0){
					throw new IllegalArgumentException(this.bind("configure.invalidTaskTag", token)); //$NON-NLS-1$
				}
				this.options.put(
					CompilerOptions.OPTION_TaskTags,

/*
 *  Low-level API performing the actual compilation
 */
public void performCompilation() {

	this.startTime = System.currentTimeMillis();


			}));
	this.logger.flush();
}
private ReferenceBinding[] processClassNames(LookupEnvironment environment) {
	// check for .class file presence in case of apt processing
	int length = this.classNames.length;
	ReferenceBinding[] referenceBindings = new ReferenceBinding[length];

				referenceBindings[i] = type;
			}
		} else {
			throw new IllegalArgumentException(
					this.bind("configure.invalidClassName", currentName));//$NON-NLS-1$
		}
	}

 */
public void processPathEntries(final int defaultSize, final ArrayList paths,
			final String currentPath, String customEncoding, boolean isSourceOnly,
			boolean rejectDestinationPathOnJars) {
		throws InvalidInputException {
	String currentClasspathName = null;
	String currentDestinationPath = null;
	ArrayList currentRuleSpecs = new ArrayList(defaultSize);

				state = rulesNeedAnotherRule;
				break;
			case destinationPathReadyToClose:
				throw new IllegalArgumentException(
					this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
						currentPath));
			case bracketClosed:

			case rulesStart:
				if (token.startsWith("-d ")) { //$NON-NLS-1$
					if (currentDestinationPath != null) {
						throw new IllegalArgumentException(
								this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$
										currentPath));
					}

				//$FALL-THROUGH$
			case rulesNeedAnotherRule:
				if (currentDestinationPath != null) {
					throw new IllegalArgumentException(
							this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$
								currentPath));
				}

	}
}

private int processPaths(String[] args, int index, String currentArg, ArrayList paths) {
	int localIndex = index;
	int count = 0;
	for (int i = 0, max = currentArg.length(); i < max; i++) {

	if (count == 0) {
		paths.add(currentArg);
	} else if (count > 1) {
		throw new IllegalArgumentException(
				this.bind("configure.unexpectedBracket", //$NON-NLS-1$
							currentArg));
	} else {
		StringBuffer currentPath = new StringBuffer(currentArg);
		while (true) {
			if (localIndex >= args.length) {
				throw new IllegalArgumentException(
						this.bind("configure.unexpectedBracket", //$NON-NLS-1$
								currentArg));
			}

				switch(nextArg.charAt(i)) {
					case '[' :
						if (count > 1) {
							throw new IllegalArgumentException(
									this.bind("configure.unexpectedBracket", //$NON-NLS-1$
											nextArg));
						}

				paths.add(currentPath.toString());
				return localIndex - index;
			} else if (count < 0) {
				throw new IllegalArgumentException(
						this.bind("configure.unexpectedBracket", //$NON-NLS-1$
									nextArg));
			} else {

	}
	return localIndex - index;
}
private int processPaths(String[] args, int index, String currentArg, String[] paths) {
	int localIndex = index;
	int count = 0;
	for (int i = 0, max = currentArg.length(); i < max; i++) {

		while (true) {
			localIndex++;
			if (localIndex >= args.length) {
				throw new IllegalArgumentException(
						this.bind("configure.unexpectedBracket", //$NON-NLS-1$
								currentArg));
			}

				switch(nextArg.charAt(i)) {
					case '[' :
						if (count > 1) {
							throw new IllegalArgumentException(
									this.bind("configure.unexpectedBracket", //$NON-NLS-1$
											currentArg));
						}

				paths[0] = currentPath.toString();
				return localIndex - index;
			} else if (count < 0) {
				throw new IllegalArgumentException(
						this.bind("configure.unexpectedBracket", //$NON-NLS-1$
									currentArg));
			} else {

		ArrayList classpaths,
		ArrayList extdirsClasspaths,
		ArrayList endorsedDirClasspaths,
		String customEncoding) {

	// process bootclasspath, classpath and sourcepaths
 	bootclasspaths = handleBootclasspath(bootclasspaths, customEncoding);

	classpaths.toArray(this.checkedClasspaths);
	this.logger.logClasspath(this.checkedClasspaths);
}
protected void validateOptions(boolean didSpecifyCompliance) {
	if (didSpecifyCompliance) {
		Object version = this.options.get(CompilerOptions.OPTION_Compliance);
		if (CompilerOptions.VERSION_1_3.equals(version)) {

	if (sourceVersion.equals(CompilerOptions.VERSION_1_7)
			&& CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK1_7) {
		// compliance must be 1.7 if source is 1.7
		throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForSource", (String)this.options.get(CompilerOptions.OPTION_Compliance), CompilerOptions.VERSION_1_7)); //$NON-NLS-1$
	} else if (sourceVersion.equals(CompilerOptions.VERSION_1_6)
			&& CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK1_6) {
		// compliance must be 1.6 if source is 1.6
		throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForSource", (String)this.options.get(CompilerOptions.OPTION_Compliance), CompilerOptions.VERSION_1_6)); //$NON-NLS-1$
	} else if (sourceVersion.equals(CompilerOptions.VERSION_1_5)
			&& CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK1_5) {
		// compliance must be 1.5 if source is 1.5
		throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForSource", (String)this.options.get(CompilerOptions.OPTION_Compliance), CompilerOptions.VERSION_1_5)); //$NON-NLS-1$
	} else if (sourceVersion.equals(CompilerOptions.VERSION_1_4)
			&& CompilerOptions.versionToJdkLevel(compliance) < ClassFileConstants.JDK1_4) {
		// compliance must be 1.4 if source is 1.4
		throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForSource", (String)this.options.get(CompilerOptions.OPTION_Compliance), CompilerOptions.VERSION_1_4)); //$NON-NLS-1$
	}

	// check and set compliance/source/target compatibilities

		if (CompilerOptions.VERSION_JSR14.equals(targetVersion)) {
			// expecting source >= 1.5
			if (CompilerOptions.versionToJdkLevel(sourceVersion) < ClassFileConstants.JDK1_5) {
				throw new IllegalArgumentException(this.bind("configure.incompatibleTargetForGenericSource", (String) targetVersion, (String) sourceVersion)); //$NON-NLS-1$
			}
		} else if (CompilerOptions.VERSION_CLDC1_1.equals(targetVersion)) {
			if (this.didSpecifySource && CompilerOptions.versionToJdkLevel(sourceVersion) >= ClassFileConstants.JDK1_4) {
				throw new IllegalArgumentException(this.bind("configure.incompatibleSourceForCldcTarget", (String) targetVersion, (String) sourceVersion)); //$NON-NLS-1$
			}
			if (CompilerOptions.versionToJdkLevel(compliance) >= ClassFileConstants.JDK1_5) {
				throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForCldcTarget", (String) targetVersion, (String) sourceVersion)); //$NON-NLS-1$
			}
		} else {
			// target must be 1.7 if source is 1.7
			if (CompilerOptions.versionToJdkLevel(sourceVersion) >= ClassFileConstants.JDK1_7
					&& CompilerOptions.versionToJdkLevel(targetVersion) < ClassFileConstants.JDK1_7){
				throw new IllegalArgumentException(this.bind("configure.incompatibleTargetForSource", (String) targetVersion, CompilerOptions.VERSION_1_7)); //$NON-NLS-1$
			}
			// target must be 1.6 if source is 1.6
			if (CompilerOptions.versionToJdkLevel(sourceVersion) >= ClassFileConstants.JDK1_6
					&& CompilerOptions.versionToJdkLevel(targetVersion) < ClassFileConstants.JDK1_6){
				throw new IllegalArgumentException(this.bind("configure.incompatibleTargetForSource", (String) targetVersion, CompilerOptions.VERSION_1_6)); //$NON-NLS-1$
			}
			// target must be 1.5 if source is 1.5
			if (CompilerOptions.versionToJdkLevel(sourceVersion) >= ClassFileConstants.JDK1_5
					&& CompilerOptions.versionToJdkLevel(targetVersion) < ClassFileConstants.JDK1_5){
				throw new IllegalArgumentException(this.bind("configure.incompatibleTargetForSource", (String) targetVersion, CompilerOptions.VERSION_1_5)); //$NON-NLS-1$
			}
			// target must be 1.4 if source is 1.4
			if (CompilerOptions.versionToJdkLevel(sourceVersion) >= ClassFileConstants.JDK1_4
					&& CompilerOptions.versionToJdkLevel(targetVersion) < ClassFileConstants.JDK1_4){
				throw new IllegalArgumentException(this.bind("configure.incompatibleTargetForSource", (String) targetVersion, CompilerOptions.VERSION_1_4)); //$NON-NLS-1$
			}
			// target cannot be greater than compliance level
			if (CompilerOptions.versionToJdkLevel(compliance) < CompilerOptions.versionToJdkLevel(targetVersion)){
				throw new IllegalArgumentException(this.bind("configure.incompatibleComplianceForTarget", (String)this.options.get(CompilerOptions.OPTION_Compliance), (String) targetVersion)); //$NON-NLS-1$
			}
		}
	}

Lines 1284-1290 Link Here

(-)src/org/eclipse/jdt/core/tests/util/Util.java (-1 / +3 lines)
1284	throw new IOException("Could not delete " + zipPath);	1284	throw new IOException("Could not delete " + zipPath);
1285	// ensure the new zip file has a different timestamp than the previous one	1285	// ensure the new zip file has a different timestamp than the previous one
1286	int timeToWait = 1000; // some platform (like Linux) have a 1s granularity)	1286	int timeToWait = 1000; // some platform (like Linux) have a 1s granularity)
1287	waitAtLeast(timeToWait);	1287	waitAtLeast(timeToWait);
		1288	} else {
		1289	zipFile.getParentFile().mkdirs();
1288	}	1290	}
1289	zip = new ZipOutputStream(new FileOutputStream(zipFile));	1291	zip = new ZipOutputStream(new FileOutputStream(zipFile));
1290	zip(rootDir, zip, rootDir.getPath().length()+1); // 1 for last slash	1292	zip(rootDir, zip, rootDir.getPath().length()+1); // 1 for last slash




import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.compiler.CharOperation;
import org.eclipse.jdt.core.compiler.CompilationProgress;
import org.eclipse.jdt.core.compiler.InvalidInputException;
import org.eclipse.jdt.core.compiler.batch.BatchCompiler;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.compiler.batch.ClasspathJar;

	try {
		(new Main(new PrintWriter(System.out), new PrintWriter(System.err), true/*systemExit*/, null/*options*/, null/*progress*/)).
			processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, classpathInput, null /* customEncoding */, true /* isSourceOnly */, false /* rejectDestinationPathOnJars*/);
	} catch (IllegalArgumentException e) {
		// e.printStackTrace();
		if (expectedError == null) {
			fail("unexpected invalid input exception: " + e.getMessage());

	}
//	 https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - cumulative -extdirs extends the classpath
	public void test025(){
		String path = org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest.LIB_DIR;
		String libPath = null;
		if (path.endsWith(File.separator)) {
			libPath = path + "lib.jar";

				JavaCore.VERSION_1_4);
			jarCreated = true;
		} catch (IOException e) {
			e.printStackTrace();
			assertTrue("Should not happen", false);
		}
		String setting= System.getProperty("jdt.compiler.useSingleThread");
		try {

Return to bug 255974

Lines 38-44 Link Here

(-)src/org/eclipse/jdt/internal/compiler/tool/EclipseFileManager.java (-11 / +10 lines)
38	import javax.tools.JavaFileObject.Kind;	38	import javax.tools.JavaFileObject.Kind;
39		39
40	import org.eclipse.jdt.core.compiler.IProblem;	40	import org.eclipse.jdt.core.compiler.IProblem;
41	import org.eclipse.jdt.core.compiler.InvalidInputException;
42	import org.eclipse.jdt.internal.compiler.batch.FileSystem;	41	import org.eclipse.jdt.internal.compiler.batch.FileSystem;
43	import org.eclipse.jdt.internal.compiler.batch.Main;	42	import org.eclipse.jdt.internal.compiler.batch.Main;
44	import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;	43	import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;
Lines 276-282 Link Here
276	ArrayList<File> files = new ArrayList<File>();	275	ArrayList<File> files = new ArrayList<File>();
277	try {	276	try {
278	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	277	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
279	} catch (InvalidInputException e) {	278	} catch (IllegalArgumentException e) {
280	return null;	279	return null;
281	}	280	}
282	for (FileSystem.Classpath classpath : paths) {	281	for (FileSystem.Classpath classpath : paths) {
Lines 346-352 Link Here
346	ArrayList<File> files = new ArrayList<File>();	345	ArrayList<File> files = new ArrayList<File>();
347	try {	346	try {
348	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	347	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
349	} catch (InvalidInputException e) {	348	} catch (IllegalArgumentException e) {
350	return null;	349	return null;
351	}	350	}
352	for (FileSystem.Classpath classpath : paths) {	351	for (FileSystem.Classpath classpath : paths) {
Lines 360-366 Link Here
360	ArrayList<File> files = new ArrayList<File>();	359	ArrayList<File> files = new ArrayList<File>();
361	try {	360	try {
362	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	361	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
363	} catch (InvalidInputException e) {	362	} catch (IllegalArgumentException e) {
364	return null;	363	return null;
365	}	364	}
366	for (FileSystem.Classpath classpath : paths) {	365	for (FileSystem.Classpath classpath : paths) {
Lines 854-861 Link Here
854	@SuppressWarnings("unchecked")	853	@SuppressWarnings("unchecked")
855	public void processPathEntries(final int defaultSize, final ArrayList paths,	854	public void processPathEntries(final int defaultSize, final ArrayList paths,
856	final String currentPath, String customEncoding, boolean isSourceOnly,	855	final String currentPath, String customEncoding, boolean isSourceOnly,
857	boolean rejectDestinationPathOnJars)	856	boolean rejectDestinationPathOnJars) {
858	throws InvalidInputException {	857
859	String currentClasspathName = null;	858	String currentClasspathName = null;
860	String currentDestinationPath = null;	859	String currentDestinationPath = null;
861	ArrayList currentRuleSpecs = new ArrayList(defaultSize);	860	ArrayList currentRuleSpecs = new ArrayList(defaultSize);
Lines 915-921 Link Here
915	state = rulesNeedAnotherRule;	914	state = rulesNeedAnotherRule;
916	break;	915	break;
917	case destinationPathReadyToClose:	916	case destinationPathReadyToClose:
918	throw new InvalidInputException(	917	throw new IllegalArgumentException(
919	this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$	918	this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
920	currentPath));	919	currentPath));
921	case bracketClosed:	920	case bracketClosed:
Lines 970-976 Link Here
970	case rulesStart:	969	case rulesStart:
971	if (token.startsWith("-d ")) { //$NON-NLS-1$	970	if (token.startsWith("-d ")) { //$NON-NLS-1$
972	if (currentDestinationPath != null) {	971	if (currentDestinationPath != null) {
973	throw new InvalidInputException(	972	throw new IllegalArgumentException(
974	this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$	973	this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$
975	currentPath));	974	currentPath));
976	}	975	}
Lines 980-986 Link Here
980	} // else we proceed with a rule	979	} // else we proceed with a rule
981	case rulesNeedAnotherRule:	980	case rulesNeedAnotherRule:
982	if (currentDestinationPath != null) {	981	if (currentDestinationPath != null) {
983	throw new InvalidInputException(	982	throw new IllegalArgumentException(
984	this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$	983	this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$
985	currentPath));	984	currentPath));
986	}	985	}
Lines 1032-1038 Link Here
1032	protected void addNewEntry(ArrayList paths, String currentClasspathName,	1031	protected void addNewEntry(ArrayList paths, String currentClasspathName,
1033	ArrayList currentRuleSpecs, String customEncoding,	1032	ArrayList currentRuleSpecs, String customEncoding,
1034	String destPath, boolean isSourceOnly,	1033	String destPath, boolean isSourceOnly,
1035	boolean rejectDestinationPathOnJars) throws InvalidInputException {	1034	boolean rejectDestinationPathOnJars) {
1036		1035
1037	int rulesSpecsSize = currentRuleSpecs.size();	1036	int rulesSpecsSize = currentRuleSpecs.size();
1038	AccessRuleSet accessRuleSet = null;	1037	AccessRuleSet accessRuleSet = null;
Lines 1085-1091 Link Here
1085	if (rejectDestinationPathOnJars && destPath != null &&	1084	if (rejectDestinationPathOnJars && destPath != null &&
1086	(currentClasspathName.endsWith(".jar") \|\| //$NON-NLS-1$	1085	(currentClasspathName.endsWith(".jar") \|\| //$NON-NLS-1$
1087	currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$	1086	currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
1088	throw new InvalidInputException(	1087	throw new IllegalArgumentException(
1089	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$	1088	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
1090	currentClasspathName));	1089	currentClasspathName));
1091	}	1090	}

Lines 38-44 Link Here

(-)src/org/eclipse/jdt/internal/compiler/apt/util/EclipseFileManager.java (-11 / +9 lines)
38	import javax.tools.JavaFileObject.Kind;	38	import javax.tools.JavaFileObject.Kind;
39		39
40	import org.eclipse.jdt.core.compiler.IProblem;	40	import org.eclipse.jdt.core.compiler.IProblem;
41	import org.eclipse.jdt.core.compiler.InvalidInputException;
42	import org.eclipse.jdt.internal.compiler.batch.FileSystem;	41	import org.eclipse.jdt.internal.compiler.batch.FileSystem;
43	import org.eclipse.jdt.internal.compiler.batch.Main;	42	import org.eclipse.jdt.internal.compiler.batch.Main;
44	import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;	43	import org.eclipse.jdt.internal.compiler.batch.Main.ResourceBundleFactory;
Lines 276-282 Link Here
276	ArrayList<File> files = new ArrayList<File>();	275	ArrayList<File> files = new ArrayList<File>();
277	try {	276	try {
278	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	277	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
279	} catch (InvalidInputException e) {	278	} catch (IllegalArgumentException e) {
280	return null;	279	return null;
281	}	280	}
282	for (FileSystem.Classpath classpath : paths) {	281	for (FileSystem.Classpath classpath : paths) {
Lines 346-352 Link Here
346	ArrayList<File> files = new ArrayList<File>();	345	ArrayList<File> files = new ArrayList<File>();
347	try {	346	try {
348	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	347	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
349	} catch (InvalidInputException e) {	348	} catch (IllegalArgumentException e) {
350	return null;	349	return null;
351	}	350	}
352	for (FileSystem.Classpath classpath : paths) {	351	for (FileSystem.Classpath classpath : paths) {
Lines 360-366 Link Here
360	ArrayList<File> files = new ArrayList<File>();	359	ArrayList<File> files = new ArrayList<File>();
361	try {	360	try {
362	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);	361	this.processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, path, this.charset.toString(), false, false);
363	} catch (InvalidInputException e) {	362	} catch (IllegalArgumentException e) {
364	return null;	363	return null;
365	}	364	}
366	for (FileSystem.Classpath classpath : paths) {	365	for (FileSystem.Classpath classpath : paths) {
Lines 872-879 Link Here
872	@SuppressWarnings("unchecked")	871	@SuppressWarnings("unchecked")
873	public void processPathEntries(final int defaultSize, final ArrayList paths,	872	public void processPathEntries(final int defaultSize, final ArrayList paths,
874	final String currentPath, String customEncoding, boolean isSourceOnly,	873	final String currentPath, String customEncoding, boolean isSourceOnly,
875	boolean rejectDestinationPathOnJars)	874	boolean rejectDestinationPathOnJars) {
876	throws InvalidInputException {
877	String currentClasspathName = null;	875	String currentClasspathName = null;
878	String currentDestinationPath = null;	876	String currentDestinationPath = null;
879	ArrayList currentRuleSpecs = new ArrayList(defaultSize);	877	ArrayList currentRuleSpecs = new ArrayList(defaultSize);
Lines 933-939 Link Here
933	state = rulesNeedAnotherRule;	931	state = rulesNeedAnotherRule;
934	break;	932	break;
935	case destinationPathReadyToClose:	933	case destinationPathReadyToClose:
936	throw new InvalidInputException(	934	throw new IllegalArgumentException(
937	this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$	935	this.bind("configure.incorrectDestinationPathEntry", //$NON-NLS-1$
938	currentPath));	936	currentPath));
939	case bracketClosed:	937	case bracketClosed:
Lines 988-994 Link Here
988	case rulesStart:	986	case rulesStart:
989	if (token.startsWith("-d ")) { //$NON-NLS-1$	987	if (token.startsWith("-d ")) { //$NON-NLS-1$
990	if (currentDestinationPath != null) {	988	if (currentDestinationPath != null) {
991	throw new InvalidInputException(	989	throw new IllegalArgumentException(
992	this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$	990	this.bind("configure.duplicateDestinationPathEntry", //$NON-NLS-1$
993	currentPath));	991	currentPath));
994	}	992	}
Lines 998-1004 Link Here
998	} // else we proceed with a rule	996	} // else we proceed with a rule
999	case rulesNeedAnotherRule:	997	case rulesNeedAnotherRule:
1000	if (currentDestinationPath != null) {	998	if (currentDestinationPath != null) {
1001	throw new InvalidInputException(	999	throw new IllegalArgumentException(
1002	this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$	1000	this.bind("configure.accessRuleAfterDestinationPath", //$NON-NLS-1$
1003	currentPath));	1001	currentPath));
1004	}	1002	}
Lines 1050-1056 Link Here
1050	protected void addNewEntry(ArrayList paths, String currentClasspathName,	1048	protected void addNewEntry(ArrayList paths, String currentClasspathName,
1051	ArrayList currentRuleSpecs, String customEncoding,	1049	ArrayList currentRuleSpecs, String customEncoding,
1052	String destPath, boolean isSourceOnly,	1050	String destPath, boolean isSourceOnly,
1053	boolean rejectDestinationPathOnJars) throws InvalidInputException {	1051	boolean rejectDestinationPathOnJars) {
1054		1052
1055	int rulesSpecsSize = currentRuleSpecs.size();	1053	int rulesSpecsSize = currentRuleSpecs.size();
1056	AccessRuleSet accessRuleSet = null;	1054	AccessRuleSet accessRuleSet = null;
Lines 1103-1109 Link Here
1103	if (rejectDestinationPathOnJars && destPath != null &&	1101	if (rejectDestinationPathOnJars && destPath != null &&
1104	(currentClasspathName.endsWith(".jar") \|\| //$NON-NLS-1$	1102	(currentClasspathName.endsWith(".jar") \|\| //$NON-NLS-1$
1105	currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$	1103	currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
1106	throw new InvalidInputException(	1104	throw new IllegalArgumentException(
1107	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$	1105	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
1108	currentClasspathName));	1106	currentClasspathName));
1109	}	1107	}

Lines 29-35 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (-4 / +4 lines)
29	import org.eclipse.jdt.core.JavaCore;	29	import org.eclipse.jdt.core.JavaCore;
30	import org.eclipse.jdt.core.compiler.CharOperation;	30	import org.eclipse.jdt.core.compiler.CharOperation;
31	import org.eclipse.jdt.core.compiler.CompilationProgress;	31	import org.eclipse.jdt.core.compiler.CompilationProgress;
32	import org.eclipse.jdt.core.compiler.InvalidInputException;
33	import org.eclipse.jdt.core.compiler.batch.BatchCompiler;	32	import org.eclipse.jdt.core.compiler.batch.BatchCompiler;
34	import org.eclipse.jdt.core.tests.util.Util;	33	import org.eclipse.jdt.core.tests.util.Util;
35	import org.eclipse.jdt.internal.compiler.batch.ClasspathJar;	34	import org.eclipse.jdt.internal.compiler.batch.ClasspathJar;
Lines 756-762 Link Here
756	try {	755	try {
757	(new Main(new PrintWriter(System.out), new PrintWriter(System.err), true/systemExit/, null/options/, null/progress/)).	756	(new Main(new PrintWriter(System.out), new PrintWriter(System.err), true/systemExit/, null/options/, null/progress/)).
758	processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, classpathInput, null /* customEncoding /, true / isSourceOnly /, false / rejectDestinationPathOnJars*/);	757	processPathEntries(Main.DEFAULT_SIZE_CLASSPATH, paths, classpathInput, null /* customEncoding /, true / isSourceOnly /, false / rejectDestinationPathOnJars*/);
759	} catch (InvalidInputException e) {	758	} catch (IllegalArgumentException e) {
760	// e.printStackTrace();	759	// e.printStackTrace();
761	if (expectedError == null) {	760	if (expectedError == null) {
762	fail("unexpected invalid input exception: " + e.getMessage());	761	fail("unexpected invalid input exception: " + e.getMessage());
Lines 2418-2424 Link Here
2418	}	2417	}
2419	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - cumulative -extdirs extends the classpath	2418	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=88364 - cumulative -extdirs extends the classpath
2420	public void test025(){	2419	public void test025(){
2421	String path = ResourcesPlugin.getWorkspace().getRoot().getLocation().toOSString();	2420	String path = org.eclipse.jdt.core.tests.compiler.regression.AbstractRegressionTest.LIB_DIR;
2422	String libPath = null;	2421	String libPath = null;
2423	if (path.endsWith(File.separator)) {	2422	if (path.endsWith(File.separator)) {
2424	libPath = path + "lib.jar";	2423	libPath = path + "lib.jar";
Lines 2437-2443 Link Here
2437	JavaCore.VERSION_1_4);	2436	JavaCore.VERSION_1_4);
2438	jarCreated = true;	2437	jarCreated = true;
2439	} catch (IOException e) {	2438	} catch (IOException e) {
2440	// ignore	2439	e.printStackTrace();
		2440	assertTrue("Should not happen", false);
2441	}	2441	}
2442	String setting= System.getProperty("jdt.compiler.useSingleThread");	2442	String setting= System.getProperty("jdt.compiler.useSingleThread");
2443	try {	2443	try {

Lines 31-37 Link Here

(-)src/org/eclipse/jdt/internal/compiler/tool/EclipseCompilerImpl.java (-5 / +2 lines)
31	import org.eclipse.jdt.core.compiler.CategorizedProblem;	31	import org.eclipse.jdt.core.compiler.CategorizedProblem;
32	import org.eclipse.jdt.core.compiler.CharOperation;	32	import org.eclipse.jdt.core.compiler.CharOperation;
33	import org.eclipse.jdt.core.compiler.CompilationProgress;	33	import org.eclipse.jdt.core.compiler.CompilationProgress;
34	import org.eclipse.jdt.core.compiler.InvalidInputException;
35	import org.eclipse.jdt.internal.compiler.ClassFile;	34	import org.eclipse.jdt.internal.compiler.ClassFile;
36	import org.eclipse.jdt.internal.compiler.CompilationResult;	35	import org.eclipse.jdt.internal.compiler.CompilationResult;
37	import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;	36	import org.eclipse.jdt.internal.compiler.IErrorHandlingPolicy;
Lines 69-83 Link Here
69	// request compilation	68	// request compilation
70	performCompilation();	69	performCompilation();
71	}	70	}
72	} catch (InvalidInputException e) {	71	} catch(IllegalArgumentException e) {
73	this.logger.logException(e);	72	this.logger.logException(e);
74	if (this.systemExitWhenFinished) {	73	if (this.systemExitWhenFinished) {
75	cleanup();	74	cleanup();
76	System.exit(-1);	75	System.exit(-1);
77	}	76	}
78	return false;	77	return false;
79	} catch(IllegalArgumentException e) {
80	throw e;
81	} catch (RuntimeException e) { // internal compiler failure	78	} catch (RuntimeException e) { // internal compiler failure
82	this.logger.logException(e);	79	this.logger.logException(e);
83	return false;	80	return false;
Lines 319-325 Link Here
319	ArrayList classpaths,	316	ArrayList classpaths,
320	ArrayList extdirsClasspaths,	317	ArrayList extdirsClasspaths,
321	ArrayList endorsedDirClasspaths,	318	ArrayList endorsedDirClasspaths,
322	String customEncoding) throws InvalidInputException {	319	String customEncoding) {
323		320
324	ArrayList<FileSystem.Classpath> fileSystemClasspaths = new ArrayList<FileSystem.Classpath>();	321	ArrayList<FileSystem.Classpath> fileSystemClasspaths = new ArrayList<FileSystem.Classpath>();
325	EclipseFileManager javaFileManager = null;	322	EclipseFileManager javaFileManager = null;