#

# 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.

#

# Messages in this file which use "placeholders" for values (e.g. {0}, {1})

# are preceded by a stylized comment describing the type of the corresponding

# values.

# The types currently in use are

#

# boolean           true or false

# file name         the name of an input file; e.g.   MyFile.java

# message segment   a sub-message; see compiler.misc.*

# modifier          a Java modifier; e.g. public, private, protected

# name              a name, typically a Java identifier

# number            an integer

# option name       the name of a command line option

# source version    a source version number, such as 1.5, 1.6, 1.7

# string            a general string

# symbol            the name of a declared type

# symbol kind       a description of the kind of a declaration; see compiler.misc.kindname.*

# token             the name of a non-terminal in source code; see compiler.misc.token.*

# type              a Java type; e.g. int, X, X<T>

# unused            the value is not used in this message

#

# list of X         a comma-separated list of items; e.g. list of type

# X or Y            alternation; e.g. message segment or type

# set of X          a comma-separated collection of items; e.g. set of modifier

#

# These may be composed: e.g.   list of type or message segment

#

# These comments are verified by the jtreg test test/tools/javac/diags/MessageInfo,

# using info derived from the collected set of examples in test/tools/javac/diags/examples.

# MessageInfo can also be run as a standalone utility providing more facilities

# for manipulating this file. For more details, see MessageInfo.java.

##

## errors

##

# 0: symbol

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

# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol

compiler.err.already.defined=\

    {0} {1} is already defined in {2} {3}

# 0: symbol kind, 1: symbol, 2: symbol kind, 3: symbol kind, 4: symbol

compiler.err.already.defined.in.clinit=\

    {0} {1} is already defined in {2} of {3} {4}

# 0: string

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

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

# 0: string

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

# 0: type, 1: list of name

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

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

# 0: type, 1: list of name

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

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

# 0: type

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

# 0: symbol, 1: symbol, 2: symbol

compiler.err.array.and.varargs=\

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

compiler.err.array.dimension.missing=\

    array dimension missing

# 0: type

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

# 0: name

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}

# 0: symbol kind, 1: name, 2: list of type or message segment, 3: list of type or message segment, 4: symbol kind, 5: type, 6: message segment

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}

# 0: symbol kind, 1: name, 2: list of type

compiler.err.cant.apply.symbols=\

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

# 0: symbol

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

    cannot assign a value to final variable {0}

# 0: type

compiler.err.cant.deref=\

    {0} cannot be dereferenced

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

    ''extends'' not allowed for @interfaces

# 0: symbol

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

    cannot inherit from final {0}

# 0: symbol

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

# 0: symbol, 1: string, 2: string

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

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

compiler.err.catch.without.try=\

    ''catch'' without ''try''

# 0: symbol kind, 1: symbol

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

# 0: symbol

compiler.err.cyclic.inheritance=\

    cyclic inheritance involving {0}

compiler.err.cyclic.annotation.element=\

    cyclic annotation element type

# 0: unused

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

    call to super not allowed in enum constructor

# 0: type

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}

# 0: symbol, 1: type, 2: symbol, 3: type, 4: unused

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

# 0: symbol

compiler.err.doesnt.exist=\

    package {0} does not exist

compiler.err.duplicate.annotation=\

    duplicate annotation

# 0: name, 1: type

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

    duplicate annotation member value {0} in {1}

# 0: name

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

# 0: symbol

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

# 0: file name, 1: string

compiler.err.error.reading.file=\

    error reading {0}; {1}

# 0: type

compiler.err.except.already.caught=\

    exception {0} has already been caught

# 0: type

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

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

# 0: symbol

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

    final parameter {0} may not be assigned

# 0: symbol

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

    auto-closeable resource {0} may not be assigned

# 0: symbol

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

    multi-catch parameter {0} may not be assigned

# 0: type, 1: type

compiler.err.multicatch.types.must.be.disjoint=\

    Alternatives in a multi-catch statement cannot be related by subclassing\n\

    Alternative {0} is a subclass of alternative {1}

compiler.err.finally.without.try=\

    ''finally'' without ''try''

# 0: type, 1: message segment

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

# 0: symbol

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

    Illegal static declaration in inner class {0}\n\

    modifier \''static\'' is only allowed in constant variable declarations

# 0: string

compiler.err.illegal.char=\

    illegal character: \\{0}

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

    unmappable character for encoding {0}

# 0: set of modifier, 1: set of modifier

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

# 0: symbol

compiler.warn.forward.ref=\

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

compiler.err.illegal.self.ref=\

    self-reference in initializer

# 0: symbol

compiler.warn.self.ref=\

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

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

    illegal generic type for instanceof

# 0: type

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

# 0: symbol

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

# 0: symbol

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

# 0: type, 1: type

compiler.err.incomparable.types=\

    incomparable types: {0} and {1}

# 0: number

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

# 0: symbol, 1: type

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.varargs.and.old.array.syntax=\

    legacy array notation not allowed on variable-arity parameter

# 0: name

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

    label {0} already in use

# 0: symbol

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

compiler.err.cannot.create.array.with.diamond=\

    cannot create array with ''<>''

#

# 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=\