1 #

     2 # Copyright 1999-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4 #

     5 # This code is free software; you can redistribute it and/or modify it

     6 # under the terms of the GNU General Public License version 2 only, as

     7 # published by the Free Software Foundation.  Sun designates this

     8 # particular file as subject to the "Classpath" exception as provided

     9 # by Sun in the LICENSE file that accompanied this code.

    10 #

    11 # This code is distributed in the hope that it will be useful, but WITHOUT

    12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14 # version 2 for more details (a copy is included in the LICENSE file that

    15 # accompanied this code).

    16 #

    17 # You should have received a copy of the GNU General Public License version

    18 # 2 along with this work; if not, write to the Free Software Foundation,

    19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20 #

    21 # Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22 # CA 95054 USA or visit www.sun.com if you need additional information or

    23 # have any questions.

    24 #

    25 

    26 ##

    27 ## errors

    28 ##

    29 

    30 compiler.err.abstract.cant.be.instantiated=\

    31     {0} is abstract; cannot be instantiated

    32 compiler.err.abstract.meth.cant.have.body=\

    33     abstract methods cannot have a body

    34 compiler.err.already.annotated=\

    35     {0} {1} has already been annotated

    36 compiler.err.already.defined=\

    37     {0} is already defined in {1}

    38 compiler.err.already.defined.single.import=\

    39     {0} is already defined in a single-type import

    40 compiler.err.already.defined.static.single.import=\

    41     {0} is already defined in a static single-type import

    42 compiler.err.already.defined.this.unit=\

    43     {0} is already defined in this compilation unit

    44 compiler.err.annotation.missing.default.value=\

    45     annotation {0} is missing {1}

    46 compiler.err.annotation.not.valid.for.type=\

    47     annotation not valid for a value of type {0}

    48 compiler.err.annotation.type.not.applicable=\

    49     annotation type not applicable to this kind of declaration

    50 compiler.err.annotation.value.must.be.annotation=\

    51     annotation value must be an annotation

    52 compiler.err.annotation.value.must.be.class.literal=\

    53     annotation value must be a class literal

    54 compiler.err.annotation.value.must.be.name.value=\

    55     annotation values must be of the form ''name=value''

    56 compiler.err.annotation.value.not.allowable.type=\

    57     annotation value not of an allowable type

    58 compiler.err.anon.class.impl.intf.no.args=\

    59     anonymous class implements interface; cannot have arguments

    60 compiler.err.anon.class.impl.intf.no.typeargs=\

    61     anonymous class implements interface; cannot have type arguments

    62 compiler.err.anon.class.impl.intf.no.qual.for.new=\

    63     anonymous class implements interface; cannot have qualifier for new

    64 compiler.err.array.and.varargs=\

    65     cannot declare both {0} and {1} in {2}

    66 compiler.err.array.dimension.missing=\

    67     array dimension missing

    68 compiler.err.array.req.but.found=\

    69     array required, but {0} found

    70 

    71 compiler.err.assignment.from.super-bound=\

    72     assigning from wildcard {0}

    73 compiler.err.assignment.to.extends-bound=\

    74     assigning to wildcard {0}

    75 compiler.err.attribute.value.must.be.constant=\

    76     attribute value must be constant

    77 

    78 compiler.err.break.outside.switch.loop=\

    79     break outside switch or loop

    80 

    81 compiler.err.call.must.be.first.stmt.in.ctor=\

    82     call to {0} must be first statement in constructor

    83 compiler.err.cant.apply.symbol=\

    84     {0} in {1} cannot be applied to {2}({3})

    85 compiler.err.cant.apply.symbol.1=\

    86     {0} in {1} cannot be applied to {2}({3}); {4}

    87 compiler.err.cant.assign.val.to.final.var=\

    88     cannot assign a value to final variable {0}

    89 compiler.err.cant.deref=\

    90     {0} cannot be dereferenced

    91 compiler.err.cant.extend.intf.annotation=\

    92     ''extends'' not allowed for @interfaces

    93 compiler.err.cant.inherit.from.final=\

    94     cannot inherit from final {0}

    95 compiler.err.cant.ref.before.ctor.called=\

    96     cannot reference {0} before supertype constructor has been called

    97 compiler.err.cant.ret.val.from.meth.decl.void=\

    98     cannot return a value from method whose result type is void

    99 compiler.err.cant.select.static.class.from.param.type=\

   100     cannot select a static class from a parameterized type

   101 compiler.err.cant.inherit.diff.arg=\

   102     {0} cannot be inherited with different arguments: <{1}> and <{2}>

   103 compiler.err.catch.without.try=\

   104     ''catch'' without ''try''

   105 compiler.err.clash.with.pkg.of.same.name=\

   106     {0} clashes with package of same name

   107 compiler.err.const.expr.req=\

   108     constant expression required

   109 compiler.err.enum.const.req=\

   110     unqualified enumeration constant name required

   111 compiler.err.cont.outside.loop=\

   112     continue outside of loop

   113 compiler.err.cyclic.inheritance=\

   114     cyclic inheritance involving {0}

   115 compiler.err.cyclic.annotation.element=\

   116     cyclic annotation element type

   117 compiler.err.call.to.super.not.allowed.in.enum.ctor=\

   118     call to super not allowed in enum constructor

   119 compiler.err.no.superclass=\

   120     {0} has no superclass

   121 

   122 compiler.err.concrete.inheritance.conflict=\

   123     methods {0} from {1} and {2} from {3} are inherited with the same signature

   124 

   125 compiler.err.default.allowed.in.intf.annotation.member=\

   126     default value only allowed in an @interface member

   127 compiler.err.doesnt.exist=\

   128     package {0} does not exist

   129 compiler.err.duplicate.annotation=\

   130     duplicate annotation

   131 compiler.err.duplicate.annotation.member.value=\

   132     duplicate annotation member value {0} in {1}

   133 compiler.err.duplicate.class=\

   134     duplicate class: {0}

   135 compiler.err.duplicate.case.label=\

   136     duplicate case label

   137 compiler.err.duplicate.default.label=\

   138     duplicate default label

   139 

   140 compiler.err.else.without.if=\

   141     ''else'' without ''if''

   142 compiler.err.empty.char.lit=\

   143     empty character literal

   144 compiler.err.encl.class.required=\

   145     an enclosing instance that contains {0} is required

   146 compiler.err.enum.annotation.must.be.enum.constant=\

   147     an enum annotation value must be an enum constant

   148 

   149 compiler.err.enum.cant.be.instantiated=\

   150     enum types may not be instantiated

   151 compiler.err.enum.label.must.be.unqualified.enum=\

   152     an enum switch case label must be the unqualified name of an enumeration constant

   153 compiler.err.enum.no.subclassing=\

   154     classes cannot directly extend java.lang.Enum

   155 compiler.err.enum.types.not.extensible=\

   156     enum types are not extensible

   157 compiler.err.enum.no.finalize=\

   158     enums cannot have finalize methods

   159 compiler.err.error.reading.file=\

   160     error reading {0}; {1}

   161 compiler.err.except.already.caught=\

   162     exception {0} has already been caught

   163 compiler.err.except.never.thrown.in.try=\

   164     exception {0} is never thrown in body of corresponding try statement

   165 

   166 compiler.err.final.parameter.may.not.be.assigned=\

   167     final parameter {0} may not be assigned

   168 compiler.err.finally.without.try=\

   169     ''finally'' without ''try''

   170 compiler.err.foreach.not.applicable.to.type=\

   171     foreach not applicable to expression type

   172 compiler.err.fp.number.too.large=\

   173     floating point number too large

   174 compiler.err.fp.number.too.small=\

   175     floating point number too small

   176 

   177 compiler.err.generic.array.creation=\

   178     generic array creation

   179 compiler.err.generic.throwable=\

   180     a generic class may not extend java.lang.Throwable

   181 

   182 compiler.err.icls.cant.have.static.decl=\

   183     inner classes cannot have static declarations

   184 compiler.err.illegal.char=\

   185     illegal character: \\{0}

   186 compiler.err.illegal.char.for.encoding=\

   187     unmappable character for encoding {0}

   188 compiler.err.illegal.combination.of.modifiers=\

   189     illegal combination of modifiers: {0} and {1}

   190 compiler.err.illegal.enum.static.ref=\

   191     illegal reference to static field from initializer

   192 compiler.err.illegal.esc.char=\

   193     illegal escape character

   194 compiler.err.illegal.forward.ref=\

   195     illegal forward reference

   196 compiler.warn.forward.ref=\

   197     reference to variable ''{0}'' before it has been initialized

   198 compiler.err.illegal.generic.type.for.instof=\

   199     illegal generic type for instanceof

   200 compiler.err.illegal.initializer.for.type=\

   201     illegal initializer for {0}

   202 compiler.err.illegal.line.end.in.char.lit=\

   203     illegal line end in character literal

   204 compiler.err.illegal.nonascii.digit=\

   205     illegal non-ASCII digit

   206 compiler.err.illegal.qual.not.icls=\

   207     illegal qualifier; {0} is not an inner class

   208 compiler.err.illegal.start.of.expr=\

   209     illegal start of expression

   210 compiler.err.illegal.start.of.type=\

   211     illegal start of type

   212 compiler.err.illegal.unicode.esc=\

   213     illegal unicode escape

   214 compiler.err.import.requires.canonical=\

   215     import requires canonical name for {0}

   216 compiler.err.improperly.formed.type.param.missing=\

   217     improperly formed type, some parameters are missing

   218 compiler.err.improperly.formed.type.inner.raw.param=\

   219     improperly formed type, type parameters given on a raw type

   220 compiler.err.incomparable.types=\

   221     incomparable types: {0} and {1}

   222 compiler.err.int.number.too.large=\

   223     integer number too large: {0}

   224 compiler.err.internal.error.cant.instantiate=\

   225     internal error; cannot instantiate {0} at {1} to ({2})

   226 compiler.err.intf.annotation.members.cant.have.params=\

   227     @interface members may not have parameters

   228 compiler.err.intf.annotation.cant.have.type.params=\

   229     @interface may not have type parameters

   230 compiler.err.intf.annotation.members.cant.have.type.params=\

   231     @interface members may not have type parameters

   232 compiler.err.intf.annotation.member.clash=\

   233     @interface member clashes with method ''{0}'' in {1}

   234 compiler.err.intf.expected.here=\

   235     interface expected here

   236 compiler.err.intf.meth.cant.have.body=\

   237     interface methods cannot have body

   238 compiler.err.invalid.annotation.member.type=\

   239     invalid type for annotation member

   240 compiler.err.invalid.hex.number=\

   241     hexadecimal numbers must contain at least one hexadecimal digit

   242 compiler.err.invalid.meth.decl.ret.type.req=\

   243     invalid method declaration; return type required

   244 

   245 compiler.err.label.already.in.use=\

   246     label {0} already in use

   247 compiler.err.local.var.accessed.from.icls.needs.final=\

   248     local variable {0} is accessed from within inner class; needs to be declared final

   249 compiler.err.local.enum=\

   250     enum types must not be local

   251 compiler.err.cannot.create.array.with.type.arguments=\

   252     cannot create array with type arguments

   253 

   254 #

   255 # limits.  We don't give the limits in the diagnostic because we expect

   256 # them to change, yet we want to use the same diagnostic.  These are all

   257 # detected during code generation.

   258 #

   259 compiler.err.limit.code=\

   260     code too large

   261 compiler.err.limit.code.too.large.for.try.stmt=\

   262     code too large for try statement

   263 compiler.err.limit.dimensions=\

   264     array type has too many dimensions

   265 compiler.err.limit.locals=\

   266     too many local variables

   267 compiler.err.limit.parameters=\

   268     too many parameters

   269 compiler.err.limit.pool=\

   270     too many constants

   271 compiler.err.limit.pool.in.class=\

   272     too many constants in class {0}

   273 compiler.err.limit.stack=\

   274     code requires too much stack

   275 compiler.err.limit.string=\

   276     constant string too long

   277 compiler.err.limit.string.overflow=\

   278     UTF8 representation for string \"{0}...\" is too long for the constant pool

   279 

   280 compiler.err.malformed.fp.lit=\

   281     malformed floating point literal

   282 compiler.err.method.does.not.override.superclass=\

   283     method does not override or implement a method from a supertype

   284 compiler.err.missing.meth.body.or.decl.abstract=\

   285     missing method body, or declare abstract

   286 compiler.err.missing.ret.stmt=\

   287     missing return statement

   288 compiler.err.missing.ret.val=\

   289     missing return value

   290 compiler.err.mod.not.allowed.here=\

   291     modifier {0} not allowed here

   292 compiler.err.intf.not.allowed.here=\

   293     interface not allowed here

   294 compiler.err.enums.must.be.static=\

   295     enum declarations allowed only in static contexts

   296 

   297 compiler.err.name.clash.same.erasure=\

   298     name clash: {0} and {1} have the same erasure

   299 compiler.err.name.clash.same.erasure.no.override=\

   300     name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither overrides the other

   301 compiler.err.name.reserved.for.internal.use=\

   302     {0} is reserved for internal use

   303 compiler.err.native.meth.cant.have.body=\

   304     native methods cannot have a body

   305 compiler.err.neither.conditional.subtype=\

   306 incompatible types for ?: neither is a subtype of the other\n\

   307 second operand: {0}\n\

   308 third operand : {1}

   309 compiler.err.new.not.allowed.in.annotation=\

   310     ''new'' not allowed in an annotation

   311 compiler.err.no.annotation.member=\

   312     no annotation member {0} in {1}

   313 compiler.err.no.encl.instance.of.type.in.scope=\

   314     no enclosing instance of type {0} is in scope

   315 compiler.err.no.intf.expected.here=\

   316     no interface expected here

   317 compiler.err.no.match.entry=\

   318     {0} has no match in entry in {1}; required {2}

   319 compiler.err.not.annotation.type=\

   320     {0} is not an annotation type

   321 compiler.err.not.def.access.class.intf.cant.access=\

   322     {0} in {1} is defined in an inaccessible class or interface

   323 compiler.err.not.def.public.cant.access=\

   324     {0} is not public in {1}; cannot be accessed from outside package

   325 compiler.err.not.loop.label=\

   326     not a loop label: {0}

   327 compiler.err.not.stmt=\

   328     not a statement

   329 compiler.err.not.encl.class=\

   330     not an enclosing class: {0}

   331 

   332 compiler.err.operator.cant.be.applied=\

   333     operator {0} cannot be applied to {1}

   334 

   335 compiler.err.pkg.annotations.sb.in.package-info.java=\

   336     package annotations should be in file package-info.java

   337 compiler.err.pkg.clashes.with.class.of.same.name=\

   338     package {0} clashes with class of same name

   339 

   340 # Errors related to annotation processing

   341 

   342 compiler.err.proc.cant.access=\

   343 cannot access {0}\n\

   344 {1}\n\

   345 Consult the following stack trace for details.\n\

   346 {2}

   347 

   348 compiler.err.proc.cant.find.class=\

   349     Could not find class file for ''{0}''.

   350 

   351 # Print a client-generated error message; assumed to be localized, no translation required

   352 compiler.err.proc.messager=\

   353     {0}

   354 

   355 compiler.err.proc.no.explicit.annotation.processing.requested=\

   356     Class names, ''{0}'', are only accepted if annotation processing is explicitly requested

   357 

   358 compiler.err.proc.no.service=\

   359     A service loader class could not be found.\n\

   360     Either java.util.ServiceLoader or sun.misc.Service must be available.

   361 

   362 compiler.err.proc.processor.bad.option.name=\

   363     Bad option name ''{0}'' provided by processor ''{1}''

   364 

   365 compiler.err.proc.processor.cant.instantiate=\

   366     Could not instantiate an instance of processor ''{0}''

   367 

   368 compiler.err.proc.processor.constructor.error=\

   369     Exception thrown while constructing Processor object: {0}

   370 

   371 compiler.err.proc.processor.not.found=\

   372     Annotation processor ''{0}'' not found

   373 

   374 compiler.err.proc.processor.wrong.type=\

   375     Annotation processor ''{0}'' does not implement javax.annotation.processing.Processor

   376 

   377 compiler.err.proc.service.problem=\

   378     Error creating a service loader to load Processors.

   379 

   380 compiler.err.proc.bad.config.file=\

   381     Bad service configuration file, or exception thrown while constructing Processor object: {0}

   382 

   383 compiler.err.proc.cant.create.loader=\

   384     Could not create class loader for annotation processors: {0}

   385 

   386 compiler.err.qualified.new.of.static.class=\

   387     qualified new of static class

   388 

   389 compiler.err.recursive.ctor.invocation=\

   390     recursive constructor invocation

   391 compiler.err.ref.ambiguous=\

   392     reference to {0} is ambiguous, both {1} {2} in {3} and {4} {5} in {6} match

   393 compiler.err.repeated.annotation.target=\

   394     repeated annotation target

   395 compiler.err.repeated.interface=\

   396     repeated interface

   397 compiler.err.repeated.modifier=\

   398     repeated modifier

   399 compiler.err.report.access=\

   400     {0} has {1} access in {2}

   401 compiler.err.ret.outside.meth=\

   402     return outside method

   403 

   404 compiler.err.signature.doesnt.match.supertype=\

   405     signature does not match {0}; incompatible supertype

   406 compiler.err.signature.doesnt.match.intf=\

   407     signature does not match {0}; incompatible interfaces

   408 compiler.err.does.not.override.abstract=\

   409     {0} is not abstract and does not override abstract method {1} in {2}

   410 compiler.err.source.cant.overwrite.input.file=\

   411     error writing source; cannot overwrite input file {0}

   412 compiler.err.stack.sim.error=\

   413     Internal error: stack sim error on {0}

   414 compiler.err.static.imp.only.classes.and.interfaces=\

   415     static import only from classes and interfaces

   416 compiler.err.synthetic.name.conflict=\

   417     the symbol {0} conflicts with a compiler-synthesized symbol in {1}

   418 

   419 compiler.err.throws.not.allowed.in.intf.annotation=\

   420     throws clause not allowed in @interface members

   421 compiler.err.try.without.catch.or.finally=\

   422     ''try'' without ''catch'' or ''finally''

   423 compiler.err.type.doesnt.take.params=\

   424     type {0} does not take parameters

   425 compiler.err.type.var.cant.be.deref=\

   426     cannot select from a type variable

   427 compiler.err.type.var.may.not.be.followed.by.other.bounds=\

   428     a type variable may not be followed by other bounds

   429 compiler.err.type.var.more.than.once=\

   430     type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated

   431 compiler.err.type.var.more.than.once.in.result=\

   432     type variable {0} occurs more than once in type of {1}; cannot be left uninstantiated

   433 compiler.err.types.incompatible.diff.ret=\

   434     types {0} and {1} are incompatible; both define {2}, but with unrelated return types

   435 

   436 compiler.err.unclosed.char.lit=\

   437     unclosed character literal

   438 compiler.err.unclosed.comment=\

   439     unclosed comment

   440 compiler.err.unclosed.str.lit=\

   441     unclosed string literal

   442 compiler.err.unknown.enum.constant=\

   443     in class file {0}: unknown enum constant {1}.{2}

   444 compiler.err.unsupported.encoding=\

   445     unsupported encoding: {0}

   446 compiler.err.io.exception=\

   447     error reading source file: {0}

   448 compiler.err.undef.label=\

   449     undefined label: {0}

   450 compiler.err.undetermined.type=\

   451     type parameters of {0} cannot be determined

   452 compiler.err.undetermined.type.1=\

   453     type parameters of {0} cannot be determined; {1}

   454 compiler.err.unreachable.stmt=\

   455     unreachable statement

   456 compiler.err.initializer.must.be.able.to.complete.normally=\

   457     initializer must be able to complete normally

   458 compiler.err.unreported.exception.need.to.catch.or.throw=\

   459     unreported exception {0}; must be caught or declared to be thrown

   460 compiler.err.unreported.exception.default.constructor=\

   461     unreported exception {0} in default constructor

   462 compiler.err.unsupported.cross.fp.lit=\

   463     hexadecimal floating-point literals are not supported on this VM

   464 compiler.err.void.not.allowed.here=\

   465     ''void'' type not allowed here

   466 

   467 compiler.err.wrong.number.type.args=\

   468     wrong number of type arguments; required {0}

   469 

   470 compiler.err.var.might.already.be.assigned=\

   471     variable {0} might already have been assigned

   472 compiler.err.var.might.not.have.been.initialized=\

   473     variable {0} might not have been initialized

   474 compiler.err.var.might.be.assigned.in.loop=\

   475     variable {0} might be assigned in loop

   476 

   477 # In the following string, {1} will always be the detail message from

   478 # java.io.IOException.

   479 compiler.err.class.cant.write=\

   480     error while writing {0}: {1}

   481 

   482 # In the following string, {0} is the name of the class in the Java source.

   483 # It really should be used two times..

   484 compiler.err.class.public.should.be.in.file=\

   485     class {0} is public, should be declared in a file named {0}.java

   486 

   487 ## All errors which do not refer to a particular line in the source code are

   488 ## preceded by this string.

   489 compiler.err.error=\

   490     error:\u0020

   491 

   492 # The following error messages do not refer to a line in the source code.

   493 compiler.err.cant.read.file=\

   494     cannot read: {0}

   495 

   496 #####

   497 

   498 # Fatal Errors

   499 

   500 compiler.misc.fatal.err.no.java.lang=\

   501     Fatal Error: Unable to find package java.lang in classpath or bootclasspath

   502 compiler.misc.fatal.err.cant.locate.meth=\

   503     Fatal Error: Unable to find method {0}

   504 compiler.misc.fatal.err.cant.locate.field=\

   505     Fatal Error: Unable to find field {0}

   506 compiler.misc.fatal.err.cant.locate.ctor=\

   507     Fatal Error: Unable to find constructor for {0}

   508 

   509 #####

   510 

   511 ##

   512 ## miscellaneous strings

   513 ##

   514 

   515 compiler.misc.source.unavailable=\

   516     (source unavailable)

   517 compiler.misc.base.membership=\

   518     all your base class are belong to us

   519 compiler.misc.x.print.processor.info=\

   520     Processor {0} matches {1} and returns {2}.

   521 compiler.misc.x.print.rounds=\

   522     Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}

   523 

   524 #####

   525 

   526 ## The following string will appear before all messages keyed as:

   527 ## "compiler.note".

   528 compiler.note.note=\

   529     Note:\u0020

   530 

   531 compiler.note.deprecated.filename=\

   532     {0} uses or overrides a deprecated API.

   533 compiler.note.deprecated.plural=\

   534     Some input files use or override a deprecated API.

   535 # The following string may appear after one of the above deprecation

   536 # messages.

   537 compiler.note.deprecated.recompile=\

   538     Recompile with -Xlint:deprecation for details.

   539 

   540 compiler.note.deprecated.filename.additional=\

   541     {0} has additional uses or overrides of a deprecated API.

   542 compiler.note.deprecated.plural.additional=\

   543     Some input files additionally use or override a deprecated API.

   544 

   545 # Notes related to annotation processing

   546 

   547 # Print a client-generated note; assumed to be localized, no translation required

   548 compiler.note.proc.messager=\

   549     {0}

   550 

   551 compiler.note.unchecked.filename=\

   552     {0} uses unchecked or unsafe operations.

   553 compiler.note.unchecked.plural=\

   554     Some input files use unchecked or unsafe operations.

   555 # The following string may appear after one of the above deprecation

   556 # messages.

   557 compiler.note.unchecked.recompile=\

   558     Recompile with -Xlint:unchecked for details.

   559 

   560 compiler.note.unchecked.filename.additional=\

   561     {0} has additional unchecked or unsafe operations.

   562 compiler.note.unchecked.plural.additional=\

   563     Some input files additionally use unchecked or unsafe operations.

   564 

   565 #####

   566 

   567 compiler.misc.count.error=\

   568     {0} error

   569 compiler.misc.count.error.plural=\

   570     {0} errors

   571 compiler.misc.count.warn=\

   572     {0} warning

   573 compiler.misc.count.warn.plural=\

   574     {0} warnings

   575 

   576 ## extra output when using -verbose (JavaCompiler)

   577 

   578 compiler.misc.verbose.checking.attribution=\

   579     [checking {0}]

   580 compiler.misc.verbose.parsing.done=\

   581     [parsing completed {0}ms]

   582 compiler.misc.verbose.parsing.started=\

   583     [parsing started {0}]

   584 compiler.misc.verbose.total=\

   585     [total {0}ms]

   586 compiler.misc.verbose.wrote.file=\

   587     [wrote {0}]

   588 

   589 ## extra output when using -verbose (Retro)

   590 compiler.misc.verbose.retro=\

   591     [retrofitting {0}]

   592 compiler.misc.verbose.retro.with=\

   593     \tretrofitting {0} with {1}

   594 compiler.misc.verbose.retro.with.list=\

   595     \tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}

   596 

   597 ## extra output when using -verbose (code/ClassReader)

   598 compiler.misc.verbose.loading=\

   599     [loading {0}]

   600 

   601 compiler.misc.verbose.sourcepath=\

   602     [search path for source files: {0}]

   603 

   604 compiler.misc.verbose.classpath=\

   605     [search path for class files: {0}]

   606 

   607 ## extra output when using -checkclassfile (code/ClassReader)

   608 compiler.misc.ccf.found.later.version=\

   609     class file has later version than expected: {0}

   610 compiler.misc.ccf.unrecognized.attribute=\

   611     unrecognized attribute: {0}

   612 

   613 ## extra output when using -prompt (util/Log)

   614 compiler.misc.resume.abort=\

   615     R)esume, A)bort>

   616 

   617 #####

   618 

   619 ##

   620 ## warnings

   621 ##

   622 

   623 ## All warning messages are preceded by the following string.

   624 compiler.warn.warning=\

   625     warning:\u0020

   626 

   627 compiler.warn.constant.SVUID=\

   628     [serial] serialVersionUID must be constant in class {0}

   629 

   630 compiler.warn.dir.path.element.not.found=\

   631     [path] bad path element "{0}": no such directory

   632 

   633 compiler.warn.finally.cannot.complete=\

   634     [finally] finally clause cannot complete normally

   635 

   636 compiler.warn.has.been.deprecated=\

   637     [deprecation] {0} in {1} has been deprecated

   638 

   639 compiler.warn.sun.proprietary=\

   640     {0} is Sun proprietary API and may be removed in a future release

   641 

   642 compiler.warn.illegal.char.for.encoding=\

   643     unmappable character for encoding {0}

   644 compiler.warn.improper.SVUID=\

   645     [serial] serialVersionUID must be declared static final in class {0}

   646 

   647 compiler.warn.inexact.non-varargs.call=\

   648 non-varargs call of varargs method with inexact argument type for last parameter;\n\

   649 cast to {0} for a varargs call\n\

   650 cast to {1} for a non-varargs call and to suppress this warning

   651 

   652 compiler.warn.long.SVUID=\

   653     [serial] serialVersionUID must be of type long in class {0}

   654 

   655 compiler.warn.missing.SVUID=\

   656     [serial] serializable class {0} has no definition of serialVersionUID

   657 

   658 compiler.warn.override.varargs.missing=\

   659     {0}; overridden method has no ''...''

   660 compiler.warn.override.varargs.extra=\

   661     {0}; overriding method is missing ''...''

   662 compiler.warn.override.bridge=\

   663     {0}; overridden method is a bridge method

   664 

   665 compiler.warn.pkg-info.already.seen=\

   666     [package-info] a package-info.java file has already been seen for package {0}

   667 compiler.warn.path.element.not.found=\

   668     [path] bad path element "{0}": no such file or directory

   669 compiler.warn.possible.fall-through.into.case=\

   670     [fallthrough] possible fall-through into case

   671 

   672 compiler.warn.redundant.cast=\

   673     [cast] redundant cast to {0}

   674 

   675 compiler.warn.position.overflow=\

   676     Position encoding overflows at line {0}

   677 

   678 compiler.warn.big.major.version=\

   679     {0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\n\

   680     It is recommended that the compiler be upgraded.

   681 

   682 # Warnings related to annotation processing

   683 compiler.warn.proc.package.does.not.exist=\

   684     package {0} does not exist

   685 compiler.warn.proc.file.reopening=\

   686     Attempt to create a file for ''{0}'' multiple times

   687 

   688 compiler.warn.proc.type.already.exists=\

   689     A file for type ''{0}'' already exists on the sourcepath or classpath

   690 

   691 compiler.warn.proc.type.recreate=\

   692     Attempt to create a file for type ''{0}'' multiple times

   693 

   694 compiler.warn.proc.illegal.file.name=\

   695     Cannot create file for illegal name ''{0}''.

   696 

   697 compiler.warn.proc.file.create.last.round=\

   698     File for type ''{0}'' created in the last round will not be subject to annotation processing.

   699 

   700 compiler.warn.proc.malformed.supported.string=\

   701     Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''

   702 

   703 compiler.warn.proc.annotations.without.processors=\

   704     No processor claimed any of these annotations: {0}

   705 

   706 compiler.warn.proc.processor.incompatible.source.version=\

   707     Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''

   708 

   709 compiler.warn.proc.proc-only.requested.no.procs=\

   710     Annotation processing without compilation requested but no processors were found.

   711 

   712 compiler.warn.proc.use.implicit=\

   713 Implicitly compiled files were not subject to annotation processing.\n\

   714 Use -implicit to specify a policy for implicit compilation.

   715 

   716 compiler.warn.proc.use.proc.or.implicit=\

   717 Implicitly compiled files were not subject to annotation processing.\n\

   718 Use -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation.

   719 

   720 # Print a client-generated warning; assumed to be localized, no translation required

   721 compiler.warn.proc.messager=\

   722     {0}

   723 

   724 compiler.warn.proc.unclosed.type.files=\

   725     Unclosed files for the types ''{0}''; these types will not undergo annotation processing

   726 

   727 compiler.warn.proc.unmatched.processor.options=\

   728     The following options were not recognized by any processor: ''{0}''

   729 

   730 compiler.warn.unchecked.assign=\

   731     [unchecked] unchecked assignment: {0} to {1}

   732 compiler.warn.unchecked.assign.to.var=\

   733     [unchecked] unchecked assignment to variable {0} as member of raw type {1}

   734 compiler.warn.unchecked.call.mbr.of.raw.type=\

   735     [unchecked] unchecked call to {0} as a member of the raw type {1}

   736 compiler.warn.unchecked.cast.to.type=\

   737     [unchecked] unchecked cast to type {0}

   738 compiler.warn.unchecked.meth.invocation.applied=\

   739     [unchecked] unchecked method invocation: {0} in {1} is applied to {2}({3})

   740 compiler.warn.unchecked.generic.array.creation=\

   741     [unchecked] unchecked generic array creation of type {0} for varargs parameter

   742 

   743 compiler.warn.missing.deprecated.annotation=\

   744     [dep-ann] deprecated item is not annotated with @Deprecated

   745 

   746 compiler.warn.invalid.archive.file=\

   747     [path] Unexpected file on path: {0}

   748 

   749 compiler.warn.unexpected.archive.file=\

   750     [path] Unexpected extension for archive file: {0}

   751 

   752 compiler.warn.div.zero=\

   753     [divzero] division by zero

   754 

   755 compiler.warn.empty.if=\

   756     [empty] empty statement after if

   757 

   758 compiler.warn.annotation.method.not.found=\

   759     Cannot find annotation method ''{1}()'' in type ''{0}''

   760 

   761 compiler.warn.annotation.method.not.found.reason=\

   762     Cannot find annotation method ''{1}()'' in type ''{0}'': {2}

   763 

   764 #####

   765 

   766 ## The following are tokens which are non-terminals in the language. They should

   767 ## be named as JLS3 calls them when translated to the appropriate language.

   768 compiler.misc.token.identifier=\

   769     <identifier>

   770 compiler.misc.token.character=\

   771     <character>

   772 compiler.misc.token.string=\

   773     <string>

   774 compiler.misc.token.integer=\

   775     <integer>

   776 compiler.misc.token.long-integer=\

   777     <long integer>

   778 compiler.misc.token.float=\

   779     <float>

   780 compiler.misc.token.double=\

   781     <double>

   782 compiler.misc.token.bad-symbol=\

   783     <bad symbol>

   784 compiler.misc.token.end-of-input=\

   785     <end of input>

   786 

   787 ## The argument to the following string will always be one of the following:

   788 ## 1. one of the above non-terminals

   789 ## 2. a keyword (JLS1.8)

   790 ## 3. a boolean literal (JLS3.10.3)

   791 ## 4. the null literal (JLS3.10.7)

   792 ## 5. a Java separator (JLS3.11)

   793 ## 6. an operator (JLS3.12)

   794 ##

   795 ## This is the only place these tokens will be used.

   796 compiler.err.expected=\

   797     {0} expected

   798 compiler.err.expected2=\

   799     {0} or {1} expected

   800 compiler.err.expected3=\

   801     {0}, {1}, or {2} expected

   802 

   803 compiler.err.premature.eof=\

   804     reached end of file while parsing

   805 

   806 ## The following are related in form, but do not easily fit the above paradigm.

   807 compiler.err.dot.class.expected=\

   808     ''.class'' expected

   809 

   810 ## The argument to this string will always be either 'case' or 'default'.

   811 compiler.err.orphaned=\

   812     orphaned {0}

   813 

   814 compiler.misc.anonymous.class=\

   815     <anonymous {0}>

   816 

   817 compiler.misc.unnamed.package=\

   818     unnamed package

   819 

   820 #####

   821 

   822 compiler.err.cant.access=\

   823 cannot access {0}\n\

   824 {1}

   825 

   826 compiler.misc.bad.class.file.header=\

   827 bad class file: {0}\n\

   828 {1}\n\

   829 Please remove or make sure it appears in the correct subdirectory of the classpath.

   830 

   831 ## The following are all possible strings for the second argument ({1}) of the

   832 ## above strings.

   833 compiler.misc.bad.class.signature=\

   834     bad class signature: {0}

   835 compiler.misc.bad.enclosing.method=\

   836     bad enclosing method attribute: {0}

   837 compiler.misc.bad.runtime.invisible.param.annotations=\

   838     bad RuntimeInvisibleParameterAnnotations attribute: {0}

   839 compiler.misc.bad.const.pool.tag=\

   840     bad constant pool tag: {0}

   841 compiler.misc.bad.const.pool.tag.at=\

   842     bad constant pool tag: {0} at {1}

   843 compiler.misc.bad.signature=\

   844     bad signature: {0}

   845 compiler.misc.class.file.wrong.class=\

   846     class file contains wrong class: {0}

   847 compiler.misc.class.file.not.found=\

   848     class file for {0} not found

   849 compiler.misc.file.doesnt.contain.class=\

   850     file does not contain class {0}

   851 compiler.misc.file.does.not.contain.package=\

   852     file does not contain package {0}

   853 compiler.misc.illegal.start.of.class.file=\

   854     illegal start of class file

   855 compiler.misc.unable.to.access.file=\

   856     unable to access file: {0}

   857 compiler.misc.unicode.str.not.supported=\

   858     unicode string in class file not supported

   859 compiler.misc.undecl.type.var=\

   860     undeclared type variable: {0}

   861 compiler.misc.wrong.version=\

   862     class file has wrong version {0}.{1}, should be {2}.{3}

   863 

   864 #####

   865 

   866 compiler.err.not.within.bounds=\

   867     type parameter {0} is not within its bound

   868 

   869 compiler.err.not.within.bounds.explain=\

   870     type parameter {0} is not within its bound; {1}

   871 

   872 ## The following are all possible strings for the second argument ({1}) of the

   873 ## above string.

   874 

   875 ## none yet...

   876 

   877 #####

   878 

   879 compiler.err.prob.found.req=\

   880 {0}\n\

   881 found   : {1}\n\

   882 required: {2}

   883 compiler.warn.prob.found.req=\

   884 {0}\n\

   885 found   : {1}\n\

   886 required: {2}

   887 compiler.err.prob.found.req.1=\

   888 {0} {3}\n\

   889 found   : {1}\n\

   890 required: {2}

   891 

   892 ## The following are all possible strings for the first argument ({0}) of the

   893 ## above strings.

   894 compiler.misc.incompatible.types=\

   895     incompatible types

   896 compiler.misc.incompatible.types.1=\

   897     incompatible types; {0}

   898 compiler.misc.inconvertible.types=\

   899     inconvertible types

   900 compiler.misc.possible.loss.of.precision=\

   901     possible loss of precision

   902 

   903 compiler.misc.unchecked.assign=\

   904     [unchecked] unchecked conversion

   905 # compiler.misc.storecheck=\

   906 #     [unchecked] assignment might cause later store checks to fail

   907 # compiler.misc.unchecked=\

   908 #     [unchecked] assigned array cannot dynamically check its stores

   909 compiler.misc.unchecked.cast.to.type=\

   910     [unchecked] unchecked cast

   911 

   912 compiler.misc.assignment.from.super-bound=\

   913     assignment from super-bound type {0}

   914 compiler.misc.assignment.to.extends-bound=\

   915     assignment to extends-bound type {0}

   916 # compiler.err.star.expected=\

   917 #     ''*'' expected

   918 # compiler.err.no.elem.type=\

   919 #     \[\*\] cannot have a type

   920 

   921 #####

   922 

   923 compiler.err.type.found.req=\

   924 unexpected type\n\

   925 found   : {0}\n\

   926 required: {1}

   927 

   928 ## The following are all possible strings for the first argument ({0}) of the

   929 ## above string.

   930 compiler.misc.type.req.class=\

   931     class

   932 compiler.misc.type.req.class.array=\

   933     class or array

   934 compiler.misc.type.req.ref=\

   935     reference

   936 compiler.misc.type.req.exact=\

   937     class or interface without bounds

   938 compiler.misc.type.parameter=\

   939     type parameter {0} 

   940 

   941 #####

   942 

   943 ## The following are all possible strings for the last argument of all those

   944 ## diagnostics whose key ends in ".1"

   945 compiler.misc.undetermined.type=\

   946     undetermined type

   947 ncompiler.misc.type.variable.has.undetermined.type=\

   948     type variable {0} has undetermined type

   949 compiler.misc.no.unique.maximal.instance.exists=\

   950     no unique maximal instance exists for type variable {0} with upper bounds {1}

   951 compiler.misc.no.unique.minimal.instance.exists=\

   952     no unique minimal instance exists for type variable {0} with lower bounds {1}

   953 compiler.misc.no.conforming.instance.exists=\

   954     no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}

   955 compiler.misc.no.conforming.assignment.exists=\

   956     no instance(s) of type variable(s) {0} exist so that argument type {1} conforms to formal parameter type {2}

   957 compiler.misc.arg.length.mismatch=\

   958     cannot instantiate from arguments because actual and formal argument lists differ in length

   959 compiler.misc.inferred.do.not.conform.to.bounds=\

   960     inferred type argument(s) {0} do not conform to bounds of type variable(s) {1}

   961 

   962 #####

   963 

   964 ## The first argument ({0}) is a "kindname".

   965 compiler.err.abstract.cant.be.accessed.directly=\

   966     abstract {0} {1} in {2} cannot be accessed directly

   967 

   968 ## The first argument ({0}) is a "kindname".

   969 compiler.err.non-static.cant.be.ref=\

   970     non-static {0} {1} cannot be referenced from a static context

   971 

   972 ## Both arguments ({0}, {1}) are "kindname"s.  {0} is a comma-separated list

   973 ## of kindnames (the list should be identical to that provided in source.

   974 compiler.err.unexpected.type=\

   975 unexpected type\n\

   976 required: {0}\n\

   977 found   : {1}

   978 

   979 ## The first argument ({0}) is a "kindname".

   980 compiler.err.cant.resolve=\

   981 cannot find symbol\n\

   982 symbol: {0} {3}{1}{2}

   983 

   984 ## The first argument ({0}) and fifth argument ({4}) are "kindname"s.

   985 compiler.err.cant.resolve.location=\

   986 cannot find symbol\n\

   987 symbol  : {0} {3}{1}{2}\n\

   988 location: {4} {5}

   989 

   990 ## The following are all possible string for "kindname".

   991 ## They should be called whatever the JLS calls them after it been translated

   992 ## to the appropriate language.

   993 # compiler.misc.kindname.constructor=\

   994 #     static member

   995 compiler.misc.kindname.annotation=\

   996     @interface

   997 compiler.misc.kindname.constructor=\

   998     constructor

   999 compiler.misc.kindname.interface=\

  1000     interface

  1001 compiler.misc.kindname.static=\

  1002     static

  1003 compiler.misc.kindname.type.variable=\

  1004     type variable

  1005 compiler.misc.kindname.type.variable.bound=\

  1006     bound of type variable

  1007 compiler.misc.kindname=\

  1008     identifier({0})

  1009 compiler.misc.kindname.variable=\

  1010     variable

  1011 compiler.misc.kindname.value=\

  1012     value

  1013 compiler.misc.kindname.method=\

  1014     method

  1015 compiler.misc.kindname.variable.method=\

  1016     variable, method

  1017 compiler.misc.kindname.value.method=\

  1018     value, method

  1019 compiler.misc.kindname.class=\

  1020     class

  1021 compiler.misc.kindname.variable.class=\

  1022     variable, class

  1023 compiler.misc.kindname.value.class=\

  1024     value, class

  1025 compiler.misc.kindname.method.class=\

  1026     method, class

  1027 compiler.misc.kindname.variable.method.class=\

  1028     variable, method, class

  1029 compiler.misc.kindname.value.method.class=\

  1030     value, method, class

  1031 compiler.misc.kindname.package=\

  1032     package

  1033 compiler.misc.kindname.variable.package=\

  1034     variable, package

  1035 compiler.misc.kindname.value.package=\

  1036     value, package

  1037 compiler.misc.kindname.method.package=\

  1038     method, package

  1039 compiler.misc.kindname.variable.method.package=\

  1040     variable, method, package

  1041 compiler.misc.kindname.value.method.package=\

  1042     value, method, package

  1043 compiler.misc.kindname.class.package=\

  1044     class, package

  1045 compiler.misc.kindname.variable.class.package=\

  1046     variable, class, package

  1047 compiler.misc.kindname.value.class.package=\

  1048     value, class, package

  1049 compiler.misc.kindname.method.class.package=\

  1050     method, class, package

  1051 compiler.misc.kindname.variable.method.class.package=\

  1052     variable, method, class, package

  1053 compiler.misc.kindname.value.method.class.package=\

  1054     value, method, class, package

  1055 

  1056 #####

  1057 

  1058 compiler.err.override.static=\

  1059     {0}; overriding method is static

  1060 compiler.err.override.meth=\

  1061     {0}; overridden method is {1}

  1062 

  1063 compiler.err.override.meth.doesnt.throw=\

  1064     {0}; overridden method does not throw {1}

  1065 

  1066 # In the following string {1} is a space separated list of Java Keywords, as

  1067 # they would have been declared in the source code

  1068 compiler.err.override.weaker.access=\

  1069     {0}; attempting to assign weaker access privileges; was {1}

  1070 

  1071 compiler.misc.override.incompatible.ret=\

  1072     {0}; attempting to use incompatible return type

  1073 

  1074 compiler.misc.override.unchecked.ret=\

  1075     {0}; return type requires unchecked conversion

  1076 

  1077 ## The following are all possible strings for the first argument ({0}) of the

  1078 ## above strings.

  1079 compiler.misc.cant.override=\

  1080     {0} in {1} cannot override {2} in {3}

  1081 compiler.misc.cant.implement=\

  1082     {0} in {1} cannot implement {2} in {3}

  1083 compiler.misc.clashes.with=\

  1084     {0} in {1} clashes with {2} in {3}

  1085 compiler.misc.unchecked.override=\

  1086     {0} in {1} overrides {2} in {3}

  1087 compiler.misc.unchecked.implement=\

  1088     {0} in {1} implements {2} in {3}

  1089 compiler.misc.unchecked.clash.with=\

  1090     {0} in {1} overrides {2} in {3}

  1091 compiler.misc.varargs.override=\

  1092     {0} in {1} overrides {2} in {3}

  1093 compiler.misc.varargs.implement=\

  1094     {0} in {1} implements {2} in {3}

  1095 compiler.misc.varargs.clash.with=\

  1096     {0} in {1} overrides {2} in {3}

  1097 

  1098 ########################################

  1099 # Diagnostics for language feature changes

  1100 ########################################

  1101 compiler.err.unsupported.fp.lit=\

  1102     hexadecimal floating-point literals are not supported before -source 5

  1103 

  1104 compiler.warn.enum.as.identifier=\

  1105     as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\

  1106 (use -source 5 or higher to use ''enum'' as a keyword)

  1107 

  1108 compiler.warn.assert.as.identifier=\

  1109     as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\

  1110 (use -source 1.4 or higher to use ''assert'' as a keyword)

  1111 

  1112 compiler.err.enum.as.identifier=\

  1113     as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n\

  1114 (use -source 1.4 or lower to use ''enum'' as an identifier)

  1115 

  1116 compiler.err.assert.as.identifier=\

  1117     as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n\

  1118 (use -source 1.3 or lower to use ''assert'' as an identifier)

  1119 

  1120 compiler.err.generics.not.supported.in.source=\

  1121     generics are not supported in -source {0}\n\

  1122 (use -source 5 or higher to enable generics)

  1123 

  1124 compiler.err.varargs.not.supported.in.source=\

  1125     variable-arity methods are not supported in -source {0}\n\

  1126 (use -source 5 or higher to enable variable-arity methods)

  1127 

  1128 compiler.err.annotations.not.supported.in.source=\

  1129     annotations are not supported in -source {0}\n\

  1130 (use -source 5 or higher to enable annotations)

  1131 

  1132 compiler.err.foreach.not.supported.in.source=\

  1133     for-each loops are not supported in -source {0}\n\

  1134 (use -source 5 or higher to enable for-each loops)

  1135