annotate src/share/classes/com/sun/tools/javac/resources/compiler.properties @ 112:38d07d25ab65

6962318: Update copyright year Reviewed-by: andrew
author ohair
date Wed, 22 Dec 2010 20:12:27 -0800
parents c28b5920263c
children c711bcdb18ea
rev   line source
duke@0 1 #
ohair@109 2 # Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
duke@0 3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 #
duke@0 5 # This code is free software; you can redistribute it and/or modify it
duke@0 6 # under the terms of the GNU General Public License version 2 only, as
ohair@86 7 # published by the Free Software Foundation. Oracle designates this
duke@0 8 # particular file as subject to the "Classpath" exception as provided
ohair@86 9 # by Oracle in the LICENSE file that accompanied this code.
duke@0 10 #
duke@0 11 # This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 13 # FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 14 # version 2 for more details (a copy is included in the LICENSE file that
duke@0 15 # accompanied this code).
duke@0 16 #
duke@0 17 # You should have received a copy of the GNU General Public License version
duke@0 18 # 2 along with this work; if not, write to the Free Software Foundation,
duke@0 19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 20 #
ohair@86 21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
ohair@86 22 # or visit www.oracle.com if you need additional information or have any
ohair@86 23 # questions.
duke@0 24 #
duke@0 25
duke@0 26 ##
duke@0 27 ## errors
duke@0 28 ##
duke@0 29
duke@0 30 compiler.err.abstract.cant.be.instantiated=\
duke@0 31 {0} is abstract; cannot be instantiated
duke@0 32 compiler.err.abstract.meth.cant.have.body=\
duke@0 33 abstract methods cannot have a body
duke@0 34 compiler.err.already.annotated=\
duke@0 35 {0} {1} has already been annotated
duke@0 36 compiler.err.already.defined=\
duke@0 37 {0} is already defined in {1}
duke@0 38 compiler.err.already.defined.single.import=\
duke@0 39 {0} is already defined in a single-type import
duke@0 40 compiler.err.already.defined.static.single.import=\
duke@0 41 {0} is already defined in a static single-type import
duke@0 42 compiler.err.already.defined.this.unit=\
duke@0 43 {0} is already defined in this compilation unit
duke@0 44 compiler.err.annotation.missing.default.value=\
duke@0 45 annotation {0} is missing {1}
duke@0 46 compiler.err.annotation.not.valid.for.type=\
duke@0 47 annotation not valid for a value of type {0}
duke@0 48 compiler.err.annotation.type.not.applicable=\
duke@0 49 annotation type not applicable to this kind of declaration
duke@0 50 compiler.err.annotation.value.must.be.annotation=\
duke@0 51 annotation value must be an annotation
duke@0 52 compiler.err.annotation.value.must.be.class.literal=\
duke@0 53 annotation value must be a class literal
duke@0 54 compiler.err.annotation.value.must.be.name.value=\
duke@0 55 annotation values must be of the form ''name=value''
duke@0 56 compiler.err.annotation.value.not.allowable.type=\
duke@0 57 annotation value not of an allowable type
duke@0 58 compiler.err.anon.class.impl.intf.no.args=\
duke@0 59 anonymous class implements interface; cannot have arguments
duke@0 60 compiler.err.anon.class.impl.intf.no.typeargs=\
duke@0 61 anonymous class implements interface; cannot have type arguments
duke@0 62 compiler.err.anon.class.impl.intf.no.qual.for.new=\
duke@0 63 anonymous class implements interface; cannot have qualifier for new
duke@0 64 compiler.err.array.and.varargs=\
duke@0 65 cannot declare both {0} and {1} in {2}
duke@0 66 compiler.err.array.dimension.missing=\
duke@0 67 array dimension missing
duke@0 68 compiler.err.array.req.but.found=\
duke@0 69 array required, but {0} found
duke@0 70
duke@0 71 compiler.err.assignment.from.super-bound=\
duke@0 72 assigning from wildcard {0}
duke@0 73 compiler.err.assignment.to.extends-bound=\
duke@0 74 assigning to wildcard {0}
duke@0 75 compiler.err.attribute.value.must.be.constant=\
duke@0 76 attribute value must be constant
duke@0 77
duke@0 78 compiler.err.break.outside.switch.loop=\
duke@0 79 break outside switch or loop
duke@0 80
duke@0 81 compiler.err.call.must.be.first.stmt.in.ctor=\
duke@0 82 call to {0} must be first statement in constructor
duke@0 83 compiler.err.cant.apply.symbol=\
duke@0 84 {0} in {1} cannot be applied to {2}({3})
duke@0 85 compiler.err.cant.apply.symbol.1=\
duke@0 86 {0} in {1} cannot be applied to {2}({3}); {4}
duke@0 87 compiler.err.cant.assign.val.to.final.var=\
duke@0 88 cannot assign a value to final variable {0}
duke@0 89 compiler.err.cant.deref=\
duke@0 90 {0} cannot be dereferenced
duke@0 91 compiler.err.cant.extend.intf.annotation=\
duke@0 92 ''extends'' not allowed for @interfaces
duke@0 93 compiler.err.cant.inherit.from.final=\
duke@0 94 cannot inherit from final {0}
duke@0 95 compiler.err.cant.ref.before.ctor.called=\
duke@0 96 cannot reference {0} before supertype constructor has been called
duke@0 97 compiler.err.cant.ret.val.from.meth.decl.void=\
duke@0 98 cannot return a value from method whose result type is void
duke@0 99 compiler.err.cant.select.static.class.from.param.type=\
duke@0 100 cannot select a static class from a parameterized type
duke@0 101 compiler.err.cant.inherit.diff.arg=\
duke@0 102 {0} cannot be inherited with different arguments: <{1}> and <{2}>
duke@0 103 compiler.err.catch.without.try=\
duke@0 104 ''catch'' without ''try''
duke@0 105 compiler.err.clash.with.pkg.of.same.name=\
duke@0 106 {0} clashes with package of same name
duke@0 107 compiler.err.const.expr.req=\
duke@0 108 constant expression required
duke@0 109 compiler.err.enum.const.req=\
duke@0 110 unqualified enumeration constant name required
duke@0 111 compiler.err.cont.outside.loop=\
duke@0 112 continue outside of loop
duke@0 113 compiler.err.cyclic.inheritance=\
duke@0 114 cyclic inheritance involving {0}
duke@0 115 compiler.err.cyclic.annotation.element=\
duke@0 116 cyclic annotation element type
duke@0 117 compiler.err.call.to.super.not.allowed.in.enum.ctor=\
duke@0 118 call to super not allowed in enum constructor
duke@0 119 compiler.err.no.superclass=\
duke@0 120 {0} has no superclass
duke@0 121
duke@0 122 compiler.err.concrete.inheritance.conflict=\
duke@0 123 methods {0} from {1} and {2} from {3} are inherited with the same signature
duke@0 124
duke@0 125 compiler.err.default.allowed.in.intf.annotation.member=\
duke@0 126 default value only allowed in an @interface member
duke@0 127 compiler.err.doesnt.exist=\
duke@0 128 package {0} does not exist
duke@0 129 compiler.err.duplicate.annotation=\
duke@0 130 duplicate annotation
duke@0 131 compiler.err.duplicate.annotation.member.value=\
duke@0 132 duplicate annotation member value {0} in {1}
duke@0 133 compiler.err.duplicate.class=\
duke@0 134 duplicate class: {0}
duke@0 135 compiler.err.duplicate.case.label=\
duke@0 136 duplicate case label
duke@0 137 compiler.err.duplicate.default.label=\
duke@0 138 duplicate default label
duke@0 139
duke@0 140 compiler.err.else.without.if=\
duke@0 141 ''else'' without ''if''
duke@0 142 compiler.err.empty.char.lit=\
duke@0 143 empty character literal
duke@0 144 compiler.err.encl.class.required=\
duke@0 145 an enclosing instance that contains {0} is required
duke@0 146 compiler.err.enum.annotation.must.be.enum.constant=\
duke@0 147 an enum annotation value must be an enum constant
duke@0 148
duke@0 149 compiler.err.enum.cant.be.instantiated=\
duke@0 150 enum types may not be instantiated
duke@0 151 compiler.err.enum.label.must.be.unqualified.enum=\
duke@0 152 an enum switch case label must be the unqualified name of an enumeration constant
duke@0 153 compiler.err.enum.no.subclassing=\
duke@0 154 classes cannot directly extend java.lang.Enum
duke@0 155 compiler.err.enum.types.not.extensible=\
duke@0 156 enum types are not extensible
duke@0 157 compiler.err.enum.no.finalize=\
duke@0 158 enums cannot have finalize methods
duke@0 159 compiler.err.error.reading.file=\
duke@0 160 error reading {0}; {1}
duke@0 161 compiler.err.except.already.caught=\
duke@0 162 exception {0} has already been caught
duke@0 163 compiler.err.except.never.thrown.in.try=\
duke@0 164 exception {0} is never thrown in body of corresponding try statement
duke@0 165
duke@0 166 compiler.err.final.parameter.may.not.be.assigned=\
duke@0 167 final parameter {0} may not be assigned
duke@0 168 compiler.err.finally.without.try=\
duke@0 169 ''finally'' without ''try''
duke@0 170 compiler.err.foreach.not.applicable.to.type=\
duke@0 171 foreach not applicable to expression type
duke@0 172 compiler.err.fp.number.too.large=\
duke@0 173 floating point number too large
duke@0 174 compiler.err.fp.number.too.small=\
duke@0 175 floating point number too small
duke@0 176
duke@0 177 compiler.err.generic.array.creation=\
duke@0 178 generic array creation
duke@0 179 compiler.err.generic.throwable=\
duke@0 180 a generic class may not extend java.lang.Throwable
duke@0 181
duke@0 182 compiler.err.icls.cant.have.static.decl=\
duke@0 183 inner classes cannot have static declarations
duke@0 184 compiler.err.illegal.char=\
duke@0 185 illegal character: \\{0}
duke@0 186 compiler.err.illegal.char.for.encoding=\
duke@0 187 unmappable character for encoding {0}
duke@0 188 compiler.err.illegal.combination.of.modifiers=\
duke@0 189 illegal combination of modifiers: {0} and {1}
duke@0 190 compiler.err.illegal.enum.static.ref=\
duke@0 191 illegal reference to static field from initializer
duke@0 192 compiler.err.illegal.esc.char=\
duke@0 193 illegal escape character
duke@0 194 compiler.err.illegal.forward.ref=\
duke@0 195 illegal forward reference
duke@0 196 compiler.warn.forward.ref=\
duke@0 197 reference to variable ''{0}'' before it has been initialized
duke@0 198 compiler.err.illegal.generic.type.for.instof=\
duke@0 199 illegal generic type for instanceof
duke@0 200 compiler.err.illegal.initializer.for.type=\
duke@0 201 illegal initializer for {0}
duke@0 202 compiler.err.illegal.line.end.in.char.lit=\
duke@0 203 illegal line end in character literal
duke@0 204 compiler.err.illegal.nonascii.digit=\
duke@0 205 illegal non-ASCII digit
duke@0 206 compiler.err.illegal.qual.not.icls=\
duke@0 207 illegal qualifier; {0} is not an inner class
duke@0 208 compiler.err.illegal.start.of.expr=\
duke@0 209 illegal start of expression
duke@0 210 compiler.err.illegal.start.of.type=\
duke@0 211 illegal start of type
duke@0 212 compiler.err.illegal.unicode.esc=\
duke@0 213 illegal unicode escape
duke@0 214 compiler.err.import.requires.canonical=\
duke@0 215 import requires canonical name for {0}
duke@0 216 compiler.err.improperly.formed.type.param.missing=\
duke@0 217 improperly formed type, some parameters are missing
duke@0 218 compiler.err.improperly.formed.type.inner.raw.param=\
duke@0 219 improperly formed type, type parameters given on a raw type
duke@0 220 compiler.err.incomparable.types=\
duke@0 221 incomparable types: {0} and {1}
duke@0 222 compiler.err.int.number.too.large=\
duke@0 223 integer number too large: {0}
duke@0 224 compiler.err.internal.error.cant.instantiate=\
duke@0 225 internal error; cannot instantiate {0} at {1} to ({2})
duke@0 226 compiler.err.intf.annotation.members.cant.have.params=\
duke@0 227 @interface members may not have parameters
duke@0 228 compiler.err.intf.annotation.cant.have.type.params=\
duke@0 229 @interface may not have type parameters
duke@0 230 compiler.err.intf.annotation.members.cant.have.type.params=\
duke@0 231 @interface members may not have type parameters
duke@0 232 compiler.err.intf.annotation.member.clash=\
duke@0 233 @interface member clashes with method ''{0}'' in {1}
duke@0 234 compiler.err.intf.expected.here=\
duke@0 235 interface expected here
duke@0 236 compiler.err.intf.meth.cant.have.body=\
duke@0 237 interface methods cannot have body
duke@0 238 compiler.err.invalid.annotation.member.type=\
duke@0 239 invalid type for annotation member
duke@0 240 compiler.err.invalid.hex.number=\
duke@0 241 hexadecimal numbers must contain at least one hexadecimal digit
duke@0 242 compiler.err.invalid.meth.decl.ret.type.req=\
duke@0 243 invalid method declaration; return type required
duke@0 244
duke@0 245 compiler.err.label.already.in.use=\
duke@0 246 label {0} already in use
duke@0 247 compiler.err.local.var.accessed.from.icls.needs.final=\
duke@0 248 local variable {0} is accessed from within inner class; needs to be declared final
duke@0 249 compiler.err.local.enum=\
duke@0 250 enum types must not be local
duke@0 251 compiler.err.cannot.create.array.with.type.arguments=\
duke@0 252 cannot create array with type arguments
duke@0 253
duke@0 254 #
duke@0 255 # limits. We don't give the limits in the diagnostic because we expect
duke@0 256 # them to change, yet we want to use the same diagnostic. These are all
duke@0 257 # detected during code generation.
duke@0 258 #
duke@0 259 compiler.err.limit.code=\
duke@0 260 code too large
duke@0 261 compiler.err.limit.code.too.large.for.try.stmt=\
duke@0 262 code too large for try statement
duke@0 263 compiler.err.limit.dimensions=\
duke@0 264 array type has too many dimensions
duke@0 265 compiler.err.limit.locals=\
duke@0 266 too many local variables
duke@0 267 compiler.err.limit.parameters=\
duke@0 268 too many parameters
duke@0 269 compiler.err.limit.pool=\
duke@0 270 too many constants
duke@0 271 compiler.err.limit.pool.in.class=\
duke@0 272 too many constants in class {0}
duke@0 273 compiler.err.limit.stack=\
duke@0 274 code requires too much stack
duke@0 275 compiler.err.limit.string=\
duke@0 276 constant string too long
duke@0 277 compiler.err.limit.string.overflow=\
duke@0 278 UTF8 representation for string \"{0}...\" is too long for the constant pool
duke@0 279
duke@0 280 compiler.err.malformed.fp.lit=\
duke@0 281 malformed floating point literal
duke@0 282 compiler.err.method.does.not.override.superclass=\
duke@0 283 method does not override or implement a method from a supertype
duke@0 284 compiler.err.missing.meth.body.or.decl.abstract=\
duke@0 285 missing method body, or declare abstract
duke@0 286 compiler.err.missing.ret.stmt=\
duke@0 287 missing return statement
duke@0 288 compiler.err.missing.ret.val=\
duke@0 289 missing return value
duke@0 290 compiler.err.mod.not.allowed.here=\
duke@0 291 modifier {0} not allowed here
duke@0 292 compiler.err.intf.not.allowed.here=\
duke@0 293 interface not allowed here
duke@0 294 compiler.err.enums.must.be.static=\
duke@0 295 enum declarations allowed only in static contexts
duke@0 296
duke@0 297 compiler.err.name.clash.same.erasure=\
duke@0 298 name clash: {0} and {1} have the same erasure
duke@0 299 compiler.err.name.clash.same.erasure.no.override=\
duke@0 300 name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other
duke@0 301 compiler.err.name.reserved.for.internal.use=\
duke@0 302 {0} is reserved for internal use
duke@0 303 compiler.err.native.meth.cant.have.body=\
duke@0 304 native methods cannot have a body
duke@0 305 compiler.err.neither.conditional.subtype=\
duke@0 306 incompatible types for ?: neither is a subtype of the other\n\
duke@0 307 second operand: {0}\n\
duke@0 308 third operand : {1}
duke@0 309 compiler.err.new.not.allowed.in.annotation=\
duke@0 310 ''new'' not allowed in an annotation
duke@0 311 compiler.err.no.annotation.member=\
duke@0 312 no annotation member {0} in {1}
duke@0 313 compiler.err.no.encl.instance.of.type.in.scope=\
duke@0 314 no enclosing instance of type {0} is in scope
duke@0 315 compiler.err.no.intf.expected.here=\
duke@0 316 no interface expected here
duke@0 317 compiler.err.no.match.entry=\
duke@0 318 {0} has no match in entry in {1}; required {2}
duke@0 319 compiler.err.not.annotation.type=\
duke@0 320 {0} is not an annotation type
duke@0 321 compiler.err.not.def.access.class.intf.cant.access=\
duke@0 322 {0} in {1} is defined in an inaccessible class or interface
duke@0 323 compiler.err.not.def.public.cant.access=\
duke@0 324 {0} is not public in {1}; cannot be accessed from outside package
duke@0 325 compiler.err.not.loop.label=\
duke@0 326 not a loop label: {0}
duke@0 327 compiler.err.not.stmt=\
duke@0 328 not a statement
duke@0 329 compiler.err.not.encl.class=\
duke@0 330 not an enclosing class: {0}
duke@0 331
duke@0 332 compiler.err.operator.cant.be.applied=\
duke@0 333 operator {0} cannot be applied to {1}
duke@0 334
duke@0 335 compiler.err.pkg.annotations.sb.in.package-info.java=\
duke@0 336 package annotations should be in file package-info.java
duke@0 337 compiler.err.pkg.clashes.with.class.of.same.name=\
duke@0 338 package {0} clashes with class of same name
duke@0 339
jjg@103 340 compiler.err.warnings.and.werror=\
jjg@103 341 warnings found and -Werror specified
jjg@103 342
duke@0 343 # Errors related to annotation processing
duke@0 344
duke@0 345 compiler.err.proc.cant.access=\
duke@0 346 cannot access {0}\n\
duke@0 347 {1}\n\
duke@0 348 Consult the following stack trace for details.\n\
duke@0 349 {2}
duke@0 350
duke@0 351 compiler.err.proc.cant.find.class=\
duke@0 352 Could not find class file for ''{0}''.
duke@0 353
duke@0 354 # Print a client-generated error message; assumed to be localized, no translation required
duke@0 355 compiler.err.proc.messager=\
duke@0 356 {0}
duke@0 357
duke@0 358 compiler.err.proc.no.explicit.annotation.processing.requested=\
duke@0 359 Class names, ''{0}'', are only accepted if annotation processing is explicitly requested
duke@0 360
duke@0 361 compiler.err.proc.no.service=\
duke@0 362 A service loader class could not be found.\n\
duke@0 363 Either java.util.ServiceLoader or sun.misc.Service must be available.
duke@0 364
duke@0 365 compiler.err.proc.processor.bad.option.name=\
duke@0 366 Bad option name ''{0}'' provided by processor ''{1}''
duke@0 367
duke@0 368 compiler.err.proc.processor.cant.instantiate=\
duke@0 369 Could not instantiate an instance of processor ''{0}''
duke@0 370
duke@0 371 compiler.err.proc.processor.constructor.error=\
duke@0 372 Exception thrown while constructing Processor object: {0}
duke@0 373
duke@0 374 compiler.err.proc.processor.not.found=\
duke@0 375 Annotation processor ''{0}'' not found
duke@0 376
duke@0 377 compiler.err.proc.processor.wrong.type=\
duke@0 378 Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor
duke@0 379
duke@0 380 compiler.err.proc.service.problem=\
duke@0 381 Error creating a service loader to load Processors.
duke@0 382
duke@0 383 compiler.err.proc.bad.config.file=\
duke@0 384 Bad service configuration file, or exception thrown while constructing Processor object: {0}
duke@0 385
duke@0 386 compiler.err.proc.cant.create.loader=\
duke@0 387 Could not create class loader for annotation processors: {0}
duke@0 388
duke@0 389 compiler.err.qualified.new.of.static.class=\
duke@0 390 qualified new of static class
duke@0 391
duke@0 392 compiler.err.recursive.ctor.invocation=\
duke@0 393 recursive constructor invocation
duke@0 394 compiler.err.ref.ambiguous=\
duke@0 395 reference to {0} is ambiguous, both {1} {2} in {3} and {4} {5} in {6} match
duke@0 396 compiler.err.repeated.annotation.target=\
duke@0 397 repeated annotation target
duke@0 398 compiler.err.repeated.interface=\
duke@0 399 repeated interface
duke@0 400 compiler.err.repeated.modifier=\
duke@0 401 repeated modifier
duke@0 402 compiler.err.report.access=\
duke@0 403 {0} has {1} access in {2}
duke@0 404 compiler.err.ret.outside.meth=\
duke@0 405 return outside method
duke@0 406
duke@0 407 compiler.err.signature.doesnt.match.supertype=\
duke@0 408 signature does not match {0}; incompatible supertype
duke@0 409 compiler.err.signature.doesnt.match.intf=\
duke@0 410 signature does not match {0}; incompatible interfaces
duke@0 411 compiler.err.does.not.override.abstract=\
duke@0 412 {0} is not abstract and does not override abstract method {1} in {2}
duke@0 413 compiler.err.source.cant.overwrite.input.file=\
duke@0 414 error writing source; cannot overwrite input file {0}
duke@0 415 compiler.err.stack.sim.error=\
duke@0 416 Internal error: stack sim error on {0}
duke@0 417 compiler.err.static.imp.only.classes.and.interfaces=\
duke@0 418 static import only from classes and interfaces
duke@0 419 compiler.err.synthetic.name.conflict=\
duke@0 420 the symbol {0} conflicts with a compiler-synthesized symbol in {1}
duke@0 421
duke@0 422 compiler.err.throws.not.allowed.in.intf.annotation=\
duke@0 423 throws clause not allowed in @interface members
duke@0 424 compiler.err.try.without.catch.or.finally=\
duke@0 425 ''try'' without ''catch'' or ''finally''
duke@0 426 compiler.err.type.doesnt.take.params=\
duke@0 427 type {0} does not take parameters
duke@0 428 compiler.err.type.var.cant.be.deref=\
duke@0 429 cannot select from a type variable
duke@0 430 compiler.err.type.var.may.not.be.followed.by.other.bounds=\
duke@0 431 a type variable may not be followed by other bounds
duke@0 432 compiler.err.type.var.more.than.once=\
duke@0 433 type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
duke@0 434 compiler.err.type.var.more.than.once.in.result=\
duke@0 435 type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated
duke@0 436 compiler.err.types.incompatible.diff.ret=\
duke@0 437 types {0} and {1} are incompatible; both define {2}, but with unrelated return types
duke@0 438
duke@0 439 compiler.err.unclosed.char.lit=\
duke@0 440 unclosed character literal
duke@0 441 compiler.err.unclosed.comment=\
duke@0 442 unclosed comment
duke@0 443 compiler.err.unclosed.str.lit=\
duke@0 444 unclosed string literal
duke@0 445 compiler.err.unknown.enum.constant=\
duke@0 446 in class file {0}: unknown enum constant {1}.{2}
duke@0 447 compiler.err.unsupported.encoding=\
duke@0 448 unsupported encoding: {0}
duke@0 449 compiler.err.io.exception=\
duke@0 450 error reading source file: {0}
duke@0 451 compiler.err.undef.label=\
duke@0 452 undefined label: {0}
duke@0 453 compiler.err.undetermined.type=\
duke@0 454 type parameters of {0} cannot be determined
duke@0 455 compiler.err.undetermined.type.1=\
duke@0 456 type parameters of {0} cannot be determined; {1}
duke@0 457 compiler.err.unreachable.stmt=\
duke@0 458 unreachable statement
duke@0 459 compiler.err.initializer.must.be.able.to.complete.normally=\
duke@0 460 initializer must be able to complete normally
duke@0 461 compiler.err.unreported.exception.need.to.catch.or.throw=\
duke@0 462 unreported exception {0}; must be caught or declared to be thrown
duke@0 463 compiler.err.unreported.exception.default.constructor=\
duke@0 464 unreported exception {0} in default constructor
duke@0 465 compiler.err.unsupported.cross.fp.lit=\
duke@0 466 hexadecimal floating-point literals are not supported on this VM
duke@0 467 compiler.err.void.not.allowed.here=\
duke@0 468 ''void'' type not allowed here
duke@0 469
duke@0 470 compiler.err.wrong.number.type.args=\
duke@0 471 wrong number of type arguments; required {0}
duke@0 472
duke@0 473 compiler.err.var.might.already.be.assigned=\
duke@0 474 variable {0} might already have been assigned
duke@0 475 compiler.err.var.might.not.have.been.initialized=\
duke@0 476 variable {0} might not have been initialized
duke@0 477 compiler.err.var.might.be.assigned.in.loop=\
duke@0 478 variable {0} might be assigned in loop
duke@0 479
duke@0 480 # In the following string, {1} will always be the detail message from
duke@0 481 # java.io.IOException.
duke@0 482 compiler.err.class.cant.write=\
duke@0 483 error while writing {0}: {1}
duke@0 484
duke@0 485 # In the following string, {0} is the name of the class in the Java source.
duke@0 486 # It really should be used two times..
duke@0 487 compiler.err.class.public.should.be.in.file=\
duke@0 488 class {0} is public, should be declared in a file named {0}.java
duke@0 489
duke@0 490 ## All errors which do not refer to a particular line in the source code are
duke@0 491 ## preceded by this string.
duke@0 492 compiler.err.error=\
duke@0 493 error:\u0020
duke@0 494
duke@0 495 # The following error messages do not refer to a line in the source code.
duke@0 496 compiler.err.cant.read.file=\
duke@0 497 cannot read: {0}
duke@0 498
duke@0 499 #####
duke@0 500
duke@0 501 # Fatal Errors
duke@0 502
duke@0 503 compiler.misc.fatal.err.no.java.lang=\
duke@0 504 Fatal Error: Unable to find package java.lang in classpath or bootclasspath
duke@0 505 compiler.misc.fatal.err.cant.locate.meth=\
duke@0 506 Fatal Error: Unable to find method {0}
duke@0 507 compiler.misc.fatal.err.cant.locate.field=\
duke@0 508 Fatal Error: Unable to find field {0}
duke@0 509 compiler.misc.fatal.err.cant.locate.ctor=\
duke@0 510 Fatal Error: Unable to find constructor for {0}
duke@0 511
duke@0 512 #####
duke@0 513
duke@0 514 ##
duke@0 515 ## miscellaneous strings
duke@0 516 ##
duke@0 517
duke@0 518 compiler.misc.source.unavailable=\
duke@0 519 (source unavailable)
duke@0 520 compiler.misc.base.membership=\
duke@0 521 all your base class are belong to us
duke@0 522 compiler.misc.x.print.processor.info=\
duke@0 523 Processor {0} matches {1} and returns {2}.
duke@0 524 compiler.misc.x.print.rounds=\
duke@0 525 Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}
duke@0 526
duke@0 527 #####
duke@0 528
duke@0 529 ## The following string will appear before all messages keyed as:
duke@0 530 ## "compiler.note".
duke@0 531 compiler.note.note=\
duke@0 532 Note:\u0020
duke@0 533
duke@0 534 compiler.note.deprecated.filename=\
duke@0 535 {0} uses or overrides a deprecated API.
duke@0 536 compiler.note.deprecated.plural=\
duke@0 537 Some input files use or override a deprecated API.
duke@0 538 # The following string may appear after one of the above deprecation
duke@0 539 # messages.
duke@0 540 compiler.note.deprecated.recompile=\
duke@0 541 Recompile with -Xlint:deprecation for details.
duke@0 542
duke@0 543 compiler.note.deprecated.filename.additional=\
duke@0 544 {0} has additional uses or overrides of a deprecated API.
duke@0 545 compiler.note.deprecated.plural.additional=\
duke@0 546 Some input files additionally use or override a deprecated API.
duke@0 547
duke@0 548 # Notes related to annotation processing
duke@0 549
duke@0 550 # Print a client-generated note; assumed to be localized, no translation required
duke@0 551 compiler.note.proc.messager=\
duke@0 552 {0}
duke@0 553
duke@0 554 compiler.note.unchecked.filename=\
duke@0 555 {0} uses unchecked or unsafe operations.
duke@0 556 compiler.note.unchecked.plural=\
duke@0 557 Some input files use unchecked or unsafe operations.
duke@0 558 # The following string may appear after one of the above deprecation
duke@0 559 # messages.
duke@0 560 compiler.note.unchecked.recompile=\
duke@0 561 Recompile with -Xlint:unchecked for details.
duke@0 562
duke@0 563 compiler.note.unchecked.filename.additional=\
duke@0 564 {0} has additional unchecked or unsafe operations.
duke@0 565 compiler.note.unchecked.plural.additional=\
duke@0 566 Some input files additionally use unchecked or unsafe operations.
duke@0 567
duke@0 568 #####
duke@0 569
duke@0 570 compiler.misc.count.error=\
duke@0 571 {0} error
duke@0 572 compiler.misc.count.error.plural=\
duke@0 573 {0} errors
duke@0 574 compiler.misc.count.warn=\
duke@0 575 {0} warning
duke@0 576 compiler.misc.count.warn.plural=\
duke@0 577 {0} warnings
duke@0 578
duke@0 579 ## extra output when using -verbose (JavaCompiler)
duke@0 580
duke@0 581 compiler.misc.verbose.checking.attribution=\
duke@0 582 [checking {0}]
duke@0 583 compiler.misc.verbose.parsing.done=\
duke@0 584 [parsing completed {0}ms]
duke@0 585 compiler.misc.verbose.parsing.started=\
duke@0 586 [parsing started {0}]
duke@0 587 compiler.misc.verbose.total=\
duke@0 588 [total {0}ms]
duke@0 589 compiler.misc.verbose.wrote.file=\
duke@0 590 [wrote {0}]
duke@0 591
duke@0 592 ## extra output when using -verbose (Retro)
duke@0 593 compiler.misc.verbose.retro=\
duke@0 594 [retrofitting {0}]
duke@0 595 compiler.misc.verbose.retro.with=\
duke@0 596 \tretrofitting {0} with {1}
duke@0 597 compiler.misc.verbose.retro.with.list=\
duke@0 598 \tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}
duke@0 599
duke@0 600 ## extra output when using -verbose (code/ClassReader)
duke@0 601 compiler.misc.verbose.loading=\
duke@0 602 [loading {0}]
duke@0 603
duke@0 604 compiler.misc.verbose.sourcepath=\
duke@0 605 [search path for source files: {0}]
duke@0 606
duke@0 607 compiler.misc.verbose.classpath=\
duke@0 608 [search path for class files: {0}]
duke@0 609
duke@0 610 ## extra output when using -checkclassfile (code/ClassReader)
duke@0 611 compiler.misc.ccf.found.later.version=\
duke@0 612 class file has later version than expected: {0}
duke@0 613 compiler.misc.ccf.unrecognized.attribute=\
duke@0 614 unrecognized attribute: {0}
duke@0 615
duke@0 616 ## extra output when using -prompt (util/Log)
duke@0 617 compiler.misc.resume.abort=\
duke@0 618 R)esume, A)bort>
duke@0 619
duke@0 620 #####
duke@0 621
duke@0 622 ##
duke@0 623 ## warnings
duke@0 624 ##
duke@0 625
duke@0 626 ## All warning messages are preceded by the following string.
duke@0 627 compiler.warn.warning=\
duke@0 628 warning:\u0020
duke@0 629
duke@0 630 compiler.warn.constant.SVUID=\
duke@0 631 [serial] serialVersionUID must be constant in class {0}
duke@0 632
duke@0 633 compiler.warn.dir.path.element.not.found=\
duke@0 634 [path] bad path element "{0}": no such directory
duke@0 635
duke@0 636 compiler.warn.finally.cannot.complete=\
duke@0 637 [finally] finally clause cannot complete normally
duke@0 638
duke@0 639 compiler.warn.has.been.deprecated=\
duke@0 640 [deprecation] {0} in {1} has been deprecated
duke@0 641
duke@0 642 compiler.warn.sun.proprietary=\
jjg@89 643 {0} is internal proprietary API and may be removed in a future release
duke@0 644
duke@0 645 compiler.warn.illegal.char.for.encoding=\
duke@0 646 unmappable character for encoding {0}
duke@0 647 compiler.warn.improper.SVUID=\
duke@0 648 [serial] serialVersionUID must be declared static final in class {0}
duke@0 649
duke@0 650 compiler.warn.inexact.non-varargs.call=\
duke@0 651 non-varargs call of varargs method with inexact argument type for last parameter;\n\
duke@0 652 cast to {0} for a varargs call\n\
duke@0 653 cast to {1} for a non-varargs call and to suppress this warning
duke@0 654
duke@0 655 compiler.warn.long.SVUID=\
duke@0 656 [serial] serialVersionUID must be of type long in class {0}
duke@0 657
duke@0 658 compiler.warn.missing.SVUID=\
duke@0 659 [serial] serializable class {0} has no definition of serialVersionUID
duke@0 660
duke@0 661 compiler.warn.override.varargs.missing=\
duke@0 662 {0}; overridden method has no ''...''
duke@0 663 compiler.warn.override.varargs.extra=\
duke@0 664 {0}; overriding method is missing ''...''
duke@0 665 compiler.warn.override.bridge=\
duke@0 666 {0}; overridden method is a bridge method
duke@0 667
duke@0 668 compiler.warn.pkg-info.already.seen=\
duke@0 669 [package-info] a package-info.java file has already been seen for package {0}
duke@0 670 compiler.warn.path.element.not.found=\
duke@0 671 [path] bad path element "{0}": no such file or directory
duke@0 672 compiler.warn.possible.fall-through.into.case=\
duke@0 673 [fallthrough] possible fall-through into case
duke@0 674
duke@0 675 compiler.warn.redundant.cast=\
duke@0 676 [cast] redundant cast to {0}
duke@0 677
duke@0 678 compiler.warn.position.overflow=\
duke@0 679 Position encoding overflows at line {0}
duke@0 680
duke@0 681 compiler.warn.big.major.version=\
duke@0 682 {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\
duke@0 683 It is recommended that the compiler be upgraded.
duke@0 684
duke@0 685 # Warnings related to annotation processing
duke@0 686 compiler.warn.proc.package.does.not.exist=\
duke@0 687 package {0} does not exist
duke@0 688 compiler.warn.proc.file.reopening=\
duke@0 689 Attempt to create a file for ''{0}'' multiple times
duke@0 690
duke@0 691 compiler.warn.proc.type.already.exists=\
duke@0 692 A file for type ''{0}'' already exists on the sourcepath or classpath
duke@0 693
duke@0 694 compiler.warn.proc.type.recreate=\
duke@0 695 Attempt to create a file for type ''{0}'' multiple times
duke@0 696
duke@0 697 compiler.warn.proc.illegal.file.name=\
duke@0 698 Cannot create file for illegal name ''{0}''.
duke@0 699
duke@0 700 compiler.warn.proc.file.create.last.round=\
duke@0 701 File for type ''{0}'' created in the last round will not be subject to annotation processing.
duke@0 702
duke@0 703 compiler.warn.proc.malformed.supported.string=\
duke@0 704 Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''
duke@0 705
duke@0 706 compiler.warn.proc.annotations.without.processors=\
duke@0 707 No processor claimed any of these annotations: {0}
duke@0 708
duke@0 709 compiler.warn.proc.processor.incompatible.source.version=\
duke@0 710 Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''
duke@0 711
duke@0 712 compiler.warn.proc.proc-only.requested.no.procs=\
duke@0 713 Annotation processing without compilation requested but no processors were found.
duke@0 714
duke@0 715 compiler.warn.proc.use.implicit=\
duke@0 716 Implicitly compiled files were not subject to annotation processing.\n\
duke@0 717 Use -implicit to specify a policy for implicit compilation.
duke@0 718
duke@0 719 compiler.warn.proc.use.proc.or.implicit=\
duke@0 720 Implicitly compiled files were not subject to annotation processing.\n\
duke@0 721 Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.
duke@0 722
duke@0 723 # Print a client-generated warning; assumed to be localized, no translation required
duke@0 724 compiler.warn.proc.messager=\
duke@0 725 {0}
duke@0 726
duke@0 727 compiler.warn.proc.unclosed.type.files=\
duke@0 728 Unclosed files for the types ''{0}''; these types will not undergo annotation processing
duke@0 729
duke@0 730 compiler.warn.proc.unmatched.processor.options=\
duke@0 731 The following options were not recognized by any processor: ''{0}''
duke@0 732
duke@0 733 compiler.warn.unchecked.assign=\
duke@0 734 [unchecked] unchecked assignment: {0} to {1}
duke@0 735 compiler.warn.unchecked.assign.to.var=\
duke@0 736 [unchecked] unchecked assignment to variable {0} as member of raw type {1}
duke@0 737 compiler.warn.unchecked.call.mbr.of.raw.type=\
duke@0 738 [unchecked] unchecked call to {0} as a member of the raw type {1}
duke@0 739 compiler.warn.unchecked.cast.to.type=\
duke@0 740 [unchecked] unchecked cast to type {0}
duke@0 741 compiler.warn.unchecked.meth.invocation.applied=\
duke@0 742 [unchecked] unchecked method invocation: {0} in {1} is applied to {2}({3})
duke@0 743 compiler.warn.unchecked.generic.array.creation=\
duke@0 744 [unchecked] unchecked generic array creation of type {0} for varargs parameter
duke@0 745
duke@0 746 compiler.warn.missing.deprecated.annotation=\
duke@0 747 [dep-ann] deprecated item is not annotated with @Deprecated
duke@0 748
duke@0 749 compiler.warn.invalid.archive.file=\
duke@0 750 [path] Unexpected file on path: {0}
duke@0 751
duke@0 752 compiler.warn.unexpected.archive.file=\
duke@0 753 [path] Unexpected extension for archive file: {0}
duke@0 754
duke@0 755 compiler.warn.div.zero=\
duke@0 756 [divzero] division by zero
duke@0 757
duke@0 758 compiler.warn.empty.if=\
duke@0 759 [empty] empty statement after if
duke@0 760
duke@0 761 compiler.warn.annotation.method.not.found=\
duke@0 762 Cannot find annotation method ''{1}()'' in type ''{0}''
duke@0 763
duke@0 764 compiler.warn.annotation.method.not.found.reason=\
duke@0 765 Cannot find annotation method ''{1}()'' in type ''{0}'': {2}
duke@0 766
duke@0 767 #####
duke@0 768
duke@0 769 ## The following are tokens which are non-terminals in the language. They should
duke@0 770 ## be named as JLS3 calls them when translated to the appropriate language.
duke@0 771 compiler.misc.token.identifier=\
duke@0 772 <identifier>
duke@0 773 compiler.misc.token.character=\
duke@0 774 <character>
duke@0 775 compiler.misc.token.string=\
duke@0 776 <string>
duke@0 777 compiler.misc.token.integer=\
duke@0 778 <integer>
duke@0 779 compiler.misc.token.long-integer=\
duke@0 780 <long integer>
duke@0 781 compiler.misc.token.float=\
duke@0 782 <float>
duke@0 783 compiler.misc.token.double=\
duke@0 784 <double>
duke@0 785 compiler.misc.token.bad-symbol=\
duke@0 786 <bad symbol>
duke@0 787 compiler.misc.token.end-of-input=\
duke@0 788 <end of input>
duke@0 789
duke@0 790 ## The argument to the following string will always be one of the following:
duke@0 791 ## 1. one of the above non-terminals
duke@0 792 ## 2. a keyword (JLS1.8)
duke@0 793 ## 3. a boolean literal (JLS3.10.3)
duke@0 794 ## 4. the null literal (JLS3.10.7)
duke@0 795 ## 5. a Java separator (JLS3.11)
duke@0 796 ## 6. an operator (JLS3.12)
duke@0 797 ##
duke@0 798 ## This is the only place these tokens will be used.
duke@0 799 compiler.err.expected=\
duke@0 800 {0} expected
duke@0 801 compiler.err.expected2=\
duke@0 802 {0} or {1} expected
duke@0 803 compiler.err.expected3=\
duke@0 804 {0}, {1}, or {2} expected
duke@0 805
duke@0 806 compiler.err.premature.eof=\
duke@0 807 reached end of file while parsing
duke@0 808
duke@0 809 ## The following are related in form, but do not easily fit the above paradigm.
duke@0 810 compiler.err.dot.class.expected=\
duke@0 811 ''.class'' expected
duke@0 812
duke@0 813 ## The argument to this string will always be either 'case' or 'default'.
duke@0 814 compiler.err.orphaned=\
duke@0 815 orphaned {0}
duke@0 816
duke@0 817 compiler.misc.anonymous.class=\
duke@0 818 <anonymous {0}>
duke@0 819
duke@0 820 compiler.misc.unnamed.package=\
duke@0 821 unnamed package
duke@0 822
duke@0 823 #####
duke@0 824
duke@0 825 compiler.err.cant.access=\
duke@0 826 cannot access {0}\n\
duke@0 827 {1}
duke@0 828
duke@0 829 compiler.misc.bad.class.file.header=\
duke@0 830 bad class file: {0}\n\
duke@0 831 {1}\n\
duke@0 832 Please remove or make sure it appears in the correct subdirectory of the classpath.
duke@0 833
duke@0 834 ## The following are all possible strings for the second argument ({1}) of the
duke@0 835 ## above strings.
duke@0 836 compiler.misc.bad.class.signature=\
duke@0 837 bad class signature: {0}
duke@0 838 compiler.misc.bad.enclosing.method=\
duke@0 839 bad enclosing method attribute: {0}
duke@0 840 compiler.misc.bad.runtime.invisible.param.annotations=\
duke@0 841 bad RuntimeInvisibleParameterAnnotations attribute: {0}
duke@0 842 compiler.misc.bad.const.pool.tag=\
duke@0 843 bad constant pool tag: {0}
duke@0 844 compiler.misc.bad.const.pool.tag.at=\
duke@0 845 bad constant pool tag: {0} at {1}
duke@0 846 compiler.misc.bad.signature=\
duke@0 847 bad signature: {0}
duke@0 848 compiler.misc.class.file.wrong.class=\
duke@0 849 class file contains wrong class: {0}
duke@0 850 compiler.misc.class.file.not.found=\
duke@0 851 class file for {0} not found
duke@0 852 compiler.misc.file.doesnt.contain.class=\
duke@0 853 file does not contain class {0}
duke@0 854 compiler.misc.file.does.not.contain.package=\
duke@0 855 file does not contain package {0}
duke@0 856 compiler.misc.illegal.start.of.class.file=\
duke@0 857 illegal start of class file
duke@0 858 compiler.misc.unable.to.access.file=\
duke@0 859 unable to access file: {0}
duke@0 860 compiler.misc.unicode.str.not.supported=\
duke@0 861 unicode string in class file not supported
duke@0 862 compiler.misc.undecl.type.var=\
duke@0 863 undeclared type variable: {0}
duke@0 864 compiler.misc.wrong.version=\
duke@0 865 class file has wrong version {0}.{1}, should be {2}.{3}
duke@0 866
duke@0 867 #####
duke@0 868
duke@0 869 compiler.err.not.within.bounds=\
duke@0 870 type parameter {0} is not within its bound
duke@0 871
duke@0 872 compiler.err.not.within.bounds.explain=\
duke@0 873 type parameter {0} is not within its bound; {1}
duke@0 874
duke@0 875 ## The following are all possible strings for the second argument ({1}) of the
duke@0 876 ## above string.
duke@0 877
duke@0 878 ## none yet...
duke@0 879
duke@0 880 #####
duke@0 881
duke@0 882 compiler.err.prob.found.req=\
duke@0 883 {0}\n\
duke@0 884 found : {1}\n\
duke@0 885 required: {2}
duke@0 886 compiler.warn.prob.found.req=\
duke@0 887 {0}\n\
duke@0 888 found : {1}\n\
duke@0 889 required: {2}
duke@0 890 compiler.err.prob.found.req.1=\
duke@0 891 {0} {3}\n\
duke@0 892 found : {1}\n\
duke@0 893 required: {2}
duke@0 894
duke@0 895 ## The following are all possible strings for the first argument ({0}) of the
duke@0 896 ## above strings.
duke@0 897 compiler.misc.incompatible.types=\
duke@0 898 incompatible types
duke@0 899 compiler.misc.incompatible.types.1=\
duke@0 900 incompatible types; {0}
duke@0 901 compiler.misc.inconvertible.types=\
duke@0 902 inconvertible types
duke@0 903 compiler.misc.possible.loss.of.precision=\
duke@0 904 possible loss of precision
duke@0 905
duke@0 906 compiler.misc.unchecked.assign=\
duke@0 907 [unchecked] unchecked conversion
duke@0 908 # compiler.misc.storecheck=\
duke@0 909 # [unchecked] assignment might cause later store checks to fail
duke@0 910 # compiler.misc.unchecked=\
duke@0 911 # [unchecked] assigned array cannot dynamically check its stores
duke@0 912 compiler.misc.unchecked.cast.to.type=\
duke@0 913 [unchecked] unchecked cast
duke@0 914
duke@0 915 compiler.misc.assignment.from.super-bound=\
duke@0 916 assignment from super-bound type {0}
duke@0 917 compiler.misc.assignment.to.extends-bound=\
duke@0 918 assignment to extends-bound type {0}
duke@0 919 # compiler.err.star.expected=\
duke@0 920 # ''*'' expected
duke@0 921 # compiler.err.no.elem.type=\
duke@0 922 # \[\*\] cannot have a type
duke@0 923
duke@0 924 #####
duke@0 925
duke@0 926 compiler.err.type.found.req=\
duke@0 927 unexpected type\n\
duke@0 928 found : {0}\n\
duke@0 929 required: {1}
duke@0 930
duke@0 931 ## The following are all possible strings for the first argument ({0}) of the
duke@0 932 ## above string.
duke@0 933 compiler.misc.type.req.class=\
duke@0 934 class
duke@0 935 compiler.misc.type.req.class.array=\
duke@0 936 class or array
duke@0 937 compiler.misc.type.req.ref=\
duke@0 938 reference
duke@0 939 compiler.misc.type.req.exact=\
duke@0 940 class or interface without bounds
duke@0 941 compiler.misc.type.parameter=\
duke@0 942 type parameter {0}
duke@0 943
duke@0 944 #####
duke@0 945
duke@0 946 ## The following are all possible strings for the last argument of all those
duke@0 947 ## diagnostics whose key ends in ".1"
duke@0 948 compiler.misc.undetermined.type=\
duke@0 949 undetermined type
duke@0 950 ncompiler.misc.type.variable.has.undetermined.type=\
duke@0 951 type variable {0} has undetermined type
duke@0 952 compiler.misc.no.unique.maximal.instance.exists=\
duke@0 953 no unique maximal instance exists for type variable {0} with upper bounds {1}
duke@0 954 compiler.misc.no.unique.minimal.instance.exists=\
duke@0 955 no unique minimal instance exists for type variable {0} with lower bounds {1}
duke@0 956 compiler.misc.no.conforming.instance.exists=\
duke@0 957 no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}
duke@0 958 compiler.misc.no.conforming.assignment.exists=\
duke@0 959 no instance(s) of type variable(s) {0} exist so that argument type {1} conforms to formal parameter type {2}
duke@0 960 compiler.misc.arg.length.mismatch=\
duke@0 961 cannot instantiate from arguments because actual and formal argument lists differ in length
duke@0 962 compiler.misc.inferred.do.not.conform.to.bounds=\
duke@0 963 inferred type argument(s) {0} do not conform to bounds of type variable(s) {1}
duke@0 964
duke@0 965 #####
duke@0 966
duke@0 967 ## The first argument ({0}) is a "kindname".
duke@0 968 compiler.err.abstract.cant.be.accessed.directly=\
duke@0 969 abstract {0} {1} in {2} cannot be accessed directly
duke@0 970
duke@0 971 ## The first argument ({0}) is a "kindname".
duke@0 972 compiler.err.non-static.cant.be.ref=\
duke@0 973 non-static {0} {1} cannot be referenced from a static context
duke@0 974
duke@0 975 ## Both arguments ({0}, {1}) are "kindname"s. {0} is a comma-separated list
duke@0 976 ## of kindnames (the list should be identical to that provided in source.
duke@0 977 compiler.err.unexpected.type=\
duke@0 978 unexpected type\n\
duke@0 979 required: {0}\n\
duke@0 980 found : {1}
duke@0 981
duke@0 982 ## The first argument ({0}) is a "kindname".
duke@0 983 compiler.err.cant.resolve=\
duke@0 984 cannot find symbol\n\
duke@0 985 symbol: {0} {3}{1}{2}
duke@0 986
duke@0 987 ## The first argument ({0}) and fifth argument ({4}) are "kindname"s.
duke@0 988 compiler.err.cant.resolve.location=\
duke@0 989 cannot find symbol\n\
duke@0 990 symbol : {0} {3}{1}{2}\n\
duke@0 991 location: {4} {5}
duke@0 992
duke@0 993 ## The following are all possible string for "kindname".
duke@0 994 ## They should be called whatever the JLS calls them after it been translated
duke@0 995 ## to the appropriate language.
duke@0 996 # compiler.misc.kindname.constructor=\
duke@0 997 # static member
duke@0 998 compiler.misc.kindname.annotation=\
duke@0 999 @interface
duke@0 1000 compiler.misc.kindname.constructor=\
duke@0 1001 constructor
duke@0 1002 compiler.misc.kindname.interface=\
duke@0 1003 interface
duke@0 1004 compiler.misc.kindname.static=\
duke@0 1005 static
duke@0 1006 compiler.misc.kindname.type.variable=\
duke@0 1007 type variable
duke@0 1008 compiler.misc.kindname.type.variable.bound=\
duke@0 1009 bound of type variable
duke@0 1010 compiler.misc.kindname=\
duke@0 1011 identifier({0})
duke@0 1012 compiler.misc.kindname.variable=\
duke@0 1013 variable
duke@0 1014 compiler.misc.kindname.value=\
duke@0 1015 value
duke@0 1016 compiler.misc.kindname.method=\
duke@0 1017 method
duke@0 1018 compiler.misc.kindname.variable.method=\
duke@0 1019 variable, method
duke@0 1020 compiler.misc.kindname.value.method=\
duke@0 1021 value, method
duke@0 1022 compiler.misc.kindname.class=\
duke@0 1023 class
duke@0 1024 compiler.misc.kindname.variable.class=\
duke@0 1025 variable, class
duke@0 1026 compiler.misc.kindname.value.class=\
duke@0 1027 value, class
duke@0 1028 compiler.misc.kindname.method.class=\
duke@0 1029 method, class
duke@0 1030 compiler.misc.kindname.variable.method.class=\
duke@0 1031 variable, method, class
duke@0 1032 compiler.misc.kindname.value.method.class=\
duke@0 1033 value, method, class
duke@0 1034 compiler.misc.kindname.package=\
duke@0 1035 package
duke@0 1036 compiler.misc.kindname.variable.package=\
duke@0 1037 variable, package
duke@0 1038 compiler.misc.kindname.value.package=\
duke@0 1039 value, package
duke@0 1040 compiler.misc.kindname.method.package=\
duke@0 1041 method, package
duke@0 1042 compiler.misc.kindname.variable.method.package=\
duke@0 1043 variable, method, package
duke@0 1044 compiler.misc.kindname.value.method.package=\
duke@0 1045 value, method, package
duke@0 1046 compiler.misc.kindname.class.package=\
duke@0 1047 class, package
duke@0 1048 compiler.misc.kindname.variable.class.package=\
duke@0 1049 variable, class, package
duke@0 1050 compiler.misc.kindname.value.class.package=\
duke@0 1051 value, class, package
duke@0 1052 compiler.misc.kindname.method.class.package=\
duke@0 1053 method, class, package
duke@0 1054 compiler.misc.kindname.variable.method.class.package=\
duke@0 1055 variable, method, class, package
duke@0 1056 compiler.misc.kindname.value.method.class.package=\
duke@0 1057 value, method, class, package
duke@0 1058
duke@0 1059 #####
duke@0 1060
duke@0 1061 compiler.err.override.static=\
duke@0 1062 {0}; overriding method is static
duke@0 1063 compiler.err.override.meth=\
duke@0 1064 {0}; overridden method is {1}
duke@0 1065
duke@0 1066 compiler.err.override.meth.doesnt.throw=\
duke@0 1067 {0}; overridden method does not throw {1}
duke@0 1068
duke@0 1069 # In the following string {1} is a space separated list of Java Keywords, as
duke@0 1070 # they would have been declared in the source code
duke@0 1071 compiler.err.override.weaker.access=\
duke@0 1072 {0}; attempting to assign weaker access privileges; was {1}
duke@0 1073
duke@0 1074 compiler.misc.override.incompatible.ret=\
duke@0 1075 {0}; attempting to use incompatible return type
duke@0 1076
duke@0 1077 compiler.misc.override.unchecked.ret=\
duke@0 1078 {0}; return type requires unchecked conversion
duke@0 1079
duke@0 1080 ## The following are all possible strings for the first argument ({0}) of the
duke@0 1081 ## above strings.
duke@0 1082 compiler.misc.cant.override=\
duke@0 1083 {0} in {1} cannot override {2} in {3}
duke@0 1084 compiler.misc.cant.implement=\
duke@0 1085 {0} in {1} cannot implement {2} in {3}
duke@0 1086 compiler.misc.clashes.with=\
duke@0 1087 {0} in {1} clashes with {2} in {3}
duke@0 1088 compiler.misc.unchecked.override=\
duke@0 1089 {0} in {1} overrides {2} in {3}
duke@0 1090 compiler.misc.unchecked.implement=\
duke@0 1091 {0} in {1} implements {2} in {3}
duke@0 1092 compiler.misc.unchecked.clash.with=\
duke@0 1093 {0} in {1} overrides {2} in {3}
duke@0 1094 compiler.misc.varargs.override=\
duke@0 1095 {0} in {1} overrides {2} in {3}
duke@0 1096 compiler.misc.varargs.implement=\
duke@0 1097 {0} in {1} implements {2} in {3}
duke@0 1098 compiler.misc.varargs.clash.with=\
duke@0 1099 {0} in {1} overrides {2} in {3}
duke@0 1100
duke@0 1101 ########################################
duke@0 1102 # Diagnostics for language feature changes
duke@0 1103 ########################################
duke@0 1104 compiler.err.unsupported.fp.lit=\
duke@0 1105 hexadecimal floating-point literals are not supported before -source 5
duke@0 1106
duke@0 1107 compiler.warn.enum.as.identifier=\
duke@0 1108 as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
duke@0 1109 (use -source 5 or higher to use ''enum'' as a keyword)
duke@0 1110
duke@0 1111 compiler.warn.assert.as.identifier=\
duke@0 1112 as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
duke@0 1113 (use -source 1.4 or higher to use ''assert'' as a keyword)
duke@0 1114
duke@0 1115 compiler.err.enum.as.identifier=\
duke@0 1116 as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\
duke@0 1117 (use -source 1.4 or lower to use ''enum'' as an identifier)
duke@0 1118
duke@0 1119 compiler.err.assert.as.identifier=\
duke@0 1120 as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\
duke@0 1121 (use -source 1.3 or lower to use ''assert'' as an identifier)
duke@0 1122
duke@0 1123 compiler.err.generics.not.supported.in.source=\
duke@0 1124 generics are not supported in -source {0}\n\
duke@0 1125 (use -source 5 or higher to enable generics)
duke@0 1126
duke@0 1127 compiler.err.varargs.not.supported.in.source=\
duke@0 1128 variable-arity methods are not supported in -source {0}\n\
duke@0 1129 (use -source 5 or higher to enable variable-arity methods)
duke@0 1130
duke@0 1131 compiler.err.annotations.not.supported.in.source=\
duke@0 1132 annotations are not supported in -source {0}\n\
duke@0 1133 (use -source 5 or higher to enable annotations)
duke@0 1134
duke@0 1135 compiler.err.foreach.not.supported.in.source=\
duke@0 1136 for-each loops are not supported in -source {0}\n\
duke@0 1137 (use -source 5 or higher to enable for-each loops)
duke@0 1138
duke@0 1139 compiler.err.static.import.not.supported.in.source=\
duke@0 1140 static import declarations are not supported in -source {0}\n\
duke@0 1141 (use -source 5 or higher to enable static import declarations)
duke@0 1142
duke@0 1143 compiler.err.enums.not.supported.in.source=\
duke@0 1144 enums are not supported in -source {0}\n\
duke@0 1145 (use -source 5 or higher to enable enums)