### JavaBatchCompiler messages.

### compiler version id
compiler.version = 0.276_R2_0_2
### scanning
scanning.start = Collecting source files inside {0}

### progress
progress.compiling = Compiling

### compile
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.oneError = 1 error
compile.severalErrors = {0} errors
compile.oneWarning = 1 warning
compile.severalWarnings = {0} warnings
compile.oneClassFileGenerated = 1 .class file generated
compile.severalClassFilesGenerated = {0} .class files generated

### configure
configure.noSourceFile = no source file specified
configure.duplicateLog = duplicate log specification: {0}
configure.duplicateRepeat = duplicate repeat specification: {0}
configure.duplicateCompliance = duplicate compliance setting specification: {0}
configure.source = invalid source option, source is either ''1.3'' or ''1.4'': {0}
configure.jck = invalid jck option, jck compliance level is either ''1.3'' or ''1.4'': {0}
configure.duplicateOutputPath = duplicate output path specification: {0}
configure.duplicateClasspath = duplicate classpath specification: {0}
configure.invalidDebugOption = invalid debug option: {0}
configure.duplicateWarningConfiguration = duplicate usage of warning configuration
configure.invalidWarningConfiguration = invalid warning configuration: {0}
configure.invalidWarning = invalid warning: {0}
configure.invalidWarningOption = invalid warning option: {0}
configure.targetJDK = target JDK should be comprised in between ''1.1'' and ''1.4'': {0}
configure.incompatibleTargetForSource14 = ''1.4'' source mode requires ''-target 1.4'' : {0}
configure.incompatibleComplianceForSource14 = ''1.4'' source mode requires ''-1.4'' compliance mode: {0}
configure.incompatibleComplianceForTarget14 = ''1.4'' target mode requires ''-1.4'' compliance mode: {0}
configure.repetition = repetition must be a positive integer: {0}
configure.directoryNotExist = directory does not exist: {0}
configure.IOError = i/o error : unable to retrieve .JAVA files in directory: {0}
configure.version = Eclipse Java Compiler {0}, Copyright IBM Corp 2000-2002. All rights reserved.
configure.noClasspath = no classpath defined, using default directory instead
configure.incorrectClasspath = incorrect classpath: {0}
configure.noSource = no source file specified
configure.cannotOpenLog = cannot open .log file
configure.unexpectedCustomEncoding = unexpected custom encoding specification: {0}[{1}]
configure.unsupportedEncoding = unsupported encoding format: {0}
configure.duplicateDefaultEncoding = duplicate default encoding format specification: {0}

### requestor
requestor.error = ERROR
requestor.warning = WARNING
requestor.in = in {0}
requestor.notRetrieveErrorMessage = Cannot retrieve the error message for {0}

### unit
unit.more = File {0} is specified more than once
unit.missing = File {0} is missing

### output
output.noClassFileCreated = No .class file created for file named {0} because of an IOException.

### miscellaneous
misc.usage = Eclipse Java Compiler {0}\n\
		Copyright IBM Corp 2000-2002. All rights reserved.\n\n\
		Usage: <options> <source files | directories>\n\n\
		where options include:\n\
		-help			display this help message\n\
		-version		compiler version number\n\
		-classpath		<dir 1>;<dir 2>;...;<dir P>\n\
		-d <dir>		destination directory (if omitted no package directory structure is created)\n\
		   \t-d none			no classfile is generated\n\
		-target <ver>		classfile target setting (1.1 or 1.2, default is 1.1)\n\
		-1.3 			set compliance level to 1.3 (default)\n\
		-1.4 			set compliance level to 1.4\n\
		-source <ver>		assertions toggle (1.3 or 1.4, default is 1.3 in -1.3 mode and 1.4 in -1.4 mode)\n\
		-nowarn			no warning (equivalent to ''-warn:none'')\n\
		-warn: <level>		set warning level (e.g. ''-warn:unusedLocals,deprecation'')\n\
		\tconstructorName		warn method with constructor name\n\
		\tpackageDefaultMethod	warn attempt to override package-default method\n\
		\tdeprecation		warn usage of deprecated type or member\n\
		\tmaskedCatchBlocks	warn hidden catch block\n\
		\tunusedLocals		warn on unused local variable (never read)\n\
		\tunusedArguments		warn on unused method argument (never read)\n\
		\tunusedImports		warn on unused imports\n\
		\tsyntheticAccess		warn when performing synthetic access for innerclass\n\
		\tassertIdentifier	warn occurrence of ''assert'' used as identifier\n\
		-deprecation		equivalent to -warn:deprecation.\n\
		-g[:<level>]		debug attributes level\n\
			\t-g			all debug info (''-g:lines,vars,source'')\n\
			\t-g:none			no debug info\n\
			\t-g:[lines,vars,source]	selective debug info\n\
		-preserveAllLocals	code gen preserve all local variables (for debug purpose)\n\
		-noImportError		no errors for unresolved imports\n\
		-encoding		specify default source encoding format (custom encoding can also be specifed on\n\
		\t\t\ta per file basis by suffixing each input source file/folder name with '[encoding]')\n\
		-log <filename>		specify a log file\n\
		-proceedOnError		keep compiling when error, dumping class files with problem methods\n\
		-verbose		print accessed/processed compilation units \n\
		-referenceInfo		compute reference info\n\
		-progress		show progress (only in -log mode)\n\
		-time			display speed information\n\
		-noExit			do not call System.exit(n) at end of compilation (n=0 if no error)\n\
		-repeat <n>		repeat compilation process <n> times (perf analysis)\n
