compiler.properties

GJC（Generic Java Compiler）编译器

#
# @(#)compiler.properties	1.43 03/05/06
#
# Copyright 2003 Sun Microsystems, Inc. All Rights Reserved.
#
# This software is the proprietary information of Sun Microsystems, Inc.
# Use is subject to license terms.
#

##
## 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.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.this.unit=\
    {0} is already defined in this compilation unit
compiler.err.anon.class.impl.intf.no.args=\
    anonymous class implements interface; cannot have arguments
compiler.err.anon.class.impl.intf.no.qual.for.new=\
    anonymous class implements interface; cannot have qualifier for new
compiler.err.array.dimension.missing=\
    array dimension missing
compiler.err.array.req.but.found=\
    array required, but {0} found

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.access=\
    cannot access {0}; {1}
compiler.err.cant.apply.symbol=\
    {0} in {1} cannot be applied to ({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.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} 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.doesnt.exist=\
    package {0} does not exist
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.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.finally.without.try=\
    ''finally'' without ''try''
compiler.err.fp.number.too.large=\
    floating point number too large
compiler.err.fp.number.too.small=\
    floating point number too small

compiler.err.icls.cant.have.static.decl=\
    inner classes cannot have static declarations
compiler.err.illegal.char=\
    illegal character: \\{0}
compiler.err.illegal.combination.of.modifiers=\
    illegal combination of modifiers: {0} and {1}
compiler.err.illegal.esc.char=\
    illegal escape character
compiler.err.illegal.forward.ref=\
    illegal forward reference
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.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.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.expected.here=\
    interface expected here
compiler.err.intf.meth.cant.have.body=\
    interface methods cannot have body
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

#
# 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.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.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.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.def.public.class.intf.cant.access=\
    {0} in {1} is not defined in a public class or interface; cannot be accessed from outside package
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=\
    operator {0} cannot be applied to {1}

compiler.err.pkg.clashes.with.class.of.same.name=\
    package {0} clashes with class of same name

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.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.synthetic.name.conflict=\
    the symbol {0} conflicts with a compiler-synthesized symbol in {1}

compiler.err.try.without.catch.or.finally=\
    ''try'' without ''catch'' or ''finally''
compiler.err.type.doesnt.take.params=\
    type {0} does not take parameters
compiler.err.type.var.cant.be.deref=\
    type variables cannot be dereferenced
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 different return type

compiler.err.unclosed.char.lit=\
    unclosed character literal
compiler.err.unclosed.comment=\
    unclosed comment
compiler.err.unclosed.str.lit=\
    unclosed string literal
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=\
    type parameters of {0} cannot be determined
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.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

compiler.err.assert.as.identifier=\
    as of release 1.4, 'assert' is a keyword, and may not be used as an identifier

# In the following string, {1} will always be the detail message from
# java.io.IOException.
compiler.err.class.cant.write=\
    error while writing {0}: {1}

# In the following string, {0} is the name of the class in the Java source.
# It really should be used two times..
compiler.err.class.public.should.be.in.file=\
    class {0} is public, should be declared in a file named {0}.java

## All errors which do not refer to a particular line in the source code are
## preceded by this string.
compiler.err.error=\
    error:\u0020

# The following error messages do not refer to a line in the source code.
compiler.err.cant.read.file=\
    cannot read: {0}

#####

# Fatal Errors

compiler.misc.fatal.err.no.java.lang=\
    Fatal Error: Unable to locate package java.lang in classpath or bootclasspath
compiler.misc.fatal.err.cant.locate.meth=\
    Fatal Error: Unable to locate method {0}

#####

##
## miscellaneous strings
##

compiler.misc.source.unavailable=\
    (source unavailable)
compiler.misc.base.membership=\