#

# Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.

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

#

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

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

# published by the Free Software Foundation.  Oracle designates this

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

# by Oracle in the LICENSE file that accompanied this code.

#

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

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

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

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

# accompanied this code).

#

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

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

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

#

# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

# or visit www.oracle.com if you need additional information or have any

# questions.

#

##

## errors

##

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

    {0} is abstract; cannot be instantiated

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

    abstract methods cannot have a body

compiler.err.already.annotated=\

    {0} {1} has already been annotated

compiler.err.already.defined=\

    {0} is already defined in {1}

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

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

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

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

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

    {0} is already defined in this compilation unit

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

    annotation {0} is missing value for the attribute {1}

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

    annotation {0} is missing values for attributes {1}

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

    annotation not valid for a value of type {0}

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

    annotation type not applicable to this kind of declaration

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

    annotation value must be an annotation

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

    annotation value must be a class literal

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

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

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

    annotation value not of an allowable type

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

    anonymous class implements interface; cannot have arguments

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

    anonymous class implements interface; cannot have type arguments

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

    anonymous class implements interface; cannot have qualifier for new

compiler.err.array.and.varargs=\

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

compiler.err.array.dimension.missing=\

    array dimension missing

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

    array required, but {0} found

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

    assigning from wildcard {0}

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

    assigning to wildcard {0}

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

    attribute value must be constant

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

    break outside switch or loop

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

    call to {0} must be first statement in constructor

compiler.err.cant.apply.symbol=\

    {0} {1} in {4} {5} cannot be applied to given types\n\

    required: {2}\n\

    found: {3}

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

    {0} {1} in {4} {5} cannot be applied to given types;\n\

    required: {2}\n\

    found: {3}\n\

    reason: {6}

compiler.err.cant.apply.symbols=\

    no suitable {0} found for {1}({2})

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

    cannot assign a value to final variable {0}

compiler.err.cant.deref=\

    {0} cannot be dereferenced

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

    ''extends'' not allowed for @interfaces

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

    cannot inherit from final {0}

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

    cannot reference {0} before supertype constructor has been called

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

    cannot return a value from method whose result type is void

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

    cannot select a static class from a parameterized type

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

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

compiler.err.catch.without.try=\

    ''catch'' without ''try''

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

    {0} {1} clashes with package of same name

compiler.err.const.expr.req=\

    constant expression required

compiler.err.cont.outside.loop=\

    continue outside of loop

compiler.err.cyclic.inheritance=\

    cyclic inheritance involving {0}

compiler.err.cyclic.annotation.element=\

    cyclic annotation element type

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

    call to super not allowed in enum constructor

compiler.err.no.superclass=\

    {0} has no superclass

compiler.err.wrong.target.for.polymorphic.signature.definition=\

    MethodHandle API building requires -target 7 runtimes or better; current is -target {0}

compiler.err.concrete.inheritance.conflict=\

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

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

    default value only allowed in an @interface member

compiler.err.doesnt.exist=\

    package {0} does not exist

compiler.err.duplicate.annotation=\

    duplicate annotation

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

    duplicate annotation member value {0} in {1}

compiler.err.duplicate.class=\

    duplicate class: {0}

compiler.err.duplicate.case.label=\

    duplicate case label

compiler.err.duplicate.default.label=\

    duplicate default label

compiler.err.else.without.if=\

    ''else'' without ''if''

compiler.err.empty.char.lit=\

    empty character literal

compiler.err.encl.class.required=\

    an enclosing instance that contains {0} is required

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

    an enum annotation value must be an enum constant

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

    enum types may not be instantiated

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

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

compiler.err.enum.no.subclassing=\

    classes cannot directly extend java.lang.Enum

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

    enum types are not extensible

compiler.err.enum.no.finalize=\

    enums cannot have finalize methods

compiler.err.error.reading.file=\

    error reading {0}; {1}

compiler.err.except.already.caught=\

    exception {0} has already been caught

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

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

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

    final parameter {0} may not be assigned

compiler.err.try.resource.may.not.be.assigned=\

    auto-closeable resource {0} may not be assigned

compiler.err.multicatch.parameter.may.not.be.assigned=\

    multi-catch parameter {0} may not be assigned

compiler.err.finally.without.try=\

    ''finally'' without ''try''

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

    for-each not applicable to expression type\n\

    required: {1}\n\

    found:    {0}

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

    floating point number too large

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

    floating point number too small

compiler.err.generic.array.creation=\

    generic array creation

compiler.err.generic.throwable=\

    a generic class may not extend java.lang.Throwable

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

compiler.err.illegal.char=\

    illegal character: \\{0}

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

    unmappable character for encoding {0}

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

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

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

    illegal reference to static field from initializer

compiler.err.illegal.esc.char=\

    illegal escape character

compiler.err.illegal.forward.ref=\

    illegal forward reference

compiler.warn.forward.ref=\

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

compiler.err.illegal.self.ref=\

    self-reference in initializer

compiler.warn.self.ref=\

    self-reference in initializer of variable ''{0}''

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

    illegal generic type for instanceof

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

    illegal initializer for {0}

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

    illegal line end in character literal

compiler.err.illegal.nonascii.digit=\

    illegal non-ASCII digit

compiler.err.illegal.underscore=\

    illegal underscore

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

    illegal qualifier; {0} is not an inner class

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

    illegal start of expression

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

    illegal start of type

compiler.err.illegal.unicode.esc=\

    illegal unicode escape

compiler.err.import.requires.canonical=\

    import requires canonical name for {0}

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

    improperly formed type, some parameters are missing

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

    improperly formed type, type arguments given on a raw type

compiler.err.incomparable.types=\

    incomparable types: {0} and {1}

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

    integer number too large: {0}

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

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

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

    @interface members may not have parameters

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

    @interface may not have type parameters

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

    @interface members may not have type parameters

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

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

compiler.err.intf.expected.here=\

    interface expected here

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

    interface methods cannot have body

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

    invalid type for annotation member

compiler.err.invalid.binary.number=\

    binary numbers must contain at least one binary digit

compiler.err.invalid.hex.number=\

    hexadecimal numbers must contain at least one hexadecimal digit

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

    invalid method declaration; return type required

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

    label {0} already in use

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

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

compiler.err.local.enum=\

    enum types must not be local

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

    cannot create array with type arguments

#

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

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

# detected during code generation.

#

compiler.err.limit.code=\

    code too large

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

    code too large for try statement

compiler.err.limit.dimensions=\

    array type has too many dimensions

compiler.err.limit.locals=\

    too many local variables

compiler.err.limit.parameters=\

    too many parameters

compiler.err.limit.pool=\

    too many constants

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

    too many constants in class {0}

compiler.err.limit.stack=\

    code requires too much stack

compiler.err.limit.string=\

    constant string too long

compiler.err.limit.string.overflow=\

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

compiler.err.malformed.fp.lit=\

    malformed floating point literal

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

    method does not override or implement a method from a supertype

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

    missing method body, or declare abstract

compiler.err.missing.ret.stmt=\

    missing return statement

compiler.err.missing.ret.val=\

    missing return value

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

    modifier {0} not allowed here

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

    interface not allowed here

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

    enum declarations allowed only in static contexts

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

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

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

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

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

    {0} is reserved for internal use

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

    native methods cannot have a body

compiler.err.neither.conditional.subtype=\

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

second operand: {0}\n\

third operand : {1}

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

    ''new'' not allowed in an annotation

compiler.err.no.annotation.member=\

    no annotation member {0} in {1}

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

    no enclosing instance of type {0} is in scope

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

    no interface expected here

compiler.err.no.match.entry=\

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

compiler.err.not.annotation.type=\

    {0} is not an annotation type

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

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

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

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

compiler.err.not.loop.label=\

    not a loop label: {0}

compiler.err.not.stmt=\

    not a statement

compiler.err.not.encl.class=\

    not an enclosing class: {0}

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

    bad operand type {1} for unary operator ''{0}''

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

    bad operand types for binary operator ''{0}''\n\

    first type:  {1}\n\

    second type: {2}

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

    package annotations should be in file package-info.java

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

    package {0} clashes with class of same name

compiler.err.warnings.and.werror=\

    warnings found and -Werror specified

# Errors related to annotation processing

compiler.err.proc.cant.access=\

cannot access {0}\n\

{1}\n\

Consult the following stack trace for details.\n\

{2}

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

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

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

compiler.err.proc.messager=\

    {0}

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

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

compiler.err.proc.no.service=\

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

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

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

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

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

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

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

    Exception thrown while constructing Processor object: {0}

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

    Annotation processor ''{0}'' not found

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

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

compiler.err.proc.service.problem=\

    Error creating a service loader to load Processors.

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

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

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

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

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

    qualified new of static class

compiler.err.recursive.ctor.invocation=\

    recursive constructor invocation

compiler.err.ref.ambiguous=\

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

compiler.err.repeated.annotation.target=\

    repeated annotation target

compiler.err.repeated.interface=\

    repeated interface

compiler.err.repeated.modifier=\

    repeated modifier

compiler.err.report.access=\

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

compiler.err.ret.outside.meth=\

    return outside method

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

    signature does not match {0}; incompatible supertype

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

    signature does not match {0}; incompatible interfaces

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

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

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

    error writing source; cannot overwrite input file {0}

compiler.err.stack.sim.error=\

    Internal error: stack sim error on {0}

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

    static import only from classes and interfaces

compiler.err.string.const.req=\

    constant string expression required

compiler.err.synthetic.name.conflict=\

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

compiler.warn.synthetic.name.conflict=\

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

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

    throws clause not allowed in @interface members

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

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

compiler.err.try.without.catch.finally.or.resource.decls=\

    ''try'' without ''catch'', ''finally'' or resource declarations

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

    type {0} does not take parameters

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

    cannot select from a type variable

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

    a type variable may not be followed by other bounds

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

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

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

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

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

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

compiler.err.unclosed.char.lit=\

    unclosed character literal

compiler.err.unclosed.comment=\

    unclosed comment

compiler.err.unclosed.str.lit=\

    unclosed string literal

compiler.err.unknown.enum.constant=\

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

compiler.err.unsupported.encoding=\

    unsupported encoding: {0}

compiler.err.io.exception=\

    error reading source file: {0}

compiler.err.undef.label=\

    undefined label: {0}

compiler.err.undetermined.type=\

    cannot infer type arguments for {0}

compiler.err.undetermined.type.1=\

    cannot infer type arguments for {0};\n\

    reason: {1}

compiler.err.invalid.inferred.types=\

    invalid inferred types for {0}; {1}

compiler.err.cant.apply.diamond=\

    cannot infer type arguments for {0}

compiler.err.cant.apply.diamond.1=\

    cannot infer type arguments for {0};\n\

    reason: {1}

compiler.err.unreachable.stmt=\

    unreachable statement

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

    initializer must be able to complete normally

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

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

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

    unreported exception {0} in default constructor

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

    hexadecimal floating-point literals are not supported on this VM

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

    ''void'' type not allowed here

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

    wrong number of type arguments; required {0}

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

    variable {0} might already have been assigned

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

    variable {0} might not have been initialized

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

    variable {0} might be assigned in loop