Attachment 16918 Details for Bug 74394 – Apply on HEAD

[patch] Apply on HEAD

patch_74394.txt (text/plain), 33.18 KB, created by Olivier Thomann

on 2005-01-04 13:52:00 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2005-01-04 13:52:00 EST

Size: 33.18 KB

patch

obsolete

>Index: batch/org/eclipse/jdt/internal/compiler/batch/Main.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/Main.java,v
>retrieving revision 1.170
>diff -u -r1.170 Main.java
>--- batch/org/eclipse/jdt/internal/compiler/batch/Main.java	19 Dec 2004 19:42:00 -0000	1.170
>+++ batch/org/eclipse/jdt/internal/compiler/batch/Main.java	4 Jan 2005 18:48:45 -0000
>@@ -12,6 +12,7 @@
> 
> import java.io.ByteArrayInputStream;
> import java.io.File;
>+import java.io.FileNotFoundException;
> import java.io.FileOutputStream;
> import java.io.FilenameFilter;
> import java.io.IOException;
>@@ -20,7 +21,10 @@
> import java.io.PrintWriter;
> import java.io.StringReader;
> import java.io.UnsupportedEncodingException;
>+import java.lang.reflect.Field;
>+import java.util.Collections;
> import java.util.Enumeration;
>+import java.util.HashMap;
> import java.util.Iterator;
> import java.util.Locale;
> import java.util.Map;
>@@ -51,26 +55,135 @@
> public class Main implements ProblemSeverities, SuffixConstants {
> 
> 	public static class Logger {
>-		
>-		PrintWriter out;
>-		PrintWriter err;
>-		PrintWriter log;
>-		
>+		private static final String COMMAND_LINE_ARGUMENT = "argument"; //$NON-NLS-1$
>+		private static final String COMMAND_LINE_ARGUMENT_VALUE = "value"; //$NON-NLS-1$
>+		private static final String COMMAND_LINE_ARGUMENTS = "command_line"; //$NON-NLS-1$
>+		private static final String COMPILER = "compiler"; //$NON-NLS-1$
>+		private static final String ERROR = "ERROR"; //$NON-NLS-1$
>+		private static final String ERROR_TAG = "error"; //$NON-NLS-1$
>+		private static final String MESSAGE = "message"; //$NON-NLS-1$
>+		private static final String NUMBER_OF_CLASSFILES = "number_of_classfiles"; //$NON-NLS-1$
>+		private static final String NUMBER_OF_ERRORS = "errors"; //$NON-NLS-1$
>+		private static final String NUMBER_OF_PROBLEMS = "problems"; //$NON-NLS-1$
>+		private static final String NUMBER_OF_WARNINGS = "warnings"; //$NON-NLS-1$
>+		private static final String PROBLEM_ARGUMENT = "argument"; //$NON-NLS-1$
>+		private static final String PROBLEM_ARGUMENT_VALUE = "value"; //$NON-NLS-1$
>+		private static final String PROBLEM_ARGUMENTS = "arguments"; //$NON-NLS-1$
>+		private static final String PROBLEM_ID = "id"; //$NON-NLS-1$
>+		private static final String PROBLEM_FILE = "source"; //$NON-NLS-1$
>+		private static final String PROBLEM_LINE = "line"; //$NON-NLS-1$
>+		private static final String PROBLEM_MESSAGE = "message"; //$NON-NLS-1$
>+		private static final String PROBLEM_MESSAGE_VALUE = "value"; //$NON-NLS-1$
>+		private static final String PROBLEM_SEVERITY = "severity"; //$NON-NLS-1$
>+		private static final String PROBLEM_SOURCE_START = "start"; //$NON-NLS-1$
>+		private static final String PROBLEM_SOURCE_END = "end"; //$NON-NLS-1$
>+		private static final String PROBLEM_SUMMARY = "problem_summary"; //$NON-NLS-1$
>+		private static final String PROBLEM_TAG = "problem"; //$NON-NLS-1$
>+		private static final String PROBLEMS ="problems"; //$NON-NLS-1$
>+		private static final String WARNING = "WARNING"; //$NON-NLS-1$
>+		private static final String XML_VERSION= "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"; //$NON-NLS-1$
>+
>+		private static final HashMap FIELD_TABLE = new HashMap();
>+		static {
>+			try {
>+				Class c = IProblem.class;
>+				Field[] fields = c.getFields();
>+				for (int i = 0, max = fields.length; i < max; i++) {
>+					Field field = fields[i];
>+					FIELD_TABLE.put(field.get(null), field.getName());
>+				}
>+			} catch (SecurityException e) {
>+				e.printStackTrace();
>+			} catch (IllegalArgumentException e) {
>+				e.printStackTrace();
>+			} catch (IllegalAccessException e) {
>+				e.printStackTrace();
>+			}
>+		}
>+		private static void appendEscapedChar(StringBuffer buffer, char c) {
>+			String replacement= getReplacement(c);
>+			if (replacement != null) {
>+				buffer.append('&');
>+				buffer.append(replacement);
>+				buffer.append(';');
>+			} else {
>+				buffer.append(c);
>+			}
>+		}
>+		private static String getEscaped(String s) {
>+			StringBuffer result= new StringBuffer(s.length() + 10);
>+			for (int i= 0; i < s.length(); ++i)
>+				appendEscapedChar(result, s.charAt(i));
>+			return result.toString();
>+		}
>+		private static String getReplacement(char c) {
>+			// Encode special XML characters into the equivalent character references.
>+			// These five are defined by default for all XML documents.
>+			switch (c) {
>+				case '<' :
>+					return "lt"; //$NON-NLS-1$
>+				case '>' :
>+					return "gt"; //$NON-NLS-1$
>+				case '"' :
>+					return "quot"; //$NON-NLS-1$
>+				case '\'' :
>+					return "apos"; //$NON-NLS-1$
>+				case '&' :
>+					return "amp"; //$NON-NLS-1$
>+			}
>+			return null;
>+		}
>+		private PrintWriter err;
>+		boolean isXml;
>+		private PrintWriter log;
>+		private PrintWriter out;
>+		private int tab;
>+		private String[] commandLineArguments;
>+		private HashMap parameters;
>+
> 		public Logger(PrintWriter out, PrintWriter err) {
> 			this.out = out;
> 			this.err = err;
>+			this.isXml = false;
>+			this.parameters = new HashMap();
> 		}
>-		
>-		public void setLog(PrintWriter log) {
>-			this.log = log;
>-		}
>-		
>+
> 		public void close() {
> 			if (this.log != null) {
>+				if (this.isXml) {
>+					this.endTag(COMPILER);
>+					this.flush();
>+				}
> 				this.log.close();
> 			}
> 		}
>+
>+		/**
>+		 * 
>+		 */
>+		public void compiling() {
>+			this.printlnOut(Main.bind("progress.compiling")); //$NON-NLS-1$
>+		}
>+		
>+		/**
>+		 * Used to stop logging problems
>+		 */
>+		private void endLoggingProblems() {
>+			if (this.isXml) {
>+				this.endTag(PROBLEMS);
>+			}
>+		}
>+
>+		public void endTag(String name) {
>+			tab--;
>+			this.printTag('/' + name, null, true, false);
>+			this.tab--;
>+		}
> 		
>+		private String getFieldName(int id) {
>+			return (String) FIELD_TABLE.get(new Integer(id));
>+		}
>+
> 		public void flush() {
> 			this.out.flush();
> 			this.err.flush();
>@@ -78,32 +191,384 @@
> 				this.log.flush();
> 			}
> 		}
>-		
>-		public void printErr(String s) {
>+
>+		public void logCommandLineArguments() {
>+			final int length = this.commandLineArguments != null ? this.commandLineArguments.length : 0;
>+			if (length != 0) {
>+				if (this.isXml) {
>+					// generate xml output
>+					this.printTag(COMMAND_LINE_ARGUMENTS, null, true, false);
>+					parameters.clear();
>+					for (int i = 0; i < length; i++) {
>+						parameters.put(COMMAND_LINE_ARGUMENT_VALUE, this.commandLineArguments[i]);
>+						this.printTag(COMMAND_LINE_ARGUMENT, parameters, true, true);
>+					}
>+					this.endTag(COMMAND_LINE_ARGUMENTS);
>+				}
>+			}
>+		}
>+
>+		/**
>+		 * @param message
>+		 */
>+		public void logExceptionMessage(String message) {
>+			if (isXml) {
>+				parameters.clear();
>+				parameters.put(MESSAGE, message);
>+				this.printTag(ERROR_TAG, parameters, true, true);
>+			}
>+			this.printlnErr(message);
>+		}
>+
>+		/**
>+		 * @param wrongClasspath
>+		 *            the given wrong classpath entry
>+		 */
>+		public void logIncorrectClasspath(String wrongClasspath) {
>+			if (isXml) {
>+				parameters.clear();
>+				parameters.put(MESSAGE, wrongClasspath);
>+				this.printTag(ERROR_TAG, parameters, true, true);
>+			}
>+			this.printlnErr(Main.bind(
>+				"configure.incorrectClasspath", wrongClasspath)); //$NON-NLS-1$
>+		}
>+
>+		/**
>+		 * 
>+		 */
>+		public void logNoClassFileCreated(String fileName) {
>+			if (isXml) {
>+				parameters.clear();
>+				parameters.put(MESSAGE, Main.bind("output.noClassFileCreated", fileName)); //$NON-NLS-1$
>+				this.printTag(ERROR_TAG, null, true, true);
>+			}
>+			this.printlnErr(Main.bind("output.noClassFileCreated", fileName)); //$NON-NLS-1$
>+		}
>+
>+		public void logNoClasspath() {
>+			if (isXml) {
>+				parameters.clear();
>+				parameters.put(MESSAGE, Main.bind("configure.noClasspath")); //$NON-NLS-1$//$NON-NLS-2$
>+				this.printTag(ERROR_TAG, parameters, true, true);
>+			}
>+			this.printlnErr(Main.bind("configure.noClasspath")); //$NON-NLS-1$
>+		}
>+
>+		/**
>+		 * @param exportedClassFilesCounter
>+		 */
>+		public void logNumberOfClassFilesGenerated(int exportedClassFilesCounter) {
>+			if (isXml) {
>+				parameters.clear();
>+				if (exportedClassFilesCounter == 1) {
>+					parameters.put(MESSAGE, Main.bind("compile.oneClassFileGenerated")); //$NON-NLS-1$
>+				} else {
>+					parameters.put(MESSAGE, Main.bind("compile.severalClassFilesGenerated", //$NON-NLS-1$
>+						String.valueOf(exportedClassFilesCounter)));
>+				}
>+				this.printTag(NUMBER_OF_CLASSFILES, parameters, true, true);
>+			}
>+			if (exportedClassFilesCounter == 1) {
>+				this.printlnOut(Main.bind("compile.oneClassFileGenerated")); //$NON-NLS-1$
>+			} else {
>+				this.printlnOut(Main.bind("compile.severalClassFilesGenerated", //$NON-NLS-1$
>+					String.valueOf(exportedClassFilesCounter)));
>+			}
>+		}
>+
>+		public int logProblems(IProblem[] problems, char[] unitSource, Main currentMain) {
>+			final int count = problems.length;
>+			int localErrorCount = 0;
>+			if (count != 0) {
>+				this.startLoggingProblems();
>+				for (int i = 0; i < count; i++) {
>+					if (problems[i] != null) {
>+						currentMain.globalProblemsCount++;
>+						this.logProblem(problems[i], localErrorCount, currentMain.globalProblemsCount, unitSource);
>+						if (problems[i].isError()) {
>+							currentMain.globalErrorsCount++;
>+							localErrorCount++;
>+						} else {
>+							currentMain.globalWarningsCount++;
>+						}
>+					}
>+				}
>+				this.endLoggingProblems();
>+			}
>+			return localErrorCount;
>+		}
>+		/**
>+		 * @param problem
>+		 *            the given problem to log
>+		 * @param localErrorCount
>+		 *            the given local error count
>+		 * @param globalErrorCount
>+		 *            the given global error count
>+		 * @param unitSource
>+		 *            the given unit source
>+		 */
>+		private void logProblem(IProblem problem, int localErrorCount,
>+			int globalErrorCount, char[] unitSource) {
>+			if (this.isXml) {
>+				// generate the xml output
>+				parameters.clear();
>+				parameters.put(PROBLEM_ID, getFieldName(problem.getID()));
>+				parameters.put(PROBLEM_FILE, new String(problem.getOriginatingFileName()));
>+				parameters.put(PROBLEM_SEVERITY, problem.isError() ? ERROR : WARNING);
>+				parameters.put(PROBLEM_LINE, new Integer(problem.getSourceLineNumber()));
>+				parameters.put(PROBLEM_SOURCE_START, new Integer(problem.getSourceStart()));
>+				parameters.put(PROBLEM_SOURCE_END, new Integer(problem.getSourceEnd()));
>+				this.printTag(PROBLEM_TAG, parameters, true, false);
>+				parameters.clear();
>+				parameters.put(PROBLEM_MESSAGE_VALUE, problem.getMessage());
>+				this.printTag(PROBLEM_MESSAGE, parameters, true, true);
>+				String[] arguments = problem.getArguments();
>+				final int length = arguments.length;
>+				if (length != 0) {
>+					this.printTag(PROBLEM_ARGUMENTS, null, true, false);
>+					parameters.clear();
>+					for (int i = 0; i < length; i++) {
>+						parameters.put(PROBLEM_ARGUMENT_VALUE, arguments[i]);
>+						this.printTag(PROBLEM_ARGUMENT, parameters, true, true);
>+					}
>+					this.endTag(PROBLEM_ARGUMENTS);
>+				}
>+				this.endTag(PROBLEM_TAG);
>+			}
>+			if (localErrorCount == 0) {
>+				this.printlnErr("----------"); //$NON-NLS-1$
>+			}
>+			this.printlnErr(problem.isError() ?
>+				Main.bind(
>+					"requestor.error", //$NON-NLS-1$
>+					Integer.toString(globalErrorCount),
>+					new String(problem.getOriginatingFileName()))
>+				: Main.bind(
>+					"requestor.warning", //$NON-NLS-1$
>+					Integer.toString(globalErrorCount),
>+					new String(problem.getOriginatingFileName())));
>+			try {
>+				this.printlnErr(((DefaultProblem) problem).errorReportSource(unitSource));
>+				this.printlnErr(problem.getMessage());
>+			} catch (Exception e) {
>+				this.printlnErr(Main.bind(
>+					"requestor.notRetrieveErrorMessage", problem.toString())); //$NON-NLS-1$
>+			}
>+			this.printlnErr("----------"); //$NON-NLS-1$
>+		}
>+
>+		/**
>+		 * @param globalProblemsCount
>+		 * @param globalErrorsCount
>+		 * @param globalWarningsCount
>+		 */
>+		public void logProblemsSummary(int globalProblemsCount,
>+			int globalErrorsCount, int globalWarningsCount) {
>+			if (this.isXml) {
>+				// generate xml
>+				parameters.clear();
>+				parameters.put(NUMBER_OF_PROBLEMS, new Integer(globalProblemsCount));
>+				parameters.put(NUMBER_OF_ERRORS, new Integer(globalErrorsCount));
>+				parameters.put(NUMBER_OF_WARNINGS, new Integer(globalWarningsCount));
>+				this.printTag(PROBLEM_SUMMARY, parameters, true, true);
>+			}
>+			if (globalProblemsCount == 1) {
>+				this.printErr(Main.bind("compile.oneProblem")); //$NON-NLS-1$
>+			} else {
>+				String errorMessage = null;
>+				String warningMessage = null;
>+				if (globalErrorsCount > 0) {
>+					if (globalErrorsCount == 1) {
>+						errorMessage = Main.bind("compile.oneError"); //$NON-NLS-1$
>+					} else {
>+						errorMessage = Main.bind("compile.severalErrors", String.valueOf(globalErrorsCount)); //$NON-NLS-1$
>+					}
>+				}
>+				if (globalWarningsCount > 0) {
>+					if (globalWarningsCount == 1) {
>+						warningMessage = Main.bind("compile.oneWarning"); //$NON-NLS-1$
>+					} else {
>+						warningMessage = Main.bind("compile.severalWarnings", String.valueOf(globalWarningsCount)); //$NON-NLS-1$
>+					}
>+				}
>+				if (errorMessage == null || warningMessage == null) {
>+					if (errorMessage == null) {
>+						this.printErr(Main.bind(
>+							"compile.severalProblemsErrorsOrWarnings", //$NON-NLS-1$
>+							String.valueOf(globalProblemsCount),
>+							warningMessage));
>+					} else {
>+						this.printErr(Main.bind(
>+							"compile.severalProblemsErrorsOrWarnings", //$NON-NLS-1$
>+							String.valueOf(globalProblemsCount),
>+							errorMessage));
>+					}
>+				} else {
>+					this.printErr(Main.bind(
>+						"compile.severalProblemsErrorsOrWarnings", //$NON-NLS-1$
>+						new String[] {
>+							String.valueOf(globalProblemsCount),
>+							errorMessage,
>+							warningMessage
>+						}));
>+				}
>+			}
>+		}
>+
>+		/**
>+		 * 
>+		 */
>+		public void logProgress() {
>+			this.printOut('.');
>+		}
>+
>+		/**
>+		 * @param i
>+		 *            the current repetition number
>+		 * @param repetitions
>+		 *            the given number of repetitions
>+		 */
>+		public void logRepetition(int i, int repetitions) {
>+			this.printlnOut(Main.bind("compile.repetition", //$NON-NLS-1$
>+				String.valueOf(i + 1), String.valueOf(repetitions)));
>+		}
>+
>+		/**
>+		 * @param time
>+		 * @param lineCount
>+		 */
>+		public void logTiming(long time, long lineCount) {
>+			if (lineCount != 0) {
>+				this.printlnOut(Main.bind(
>+					"compile.instantTime", //$NON-NLS-1$
>+					new String[] {
>+						String.valueOf(lineCount),
>+						String.valueOf(time),
>+						String.valueOf(((int) (lineCount * 10000.0 / time)) / 10.0) }));
>+			} else {
>+				this.printlnOut(Main.bind("compile.totalTime", String.valueOf(time))); //$NON-NLS-1$
>+			}
>+		}
>+
>+		/**
>+		 * @param usage
>+		 */
>+		public void logUsage(String usage) {
>+			this.printlnOut(usage); //$NON-NLS-1$//$NON-NLS-2$
>+		}
>+
>+		/**
>+		 * 
>+		 */
>+		public void logVersion() {
>+			this.printlnOut(Main.bind("misc.version")); //$NON-NLS-1$
>+		}
>+
>+		/**
>+		 * 
>+		 */
>+		public void logWrongJDK() {
>+			if (isXml) {
>+				parameters.clear();
>+				parameters.put(MESSAGE, Main.bind("configure.requiresJDK1.2orAbove")); //$NON-NLS-1$//$NON-NLS-2$
>+				this.printTag(ERROR, parameters, true, true);				
>+			}
>+			this.printlnErr(Main.bind("configure.requiresJDK1.2orAbove")); //$NON-NLS-1$
>+		}
>+
>+		private void printErr(String s) {
> 			this.err.print(s);
>-			if (this.log != null) {
>-				this.log.print(s);
>+			if (!this.isXml) {
>+				if (this.log != null) {
>+					this.log.print(s);
>+				}
> 			}
> 		}
>-		
>-		public void printlnErr(String s) {
>+
>+		private void printlnErr(String s) {
> 			this.err.println(s);
>-			if (this.log != null) {
>-				this.log.println(s);
>+			if (!this.isXml) {
>+				if (this.log != null) {
>+					this.log.println(s);
>+				}
> 			}
> 		}
>-		
>-		public void printlnOut(String s) {
>+
>+		private void printlnOut(String s) {
> 			this.out.println(s);
> 		}
>-		
>-		public void printlnOut() {
>+
>+		/**
>+		 * 
>+		 */
>+		public void printNewLine() {
> 			this.out.println();
> 		}
>-		
>-		public void printOut(char c) {
>+
>+		private void printOut(char c) {
> 			this.out.print(c);
> 		}
>+		public void printTag(String name, HashMap params, boolean insertNewLine, boolean closeTag) {
>+			for (int i= this.tab; i > 0; i--) this.log.print('\t');
>+			StringBuffer buffer= new StringBuffer();
>+			buffer.append("<"); //$NON-NLS-1$
>+			buffer.append(name);
>+			if (params != null) {
>+				for (Enumeration enumeration = Collections.enumeration(params.keySet()); enumeration.hasMoreElements();) {
>+					buffer.append(" "); //$NON-NLS-1$
>+					String key= (String) enumeration.nextElement();
>+					buffer.append(key);
>+					buffer.append("=\""); //$NON-NLS-1$
>+					buffer.append(getEscaped(String.valueOf(params.get(key))));
>+					buffer.append("\""); //$NON-NLS-1$
>+				}
>+			}
>+			if (closeTag) {
>+				buffer.append("/>"); //$NON-NLS-1$
>+			} else {
>+				buffer.append(">"); //$NON-NLS-1$
>+				this.tab++;
>+			}
>+			if (insertNewLine) {
>+				this.log.println(String.valueOf(buffer));
>+			} else {
>+				this.log.print(String.valueOf(buffer));
>+			}
>+		}
>+
>+		public void setCommandLine(String[] args) {
>+			this.commandLineArguments = args;
>+		}
>+
>+		public void setLog(String logFileName) throws InvalidInputException {
>+			try {
>+				this.log = new PrintWriter(new FileOutputStream(logFileName, false));
>+				int index = logFileName.lastIndexOf('.');
>+				if (index != 0) {
>+					if (logFileName.substring(index).toLowerCase().equals(".xml")) { //$NON-NLS-1$
>+						this.isXml = true;
>+						this.log.println(XML_VERSION);
>+						this.tab = 0;
>+						parameters.clear();
>+						parameters.put("name", Main.bind("compiler.name")); //$NON-NLS-1$//$NON-NLS-2$
>+						parameters.put("version", Main.bind("compiler.version")); //$NON-NLS-1$//$NON-NLS-2$
>+						this.printTag(COMPILER, parameters, true, false);
>+					}
>+				}
>+			} catch (FileNotFoundException e) {
>+				throw new InvalidInputException(Main.bind("configure.cannotOpenLog")); //$NON-NLS-1$
>+			}
>+		}
>+
>+		/**
>+		 * Used to start logging problems
>+		 */
>+		private void startLoggingProblems() {
>+			if (this.isXml) {
>+				this.printTag(PROBLEMS, null, true, false);
>+			}
>+		}
> 	}
> 	static {
> 		relocalize();
>@@ -354,8 +819,7 @@
> //				if (this.verbose) {
> //					System.out.println(new CompilerOptions(this.options));
> //				}
>-				if (this.showProgress)
>-					this.logger.printlnOut(Main.bind("progress.compiling")); //$NON-NLS-1$
>+				if (this.showProgress) this.logger.compiling(); //$NON-NLS-1$
> 				for (int i = 0; i < this.repetitions; i++) {
> 					this.globalProblemsCount = 0;
> 					this.globalErrorsCount = 0;
>@@ -365,25 +829,27 @@
> 
> 					if (this.repetitions > 1) {
> 						this.logger.flush();
>-						this.logger.printlnOut(
>-							Main.bind(
>-								"compile.repetition", //$NON-NLS-1$
>-								String.valueOf(i + 1),
>-								String.valueOf(this.repetitions)));
>+						this.logger.logRepetition(i, this.repetitions);
> 					} 
> 					// request compilation
> 					performCompilation();
> 				}
>-				if (this.showProgress)
>-					this.logger.printlnOut();
>+				if (this.showProgress) this.logger.printNewLine();
> 			}
> 			if (this.systemExitWhenFinished) {
>+				if (this.globalErrorsCount > 0) {
>+					this.logger.logCommandLineArguments();
>+				}
> 				this.logger.flush();
>+    			this.logger.close();
> 				System.exit(this.globalErrorsCount > 0 ? -1 : 0);
> 			}
> 		} catch (InvalidInputException e) {
>-			this.logger.printlnErr(e.getMessage());
>+			this.logger.logExceptionMessage(e.getMessage());
> 			if (this.systemExitWhenFinished) {
>+				if (this.globalErrorsCount > 0) {
>+					this.logger.logCommandLineArguments();
>+				}
>     			this.logger.flush();
>     			this.logger.close();
> 				System.exit(-1);
>@@ -391,6 +857,9 @@
> 			return false;
> 		} catch (RuntimeException e) { // internal compiler failure
> 			if (this.systemExitWhenFinished) {
>+				if (this.globalErrorsCount > 0) {
>+					this.logger.logCommandLineArguments();
>+				}
> 				this.logger.flush();
> 				this.logger.close();
> 				System.exit(-1);
>@@ -398,6 +867,9 @@
> 			return false;
> 			//e.printStackTrace();
> 		} finally {
>+			if (this.globalErrorsCount > 0) {
>+				this.logger.logCommandLineArguments();
>+			}
> 			this.logger.flush();
> 			this.logger.close();
> 		}
>@@ -493,6 +965,7 @@
> 				newCommandLineArgs[i] = newCommandLineArgs[i].trim();
> 			}
> 		}
>+		this.logger.setCommandLine(newCommandLineArgs);
> 		argCount = newCommandLineArgs.length;
> 		while (++index < argCount) {
> 
>@@ -1236,7 +1709,7 @@
> 			// no user classpath specified.
> 			String classProp = System.getProperty("java.class.path"); //$NON-NLS-1$
> 			if ((classProp == null) || (classProp.length() == 0)) {
>-				this.logger.printlnErr(Main.bind("configure.noClasspath")); //$NON-NLS-1$
>+				this.logger.logNoClasspath(); //$NON-NLS-1$
> 				classProp = System.getProperty("user.dir"); //$NON-NLS-1$
> 			}
> 			StringTokenizer tokenizer = new StringTokenizer(classProp, File.pathSeparator);
>@@ -1254,7 +1727,7 @@
> 			 */
> 			 String javaversion = System.getProperty("java.version");//$NON-NLS-1$
> 			 if (javaversion != null && javaversion.equalsIgnoreCase("1.1.8")) { //$NON-NLS-1$
>-				this.logger.printlnErr(Main.bind("configure.requiresJDK1.2orAbove")); //$NON-NLS-1$
>+				this.logger.logWrongJDK(); //$NON-NLS-1$
> 				this.proceed = false;
> 				return;
> 			 }
>@@ -1291,11 +1764,7 @@
> 		}
> 
> 		if (this.log != null) {
>-			try {
>-				this.logger.setLog(new PrintWriter(new FileOutputStream(this.log, false)));
>-			} catch (IOException e) {
>-				throw new InvalidInputException(Main.bind("configure.cannotOpenLog")); //$NON-NLS-1$
>-			}
>+			this.logger.setLog(this.log);
> 		} else {
> 			this.showProgress = false;
> 		}
>@@ -1331,7 +1800,7 @@
> 		for (int i = 0, max = this.classpaths.length; i < max; i++) {
> 			File file = new File(this.classpaths[i]);
> 			if (!file.exists()) { // signal missing classpath entry file
>-				this.logger.printlnErr(Main.bind("configure.incorrectClasspath", this.classpaths[i])); //$NON-NLS-1$
>+				this.logger.logIncorrectClasspath(this.classpaths[i]); //$NON-NLS-1$
> 			}
> 		}
> 		if (this.destinationPath == null) {
>@@ -1343,24 +1812,24 @@
> 		if (didSpecifyCompliance) {
> 			Object version = this.options.get(CompilerOptions.OPTION_Compliance);
> 			if (CompilerOptions.VERSION_1_3.equals(version)) {
>-					if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_3);
>-					if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_1);
>+				if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_3);
>+				if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_1);
> 			} else if (CompilerOptions.VERSION_1_4.equals(version)) {
>-					if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_3);
>-					if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_2);
>+				if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_3);
>+				if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_2);
> 			} else if (CompilerOptions.VERSION_1_5.equals(version)) {
>-					if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_5);
>-					if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_5);
>+				if (!didSpecifySource) this.options.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_5);
>+				if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_5);
> 			}
> 		}
> 		if (didSpecifySource) {
> 			Object version = this.options.get(CompilerOptions.OPTION_Source);
> 			 if (CompilerOptions.VERSION_1_4.equals(version)) {
>-					if (!didSpecifyCompliance) this.options.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_4);
>-					if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_4);
>+				if (!didSpecifyCompliance) this.options.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_4);
>+				if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_4);
> 			} else if (CompilerOptions.VERSION_1_5.equals(version)) {
>-					if (!didSpecifyCompliance) this.options.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_5);
>-					if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_5);
>+				if (!didSpecifyCompliance) this.options.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_5);
>+				if (!didSpecifyTarget) this.options.put(CompilerOptions.OPTION_TargetPlatform, CompilerOptions.VERSION_1_5);
> 			}
> 		}
> 
>@@ -1378,7 +1847,7 @@
> 	   		}
> 			// target cannot be greater than compliance level
> 			if (CompilerOptions.versionToJdkLevel(this.options.get(CompilerOptions.OPTION_Compliance)) < CompilerOptions.versionToJdkLevel(this.options.get(CompilerOptions.OPTION_TargetPlatform))){ 
>-					throw new InvalidInputException(Main.bind("configure.incompatibleComplianceForTarget", (String)this.options.get(CompilerOptions.OPTION_Compliance), (String)this.options.get(CompilerOptions.OPTION_TargetPlatform))); //$NON-NLS-1$
>+				throw new InvalidInputException(Main.bind("configure.incompatibleComplianceForTarget", (String)this.options.get(CompilerOptions.OPTION_Compliance), (String)this.options.get(CompilerOptions.OPTION_TargetPlatform))); //$NON-NLS-1$
> 			}
> 		}
> 
>@@ -1456,49 +1925,14 @@
> 					int unitLineCount = compilationResult.lineSeparatorPositions.length;
> 					Main.this.lineCount += unitLineCount;
> 					this.lineDelta += unitLineCount;
>-					if (Main.this.showProgress
>-						&& this.lineDelta > 2000) { // in -log mode, dump a dot every 2000 lines compiled
>-						Main.this.logger.printOut('.');
>+					if (Main.this.showProgress && this.lineDelta > 2000) {
>+						// in -log mode, dump a dot every 2000 lines compiled
>+						Main.this.logger.logProgress();
> 						this.lineDelta = 0;
> 					}
> 				}
> 				if (compilationResult.hasProblems() || compilationResult.hasTasks()) {
>-					IProblem[] problems = compilationResult.getAllProblems();
>-					int count = problems.length;
>-					int localErrorCount = 0;
>-					char[] unitSource = compilationResult.compilationUnit.getContents();
>-					for (int i = 0; i < count; i++) {
>-						if (problems[i] != null) {
>-							Main.this.globalProblemsCount++;
>-							if (localErrorCount == 0)
>-								Main.this.logger.printlnErr("----------"); //$NON-NLS-1$
>-							Main.this.logger.printErr(
>-								Main.this.globalProblemsCount
>-									+ ". "  //$NON-NLS-1$
>-									+ (problems[i].isError()
>-										? Main.bind("requestor.error")  //$NON-NLS-1$
>-										: Main.bind("requestor.warning")));  //$NON-NLS-1$
>-							if (problems[i].isError()) {
>-								Main.this.globalErrorsCount++;
>-							} else {
>-								Main.this.globalWarningsCount++;
>-							}
>-							Main.this.logger.printErr(" "); //$NON-NLS-1$
>-							Main.this.logger.printErr(
>-								Main.bind("requestor.in", new String(problems[i].getOriginatingFileName()))); //$NON-NLS-1$
>-							try {
>-								Main.this.logger.printlnErr(
>-									((DefaultProblem) problems[i]).errorReportSource(unitSource));
>-								Main.this.logger.printlnErr(problems[i].getMessage());
>-							} catch (Exception e) {
>-								Main.this.logger.printlnErr(
>-									Main.bind("requestor.notRetrieveErrorMessage", problems[i].toString())); //$NON-NLS-1$
>-							}
>-							Main.this.logger.printlnErr("----------"); //$NON-NLS-1$
>-							if (problems[i].isError())
>-								localErrorCount++;
>-						}
>-					}
>+					int localErrorCount = Main.this.logger.logProblems(compilationResult.getAllProblems(), compilationResult.compilationUnit.getContents(), Main.this);
> 					// exit?
> 					if (Main.this.systemExitWhenFinished && !Main.this.proceedOnError && (localErrorCount > 0)) {
> 						Main.this.printStats();
>@@ -1631,7 +2065,7 @@
> 					} catch (IOException e) {
> 						String fileName = this.destinationPath + new String(relativeName);
> 						e.printStackTrace();
>-						this.logger.printlnErr(Main.bind("output.noClassFileCreated", fileName));  //$NON-NLS-1$
>+						this.logger.logNoClassFileCreated(fileName);  //$NON-NLS-1$
> 					}
> 					this.exportedClassFilesCounter++;
> 				}
>@@ -1659,7 +2093,7 @@
> 					} catch (IOException e) {
> 						String fileName = this.destinationPath + new String(relativeName);
> 						e.printStackTrace();
>-						this.logger.printlnErr(Main.bind("output.noClassFileCreated", fileName)); //$NON-NLS-1$
>+						this.logger.logNoClassFileCreated(fileName); //$NON-NLS-1$
> 					}
> 					this.exportedClassFilesCounter++;
> 				}
>@@ -1696,67 +2130,23 @@
> 	
> 	public void printStats() {
> 		if (this.timing) {
>-
> 			long time = System.currentTimeMillis() - this.startTime;
>-			if (this.lineCount != 0) {
>-				this.logger.printlnOut(
>-					Main.bind(
>-						"compile.instantTime", 	//$NON-NLS-1$
>-						new String[] {
>-							String.valueOf(this.lineCount),
>-							String.valueOf(time),
>-							String.valueOf(((int)(this.lineCount * 10000.0 / time)) / 10.0)}));
>-			} else {
>-				this.logger.printlnOut(Main.bind("compile.totalTime", String.valueOf(time))); //$NON-NLS-1$
>-			}
>+			this.logger.logTiming(time, this.lineCount);
> 		}
> 		if (this.globalProblemsCount > 0) {
>-			if (this.globalProblemsCount == 1) {
>-				this.logger.printErr(Main.bind("compile.oneProblem")); //$NON-NLS-1$
>-			} else {
>-				this.logger.printErr(
>-					Main.bind("compile.severalProblems", String.valueOf(this.globalProblemsCount))); 	//$NON-NLS-1$
>-			}
>-			this.logger.printErr(" ("); //$NON-NLS-1$
>-			if (this.globalErrorsCount > 0) {
>-				if (this.globalErrorsCount == 1) {
>-					this.logger.printErr(Main.bind("compile.oneError")); //$NON-NLS-1$
>-				} else {
>-					this.logger.printErr(
>-						Main.bind("compile.severalErrors", String.valueOf(this.globalErrorsCount))); 	//$NON-NLS-1$
>-				}
>-			}
>-			if (this.globalWarningsCount > 0) {
>-				if (this.globalErrorsCount > 0) {
>-					this.logger.printErr(", "); //$NON-NLS-1$
>-				}
>-				if (this.globalWarningsCount == 1) {
>-					this.logger.printErr(Main.bind("compile.oneWarning")); //$NON-NLS-1$
>-				} else {
>-					this.logger.printErr(
>-						Main.bind("compile.severalWarnings", String.valueOf(this.globalWarningsCount))); 	//$NON-NLS-1$
>-				}
>-			}
>-			this.logger.printlnErr(")"); //$NON-NLS-1$
>+			this.logger.logProblemsSummary(this.globalProblemsCount, this.globalErrorsCount, this.globalWarningsCount);
> 		}
> 		if (this.exportedClassFilesCounter != 0
>-			&& (this.showProgress || this.timing || this.verbose)) {
>-			if (this.exportedClassFilesCounter == 1) {
>-				this.logger.printlnOut(Main.bind("compile.oneClassFileGenerated")); //$NON-NLS-1$
>-			} else {
>-				this.logger.printlnOut(
>-					Main.bind(
>-						"compile.severalClassFilesGenerated", //$NON-NLS-1$
>-						String.valueOf(this.exportedClassFilesCounter)));
>-			}
>+				&& (this.showProgress || this.timing || this.verbose)) {
>+			this.logger.logNumberOfClassFilesGenerated(this.exportedClassFilesCounter);
> 		}
> 	}
> 	public void printUsage() {
>-		this.logger.printlnOut(Main.bind("misc.usage", System.getProperty("path.separator"))); //$NON-NLS-1$//$NON-NLS-2$
>+		this.logger.logUsage(Main.bind("misc.usage", System.getProperty("path.separator"))); //$NON-NLS-1$//$NON-NLS-2$
> 		this.logger.flush();
> 	}
> 	public void printVersion() {
>-		this.logger.printlnOut(Main.bind("misc.version"));  //$NON-NLS-1$
>+		this.logger.logVersion();  //$NON-NLS-1$
> 		this.logger.flush();
> 	}
> }
>Index: batch/org/eclipse/jdt/internal/compiler/batch/messages.properties
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.core/batch/org/eclipse/jdt/internal/compiler/batch/messages.properties,v
>retrieving revision 1.376
>diff -u -r1.376 messages.properties
>--- batch/org/eclipse/jdt/internal/compiler/batch/messages.properties	4 Jan 2005 15:29:21 -0000	1.376
>+++ batch/org/eclipse/jdt/internal/compiler/batch/messages.properties	4 Jan 2005 18:48:45 -0000
>@@ -27,8 +27,9 @@
> compile.repetition = [repetition {0}/{1}]
> compile.instantTime = [compiled {0} lines in {1} ms: {2} lines/s]
> compile.totalTime = [total compilation time: {0}]
>-compile.oneProblem = 1 problem
>-compile.severalProblems = {0} problems
>+compile.oneProblem = 1 problem ({0})
>+compile.severalProblemsErrorsOrWarnings = {0} problems ({1})
>+compile.severalProblemsErrorsAndWarnings = {0} problems ({1}, {2})
> compile.oneError = 1 error
> compile.severalErrors = {0} errors
> compile.oneWarning = 1 warning
>@@ -69,9 +70,8 @@
> configure.invalidTaskTag ={0} is an invalid task tag
> 
> ### requestor
>-requestor.error = ERROR
>-requestor.warning = WARNING
>-requestor.in = in {0}
>+requestor.error = {0}. ERROR in {1}
>+requestor.warning = {0}. WARNING in {1}
> requestor.notRetrieveErrorMessage = Cannot retrieve the error message for {0}
> 
> ### unit

Actions: View | Diff

Attachments on bug 74394: 16918 | 16996 | 16997 | 17043 | 17044 | 17046 | 17047 | 17048 | 17056 | 17057 | 17405