linkerlau/my-jdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(jdk8): move files to new folder to avoid resources compiled.

Browse Source
This commit is contained in:
linkerlau
2025-09-07 15:25:52 +08:00
parent 3f0047bf6f
commit 8c35cfb1c0
17415 changed files with 217 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

627
jdkSrc/jdk8/com/sun/tools/javac/resources/compiler.java Normal file
View File

@@ -0,0 +1,627 @@
package com.sun.tools.javac.resources;
public final class compiler extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "compiler.err.abstract.cant.be.accessed.directly", "abstract {0} {1} in {2} cannot be accessed directly" },
{ "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} {1} is already defined in {2} {3}" },
{ "compiler.err.already.defined.in.clinit", "{0} {1} is already defined in {2} of {3} {4}" },
{ "compiler.err.already.defined.single.import", "a type with the same simple name is already defined by the single-type-import of {0}" },
{ "compiler.err.already.defined.static.single.import", "a type with the same simple name is already defined by the static single-type-import of {0}" },
{ "compiler.err.already.defined.this.unit", "{0} is already defined in this compilation unit" },
{ "compiler.err.annotation.missing.default.value", "annotation @{0} is missing a default value for the element ''{1}''" },
{ "compiler.err.annotation.missing.default.value.1", "annotation @{0} is missing default values for elements {1}" },
{ "compiler.err.annotation.not.valid.for.type", "annotation not valid for an element 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.annotations.after.type.params.not.supported.in.source", "annotations after method type parameters are not supported in -source {0}\n(use -source 8 or higher to enable annotations after method type parameters)" },
{ "compiler.err.annotations.not.supported.in.source", "annotations are not supported in -source {0}\n(use -source 5 or higher to enable annotations)" },
{ "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.anon.class.impl.intf.no.typeargs", "anonymous class implements interface; cannot have type arguments" },
{ "compiler.err.array.and.receiver", "legacy array notation not allowed on receiver parameter" },
{ "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.assert.as.identifier", "as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n(use -source 1.3 or lower to use ''assert'' as an identifier)" },
{ "compiler.err.attribute.value.must.be.constant", "element value must be a constant expression" },
{ "compiler.err.bad.functional.intf.anno", "Unexpected @FunctionalInterface annotation" },
{ "compiler.err.bad.functional.intf.anno.1", "Unexpected @FunctionalInterface annotation\n{0}" },
{ "compiler.err.bad.initializer", "bad initializer for {0}" },
{ "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.call.to.super.not.allowed.in.enum.ctor", "call to super not allowed in enum constructor" },
{ "compiler.err.cannot.create.array.with.diamond", "cannot create array with ''<>''" },
{ "compiler.err.cannot.create.array.with.type.arguments", "cannot create array with type arguments" },
{ "compiler.err.cant.access", "cannot access {0}\n{1}" },
{ "compiler.err.cant.apply.diamond", "cannot infer type arguments for {0}" },
{ "compiler.err.cant.apply.diamond.1", "cannot infer type arguments for {0}\nreason: {1}" },
{ "compiler.err.cant.apply.symbol", "{0} {1} in {4} {5} cannot be applied to given types;\nrequired: {2}\nfound: {3}\nreason: {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.diff.arg", "{0} cannot be inherited with different arguments: <{1}> and <{2}>" },
{ "compiler.err.cant.inherit.from.anon", "cannot inherit from anonymous class" },
{ "compiler.err.cant.inherit.from.final", "cannot inherit from final {0}" },
{ "compiler.err.cant.read.file", "cannot read: {0}" },
{ "compiler.err.cant.ref.before.ctor.called", "cannot reference {0} before supertype constructor has been called" },
{ "compiler.err.cant.ref.non.effectively.final.var", "local variables referenced from {1} must be final or effectively final" },
{ "compiler.err.cant.resolve", "cannot find symbol\nsymbol: {0} {1}" },
{ "compiler.err.cant.resolve.args", "cannot find symbol\nsymbol: {0} {1}({3})" },
{ "compiler.err.cant.resolve.args.params", "cannot find symbol\nsymbol: {0} <{2}>{1}({3})" },
{ "compiler.err.cant.resolve.location", "cannot find symbol\nsymbol: {0} {1}\nlocation: {4}" },
{ "compiler.err.cant.resolve.location.args", "cannot find symbol\nsymbol: {0} {1}({3})\nlocation: {4}" },
{ "compiler.err.cant.resolve.location.args.params", "cannot find symbol\nsymbol: {0} <{2}>{1}({3})\nlocation: {4}" },
{ "compiler.err.cant.select.static.class.from.param.type", "cannot select a static class from a parameterized type" },
{ "compiler.err.cant.type.annotate.scoping", "scoping construct cannot be annotated with type-use annotations: {0}" },
{ "compiler.err.cant.type.annotate.scoping.1", "scoping construct cannot be annotated with type-use annotation: {0}" },
{ "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.class.cant.write", "error while writing {0}: {1}" },
{ "compiler.err.class.not.allowed", "class, interface or enum declaration not allowed here" },
{ "compiler.err.class.public.should.be.in.file", "class {0} is public, should be declared in a file named {0}.java" },
{ "compiler.err.concrete.inheritance.conflict", "methods {0} from {1} and {2} from {3} are inherited with the same signature" },
{ "compiler.err.const.expr.req", "constant expression required" },
{ "compiler.err.cont.outside.loop", "continue outside of loop" },
{ "compiler.err.cyclic.annotation.element", "type of element {0} is cyclic" },
{ "compiler.err.cyclic.inheritance", "cyclic inheritance involving {0}" },
{ "compiler.err.dc.bad.entity", "bad HTML entity" },
{ "compiler.err.dc.bad.gt", "bad use of ''>''" },
{ "compiler.err.dc.bad.inline.tag", "incorrect use of inline tag" },
{ "compiler.err.dc.gt.expected", "''>'' expected" },
{ "compiler.err.dc.identifier.expected", "identifier expected" },
{ "compiler.err.dc.malformed.html", "malformed HTML" },
{ "compiler.err.dc.missing.semicolon", "semicolon missing" },
{ "compiler.err.dc.no.content", "no content" },
{ "compiler.err.dc.no.tag.name", "no tag name after '@'" },
{ "compiler.err.dc.ref.bad.parens", "'')'' missing in reference" },
{ "compiler.err.dc.ref.syntax.error", "syntax error in reference" },
{ "compiler.err.dc.ref.unexpected.input", "unexpected text" },
{ "compiler.err.dc.unexpected.content", "unexpected content" },
{ "compiler.err.dc.unterminated.inline.tag", "unterminated inline tag" },
{ "compiler.err.dc.unterminated.signature", "unterminated signature" },
{ "compiler.err.dc.unterminated.string", "unterminated string" },
{ "compiler.err.default.allowed.in.intf.annotation.member", "default value only allowed in an annotation type declaration" },
{ "compiler.err.default.methods.not.supported.in.source", "default methods are not supported in -source {0}\n(use -source 8 or higher to enable default methods)" },
{ "compiler.err.default.overrides.object.member", "default method {0} in {1} {2} overrides a member of java.lang.Object" },
{ "compiler.err.diamond.not.supported.in.source", "diamond operator is not supported in -source {0}\n(use -source 7 or higher to enable diamond operator)" },
{ "compiler.err.does.not.override.abstract", "{0} is not abstract and does not override abstract method {1} in {2}" },
{ "compiler.err.doesnt.exist", "package {0} does not exist" },
{ "compiler.err.dot.class.expected", "''.class'' expected" },
{ "compiler.err.duplicate.annotation.invalid.repeated", "annotation {0} is not a valid repeatable annotation" },
{ "compiler.err.duplicate.annotation.member.value", "duplicate element ''{0}'' in annotation @{1}." },
{ "compiler.err.duplicate.annotation.missing.container", "{0} is not a repeatable annotation type" },
{ "compiler.err.duplicate.case.label", "duplicate case label" },
{ "compiler.err.duplicate.class", "duplicate class: {0}" },
{ "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.as.identifier", "as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n(use -source 1.4 or lower to use ''enum'' as an identifier)" },
{ "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.finalize", "enums cannot have finalize methods" },
{ "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.enums.must.be.static", "enum declarations allowed only in static contexts" },
{ "compiler.err.enums.not.supported.in.source", "enums are not supported in -source {0}\n(use -source 5 or higher to enable enums)" },
{ "compiler.err.error", "error: " },
{ "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.expected", "{0} expected" },
{ "compiler.err.expected2", "{0} or {1} expected" },
{ "compiler.err.expected3", "{0}, {1}, or {2} expected" },
{ "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.foreach.not.applicable.to.type", "for-each not applicable to expression type\nrequired: {1}\nfound: {0}" },
{ "compiler.err.foreach.not.supported.in.source", "enhanced for loops are not supported in -source {0}\n(use -source 5 or higher to enable for-each loops)" },
{ "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.generics.not.supported.in.source", "generics are not supported in -source {0}\n(use -source 5 or higher to enable generics)" },
{ "compiler.err.icls.cant.have.static.decl", "Illegal static declaration in inner class {0}\nmodifier ''static'' is only allowed in constant variable declarations" },
{ "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.default.super.call", "bad type qualifier {0} in default super call\n{1}" },
{ "compiler.err.illegal.dot", "illegal ''.''" },
{ "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.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.qual.not.icls", "illegal qualifier; {0} is not an inner class" },
{ "compiler.err.illegal.self.ref", "self-reference in initializer" },
{ "compiler.err.illegal.start.of.expr", "illegal start of expression" },
{ "compiler.err.illegal.start.of.stmt", "illegal start of statement" },
{ "compiler.err.illegal.start.of.type", "illegal start of type" },
{ "compiler.err.illegal.static.intf.meth.call", "illegal static interface method call\nthe receiver expression should be replaced with the type qualifier ''{0}''" },
{ "compiler.err.illegal.underscore", "illegal underscore" },
{ "compiler.err.illegal.unicode.esc", "illegal unicode escape" },
{ "compiler.err.import.requires.canonical", "import requires canonical name for {0}" },
{ "compiler.err.improperly.formed.type.inner.raw.param", "improperly formed type, type arguments given on a raw type" },
{ "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.incompatible.thrown.types.in.mref", "incompatible thrown types {0} in method reference" },
{ "compiler.err.incorrect.constructor.receiver.name", "the receiver name does not match the enclosing outer class type\nrequired: {0}\nfound: {1}" },
{ "compiler.err.incorrect.constructor.receiver.type", "the receiver type does not match the enclosing outer class type\nrequired: {0}\nfound: {1}" },
{ "compiler.err.incorrect.receiver.name", "the receiver name does not match the enclosing class type\nrequired: {0}\nfound: {1}" },
{ "compiler.err.incorrect.receiver.type", "the receiver type does not match the enclosing class type\nrequired: {0}\nfound: {1}" },
{ "compiler.err.initializer.must.be.able.to.complete.normally", "initializer must be able to complete normally" },
{ "compiler.err.int.number.too.large", "integer number too large: {0}" },
{ "compiler.err.intersection.types.in.cast.not.supported.in.source", "intersection types in cast are not supported in -source {0}\n(use -source 8 or higher to enable default methods)" },
{ "compiler.err.intf.annotation.cant.have.type.params", "annotation type {0} cannot be generic" },
{ "compiler.err.intf.annotation.member.clash", "annotation type {1} declares an element with the same name as method {0}" },
{ "compiler.err.intf.annotation.members.cant.have.params", "elements in annotation type declarations cannot declare formal parameters" },
{ "compiler.err.intf.annotation.members.cant.have.type.params", "elements in annotation type declarations cannot be generic methods" },
{ "compiler.err.intf.expected.here", "interface expected here" },
{ "compiler.err.intf.meth.cant.have.body", "interface abstract methods cannot have body" },
{ "compiler.err.intf.not.allowed.here", "interface not allowed here" },
{ "compiler.err.invalid.annotation.member.type", "invalid type for element {0} of annotation type" },
{ "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.invalid.mref", "invalid {0} reference\n{1}" },
{ "compiler.err.invalid.repeatable.annotation", "duplicate annotation: {0} is annotated with an invalid @Repeatable annotation" },
{ "compiler.err.invalid.repeatable.annotation.elem.nondefault", "containing annotation type ({0}) does not have a default value for element {1}" },
{ "compiler.err.invalid.repeatable.annotation.incompatible.target", "containing annotation type ({0}) is applicable to more targets than repeatable annotation type ({1})" },
{ "compiler.err.invalid.repeatable.annotation.invalid.value", "{0} is not a valid @Repeatable: invalid value element" },
{ "compiler.err.invalid.repeatable.annotation.multiple.values", "{0} is not a valid @Repeatable, {1} element methods named ''value'' declared" },
{ "compiler.err.invalid.repeatable.annotation.no.value", "{0} is not a valid @Repeatable, no value element method declared" },
{ "compiler.err.invalid.repeatable.annotation.not.documented", "repeatable annotation type ({1}) is @Documented while containing annotation type ({0}) is not" },
{ "compiler.err.invalid.repeatable.annotation.not.inherited", "repeatable annotation type ({1}) is @Inherited while containing annotation type ({0}) is not" },
{ "compiler.err.invalid.repeatable.annotation.repeated.and.container.present", "container {0} must not be present at the same time as the element it contains" },
{ "compiler.err.invalid.repeatable.annotation.retention", "retention of containing annotation type ({0}) is shorter than the retention of repeatable annotation type ({2})" },
{ "compiler.err.invalid.repeatable.annotation.value.return", "containing annotation type ({0}) must declare an element named ''value'' of type {2}" },
{ "compiler.err.io.exception", "error reading source file: {0}" },
{ "compiler.err.label.already.in.use", "label {0} already in use" },
{ "compiler.err.lambda.body.neither.value.nor.void.compatible", "lambda body is neither value nor void compatible" },
{ "compiler.err.lambda.not.supported.in.source", "lambda expressions are not supported in -source {0}\n(use -source 8 or higher to enable lambda expressions)" },
{ "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.local.enum", "enum types must not be local" },
{ "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.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.method.invoked.with.incorrect.number.arguments", "method invoked with incorrect number of arguments; expected {0}, found {1}" },
{ "compiler.err.method.references.not.supported.in.source", "method references are not supported in -source {0}\n(use -source 8 or higher to enable method references)" },
{ "compiler.err.missing.meth.body.or.decl.abstract", "missing method body, or declare abstract" },
{ "compiler.err.missing.ret.stmt", "missing return statement" },
{ "compiler.err.mod.not.allowed.here", "modifier {0} not allowed here" },
{ "compiler.err.multicatch.not.supported.in.source", "multi-catch statement is not supported in -source {0}\n(use -source 7 or higher to enable multi-catch statement)" },
{ "compiler.err.multicatch.parameter.may.not.be.assigned", "multi-catch parameter {0} may not be assigned" },
{ "compiler.err.multicatch.types.must.be.disjoint", "Alternatives in a multi-catch statement cannot be related by subclassing\nAlternative {0} is a subclass of alternative {1}" },
{ "compiler.err.name.clash.same.erasure", "name clash: {0} and {1} have the same erasure" },
{ "compiler.err.name.clash.same.erasure.no.hide", "name clash: {0} in {1} and {2} in {3} have the same erasure, yet neither hides the other" },
{ "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.clash.same.erasure.no.override.1", "name clash: {0} in {1} overrides a method whose erasure is the same as another method, yet neither overrides the other\nfirst method: {2} in {3}\nsecond method: {4} in {5}" },
{ "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\nsecond operand: {0}\nthird 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.annotations.on.dot.class", "no annotations are allowed in the type of a class literal" },
{ "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.no.superclass", "{0} has no superclass." },
{ "compiler.err.non-static.cant.be.ref", "non-static {0} {1} cannot be referenced from a static context" },
{ "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.encl.class", "not an enclosing class: {0}" },
{ "compiler.err.not.in.profile", "{0} is not available in profile ''{1}''" },
{ "compiler.err.not.loop.label", "not a loop label: {0}" },
{ "compiler.err.not.stmt", "not a statement" },
{ "compiler.err.not.within.bounds", "type argument {0} is not within bounds of type-variable {1}" },
{ "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}''\nfirst type: {1}\nsecond type: {2}" },
{ "compiler.err.orphaned", "orphaned {0}" },
{ "compiler.err.override.incompatible.ret", "{0}\nreturn type {1} is not compatible with {2}" },
{ "compiler.err.override.meth", "{0}\noverridden method is {1}" },
{ "compiler.err.override.meth.doesnt.throw", "{0}\noverridden method does not throw {1}" },
{ "compiler.err.override.static", "{0}\noverriding method is static" },
{ "compiler.err.override.weaker.access", "{0}\nattempting to assign weaker access privileges; was {1}" },
{ "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.premature.eof", "reached end of file while parsing" },
{ "compiler.err.prob.found.req", "incompatible types: {0}" },
{ "compiler.err.proc.bad.config.file", "Bad service configuration file, or exception thrown while constructing Processor object: {0}" },
{ "compiler.err.proc.cant.access", "cannot access {0}\n{1}\nConsult the following stack trace for details.\n{2}" },
{ "compiler.err.proc.cant.access.1", "cannot access {0}\n{1}" },
{ "compiler.err.proc.cant.create.loader", "Could not create class loader for annotation processors: {0}" },
{ "compiler.err.proc.cant.find.class", "Could not find class file for ''{0}''." },
{ "compiler.err.proc.cant.load.class", "Could not load processor class file due to ''{0}''." },
{ "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 ServiceLoader was not usable and is required for annotation processing." },
{ "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.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.qualified.new.of.static.class", "qualified new of static class" },
{ "compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class", "receiver parameter not applicable for constructor of top-level class" },
{ "compiler.err.recursive.ctor.invocation", "recursive constructor invocation" },
{ "compiler.err.ref.ambiguous", "reference to {0} is ambiguous\nboth {1} {2} in {3} and {4} {5} in {6} match" },
{ "compiler.err.repeatable.annotations.not.supported.in.source", "repeated annotations are not supported in -source {0}\n(use -source 8 or higher to enable repeated annotations)" },
{ "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.intf", "signature does not match {0}; incompatible interfaces" },
{ "compiler.err.signature.doesnt.match.supertype", "signature does not match {0}; incompatible supertype" },
{ "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.static.import.not.supported.in.source", "static import declarations are not supported in -source {0}\n(use -source 5 or higher to enable static import declarations)" },
{ "compiler.err.static.intf.method.invoke.not.supported.in.source", "static interface method invocations are not supported in -source {0}\n(use -source 8 or higher to enable static interface method invocations)" },
{ "compiler.err.static.intf.methods.not.supported.in.source", "static interface methods are not supported in -source {0}\n(use -source 8 or higher to enable static interface methods)" },
{ "compiler.err.string.const.req", "constant string expression required" },
{ "compiler.err.string.switch.not.supported.in.source", "strings in switch are not supported in -source {0}\n(use -source 7 or higher to enable strings in switch)" },
{ "compiler.err.synthetic.name.conflict", "the symbol {0} conflicts with a compiler-synthesized symbol in {1}" },
{ "compiler.err.this.as.identifier", "as of release 8, ''this'' is allowed as the parameter name for the receiver type only, which has to be the first parameter" },
{ "compiler.err.throws.not.allowed.in.intf.annotation", "throws clause not allowed in @interface members" },
{ "compiler.err.try.resource.may.not.be.assigned", "auto-closeable resource {0} may not be assigned" },
{ "compiler.err.try.with.resources.not.supported.in.source", "try-with-resources is not supported in -source {0}\n(use -source 7 or higher to enable try-with-resources)" },
{ "compiler.err.try.without.catch.finally.or.resource.decls", "''try'' without ''catch'', ''finally'' or resource declarations" },
{ "compiler.err.try.without.catch.or.finally", "''try'' without ''catch'' or ''finally''" },
{ "compiler.err.type.annotations.not.supported.in.source", "type annotations are not supported in -source {0}\n(use -source 8 or higher to enable type annotations)" },
{ "compiler.err.type.doesnt.take.params", "type {0} does not take parameters" },
{ "compiler.err.type.found.req", "unexpected type\nrequired: {1}\nfound: {0}" },
{ "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.abstract.default", "{0} {1} inherits abstract and default for {2}({3}) from types {4} and {5}" },
{ "compiler.err.types.incompatible.diff.ret", "types {0} and {1} are incompatible; both define {2}, but with unrelated return types" },
{ "compiler.err.types.incompatible.unrelated.defaults", "{0} {1} inherits unrelated defaults for {2}({3}) from types {4} and {5}" },
{ "compiler.err.unclosed.char.lit", "unclosed character literal" },
{ "compiler.err.unclosed.comment", "unclosed comment" },
{ "compiler.err.unclosed.str.lit", "unclosed string literal" },
{ "compiler.err.undef.label", "undefined label: {0}" },
{ "compiler.err.underscore.as.identifier.in.lambda", "''_'' used as an identifier\n(use of ''_'' as an identifier is forbidden for lambda parameters)" },
{ "compiler.err.unexpected.lambda", "lambda expression not expected here" },
{ "compiler.err.unexpected.mref", "method reference not expected here" },
{ "compiler.err.unexpected.type", "unexpected type\nrequired: {0}\nfound: {1}" },
{ "compiler.err.unreachable.stmt", "unreachable statement" },
{ "compiler.err.unreported.exception.default.constructor", "unreported exception {0} in default constructor" },
{ "compiler.err.unreported.exception.implicit.close", "unreported exception {0}; must be caught or declared to be thrown\nexception thrown from implicit call to close() on resource variable ''{1}''" },
{ "compiler.err.unreported.exception.need.to.catch.or.throw", "unreported exception {0}; must be caught or declared to be thrown" },
{ "compiler.err.unsupported.binary.lit", "binary literals are not supported in -source {0}\n(use -source 7 or higher to enable binary literals)" },
{ "compiler.err.unsupported.cross.fp.lit", "hexadecimal floating-point literals are not supported on this VM" },
{ "compiler.err.unsupported.encoding", "unsupported encoding: {0}" },
{ "compiler.err.unsupported.fp.lit", "hexadecimal floating point literals are not supported in -source {0}\n(use -source 5 or higher to enable hexadecimal floating point literals)" },
{ "compiler.err.unsupported.underscore.lit", "underscores in literals are not supported in -source {0}\n(use -source 7 or higher to enable underscores in literals)" },
{ "compiler.err.var.might.already.be.assigned", "variable {0} might already have been assigned" },
{ "compiler.err.var.might.be.assigned.in.loop", "variable {0} might be assigned in loop" },
{ "compiler.err.var.might.not.have.been.initialized", "variable {0} might not have been initialized" },
{ "compiler.err.var.not.initialized.in.default.constructor", "variable {0} not initialized in the default constructor" },
{ "compiler.err.varargs.and.old.array.syntax", "legacy array notation not allowed on variable-arity parameter" },
{ "compiler.err.varargs.and.receiver", "varargs notation not allowed on receiver parameter" },
{ "compiler.err.varargs.invalid.trustme.anno", "Invalid {0} annotation. {1}" },
{ "compiler.err.varargs.not.supported.in.source", "variable-arity methods are not supported in -source {0}\n(use -source 5 or higher to enable variable-arity methods)" },
{ "compiler.err.variable.not.allowed", "variable declaration not allowed here" },
{ "compiler.err.void.not.allowed.here", "''void'' type not allowed here" },
{ "compiler.err.warnings.and.werror", "warnings found and -Werror specified" },
{ "compiler.err.wrong.number.type.args", "wrong number of type arguments; required {0}" },
{ "compiler.misc.anonymous.class", "<anonymous {0}>" },
{ "compiler.misc.applicable.method.found", "#{0} applicable method found: {1}" },
{ "compiler.misc.applicable.method.found.1", "#{0} applicable method found: {1}\n({2})" },
{ "compiler.misc.arg.length.mismatch", "actual and formal argument lists differ in length" },
{ "compiler.misc.bad.class.file.header", "bad class file: {0}\n{1}\nPlease remove or make sure it appears in the correct subdirectory of the classpath." },
{ "compiler.misc.bad.class.signature", "bad class signature: {0}" },
{ "compiler.misc.bad.const.pool.entry", "bad constant pool entry in {0}\nexpected {1} at index {2}" },
{ "compiler.misc.bad.const.pool.tag", "bad constant pool tag: {0}" },
{ "compiler.misc.bad.const.pool.tag.at", "bad constant pool tag: {0} at {1}" },
{ "compiler.misc.bad.enclosing.class", "bad enclosing class for {0}: {1}" },
{ "compiler.misc.bad.enclosing.method", "bad enclosing method attribute for class {0}" },
{ "compiler.misc.bad.intersection.target.for.functional.expr", "bad intersection type target for lambda or method reference\n{0}" },
{ "compiler.misc.bad.runtime.invisible.param.annotations", "bad RuntimeInvisibleParameterAnnotations attribute: {0}" },
{ "compiler.misc.bad.signature", "bad signature: {0}" },
{ "compiler.misc.bad.source.file.header", "bad source file: {0}\n{1}\nPlease remove or make sure it appears in the correct subdirectory of the sourcepath." },
{ "compiler.misc.bad.type.annotation.value", "bad type annotation target type value: {0}" },
{ "compiler.misc.base.membership", "all your base class are belong to us" },
{ "compiler.misc.cant.access.inner.cls.constr", "cannot access constructor {0}({1})\nan enclosing instance of type {2} is not in scope" },
{ "compiler.misc.cant.apply.diamond.1", "cannot infer type arguments for {0}\nreason: {1}" },
{ "compiler.misc.cant.apply.symbol", "{0} {1} in {4} {5} cannot be applied to given types\nrequired: {2}\nfound: {3}\nreason: {6}" },
{ "compiler.misc.cant.apply.symbols", "no suitable {0} found for {1}({2})" },
{ "compiler.misc.cant.implement", "{0} in {1} cannot implement {2} in {3}" },
{ "compiler.misc.cant.override", "{0} in {1} cannot override {2} in {3}" },
{ "compiler.misc.cant.resolve.location.args", "cannot find symbol\nsymbol: {0} {1}({3})\nlocation: {4}" },
{ "compiler.misc.cant.resolve.location.args.params", "cannot find symbol\nsymbol: {0} <{2}>{1}({3})\nlocation: {4}" },
{ "compiler.misc.captured.type", "CAP#{0}" },
{ "compiler.misc.ccf.found.later.version", "class file has later version than expected: {0}" },
{ "compiler.misc.ccf.unrecognized.attribute", "unrecognized attribute: {0}" },
{ "compiler.misc.clashes.with", "{0} in {1} clashes with {2} in {3}" },
{ "compiler.misc.class.file.not.found", "class file for {0} not found" },
{ "compiler.misc.class.file.wrong.class", "class file contains wrong class: {0}" },
{ "compiler.misc.conditional.target.cant.be.void", "target-type for conditional expression cannot be void" },
{ "compiler.misc.count.error", "{0} error" },
{ "compiler.misc.count.error.plural", "{0} errors" },
{ "compiler.misc.count.warn", "{0} warning" },
{ "compiler.misc.count.warn.plural", "{0} warnings" },
{ "compiler.misc.descriptor", "descriptor: {2} {0}({1})" },
{ "compiler.misc.descriptor.throws", "descriptor: {2} {0}({1}) throws {3}" },
{ "compiler.misc.diamond", "{0}<>" },
{ "compiler.misc.diamond.and.anon.class", "cannot use ''<>'' with anonymous inner classes" },
{ "compiler.misc.diamond.and.explicit.params", "cannot use ''<>'' with explicit type parameters for constructor" },
{ "compiler.misc.diamond.non.generic", "cannot use ''<>'' with non-generic class {0}" },
{ "compiler.misc.explicit.param.do.not.conform.to.bounds", "explicit type argument {0} does not conform to declared bound(s) {1}" },
{ "compiler.misc.fatal.err.cant.close", "Fatal Error: Cannot close compiler resources" },
{ "compiler.misc.fatal.err.cant.locate.ctor", "Fatal Error: Unable to find constructor for {0}" },
{ "compiler.misc.fatal.err.cant.locate.field", "Fatal Error: Unable to find field {0}" },
{ "compiler.misc.fatal.err.cant.locate.meth", "Fatal Error: Unable to find method {0}" },
{ "compiler.misc.fatal.err.no.java.lang", "Fatal Error: Unable to find package java.lang in classpath or bootclasspath" },
{ "compiler.misc.file.does.not.contain.package", "file does not contain package {0}" },
{ "compiler.misc.file.doesnt.contain.class", "file does not contain class {0}" },
{ "compiler.misc.illegal.start.of.class.file", "illegal start of class file" },
{ "compiler.misc.inaccessible.varargs.type", "formal varargs element type {0} is not accessible from {1} {2}" },
{ "compiler.misc.inapplicable.method", "{0} {1}.{2} is not applicable\n({3})" },
{ "compiler.misc.incompatible.abstracts", "multiple non-overriding abstract methods found in {0} {1}" },
{ "compiler.misc.incompatible.arg.types.in.lambda", "incompatible parameter types in lambda expression" },
{ "compiler.misc.incompatible.arg.types.in.mref", "incompatible parameter types in method reference" },
{ "compiler.misc.incompatible.descs.in.functional.intf", "incompatible function descriptors found in {0} {1}" },
{ "compiler.misc.incompatible.eq.bounds", "inference variable {0} has incompatible equality constraints {1}" },
{ "compiler.misc.incompatible.eq.lower.bounds", "inference variable {0} has incompatible bounds\nequality constraints: {1}\nlower bounds: {2}" },
{ "compiler.misc.incompatible.eq.upper.bounds", "inference variable {0} has incompatible bounds\nequality constraints: {1}\nupper bounds: {2}" },
{ "compiler.misc.incompatible.ret.type.in.lambda", "bad return type in lambda expression\n{0}" },
{ "compiler.misc.incompatible.ret.type.in.mref", "bad return type in method reference\n{0}" },
{ "compiler.misc.incompatible.type.in.conditional", "bad type in conditional expression\n{0}" },
{ "compiler.misc.incompatible.upper.bounds", "inference variable {0} has incompatible upper bounds {1}" },
{ "compiler.misc.incompatible.upper.eq.bounds", "inference variable {0} has incompatible bounds\nupper bounds: {1}\nequality constraints: {2}" },
{ "compiler.misc.incompatible.upper.lower.bounds", "inference variable {0} has incompatible bounds\nupper bounds: {1}\nlower bounds: {2}" },
{ "compiler.misc.inconvertible.types", "{0} cannot be converted to {1}" },
{ "compiler.misc.infer.arg.length.mismatch", "cannot infer type-variable(s) {0}\n(actual and formal argument lists differ in length)" },
{ "compiler.misc.infer.no.conforming.assignment.exists", "cannot infer type-variable(s) {0}\n(argument mismatch; {1})" },
{ "compiler.misc.infer.no.conforming.instance.exists", "no instance(s) of type variable(s) {0} exist so that {1} conforms to {2}" },
{ "compiler.misc.infer.varargs.argument.mismatch", "cannot infer type-variable(s) {0}\n(varargs mismatch; {1})" },
{ "compiler.misc.inferred.do.not.conform.to.eq.bounds", "inferred type does not conform to equality constraint(s)\ninferred: {0}\nequality constraints(s): {1}" },
{ "compiler.misc.inferred.do.not.conform.to.lower.bounds", "inferred type does not conform to lower bound(s)\ninferred: {0}\nlower bound(s): {1}" },
{ "compiler.misc.inferred.do.not.conform.to.upper.bounds", "inferred type does not conform to upper bound(s)\ninferred: {0}\nupper bound(s): {1}" },
{ "compiler.misc.inner.cls", "an inner class" },
{ "compiler.misc.intersection.type", "INT#{0}" },
{ "compiler.misc.invalid.default.interface", "default method found in version {0}.{1} classfile" },
{ "compiler.misc.invalid.generic.lambda.target", "invalid functional descriptor for lambda expression\nmethod {0} in {1} {2} is generic" },
{ "compiler.misc.invalid.mref", "invalid {0} reference\n{1}" },
{ "compiler.misc.invalid.static.interface", "static method found in version {0}.{1} classfile" },
{ "compiler.misc.kindname.annotation", "@interface" },
{ "compiler.misc.kindname.class", "class" },
{ "compiler.misc.kindname.constructor", "constructor" },
{ "compiler.misc.kindname.enum", "enum" },
{ "compiler.misc.kindname.instance.init", "instance initializer" },
{ "compiler.misc.kindname.interface", "interface" },
{ "compiler.misc.kindname.method", "method" },
{ "compiler.misc.kindname.package", "package" },
{ "compiler.misc.kindname.static", "static" },
{ "compiler.misc.kindname.static.init", "static initializer" },
{ "compiler.misc.kindname.type.variable", "type variable" },
{ "compiler.misc.kindname.type.variable.bound", "bound of type variable" },
{ "compiler.misc.kindname.value", "value" },
{ "compiler.misc.kindname.variable", "variable" },
{ "compiler.misc.lambda", "a lambda expression" },
{ "compiler.misc.location", "{0} {1}" },
{ "compiler.misc.location.1", "{0} {1} of type {2}" },
{ "compiler.misc.missing.ret.val", "missing return value" },
{ "compiler.misc.mref.infer.and.explicit.params", "cannot use raw constructor reference with explicit type parameters for constructor" },
{ "compiler.misc.no.abstracts", "no abstract method found in {0} {1}" },
{ "compiler.misc.no.args", "no arguments" },
{ "compiler.misc.no.conforming.assignment.exists", "argument mismatch; {0}" },
{ "compiler.misc.no.suitable.functional.intf.inst", "cannot infer functional interface descriptor for {0}" },
{ "compiler.misc.no.unique.maximal.instance.exists", "no unique maximal instance exists for type variable {0} with upper bounds {1}" },
{ "compiler.misc.no.unique.minimal.instance.exists", "no unique minimal instance exists for type variable {0} with lower bounds {1}" },
{ "compiler.misc.non-static.cant.be.ref", "non-static {0} {1} cannot be referenced from a static context" },
{ "compiler.misc.not.a.functional.intf", "{0} is not a functional interface" },
{ "compiler.misc.not.a.functional.intf.1", "{0} is not a functional interface\n{1}" },
{ "compiler.misc.not.an.intf.component", "component type {0} is not an interface" },
{ "compiler.misc.not.applicable.method.found", "#{0} not applicable method found: {1}\n({2})" },
{ "compiler.misc.not.def.access.class.intf.cant.access", "{0} in {1} is defined in an inaccessible class or interface" },
{ "compiler.misc.not.def.public.cant.access", "{0} is not public in {1}; cannot be accessed from outside package" },
{ "compiler.misc.overridden.default", "method {0} is overridden in {1}" },
{ "compiler.misc.partial.inst.sig", "partially instantiated to: {0}" },
{ "compiler.misc.possible.loss.of.precision", "possible lossy conversion from {0} to {1}" },
{ "compiler.misc.prob.found.req", "incompatible types: {0}" },
{ "compiler.misc.redundant.supertype", "redundant interface {0} is extended by {1}" },
{ "compiler.misc.ref.ambiguous", "reference to {0} is ambiguous\nboth {1} {2} in {3} and {4} {5} in {6} match" },
{ "compiler.misc.report.access", "{0} has {1} access in {2}" },
{ "compiler.misc.resume.abort", "R)esume, A)bort>" },
{ "compiler.misc.source.unavailable", "(source unavailable)" },
{ "compiler.misc.static.bound.mref", "static bound method reference" },
{ "compiler.misc.static.method.in.unbound.lookup", "static {0} {1} found in unbound lookup" },
{ "compiler.misc.static.mref.with.targs", "parameterized qualifier on static method reference" },
{ "compiler.misc.token.bad-symbol", "<bad symbol>" },
{ "compiler.misc.token.character", "<character>" },
{ "compiler.misc.token.double", "<double>" },
{ "compiler.misc.token.end-of-input", "<end of input>" },
{ "compiler.misc.token.float", "<float>" },
{ "compiler.misc.token.identifier", "<identifier>" },
{ "compiler.misc.token.integer", "<integer>" },
{ "compiler.misc.token.long-integer", "<long integer>" },
{ "compiler.misc.token.string", "<string>" },
{ "compiler.misc.try.not.applicable.to.type", "try-with-resources not applicable to variable type\n({0})" },
{ "compiler.misc.type.captureof", "capture#{0} of {1}" },
{ "compiler.misc.type.captureof.1", "capture#{0}" },
{ "compiler.misc.type.none", "<none>" },
{ "compiler.misc.type.null", "<null>" },
{ "compiler.misc.type.parameter", "type parameter {0}" },
{ "compiler.misc.type.req.array.or.iterable", "array or java.lang.Iterable" },
{ "compiler.misc.type.req.class", "class" },
{ "compiler.misc.type.req.class.array", "class or array" },
{ "compiler.misc.type.req.exact", "class or interface without bounds" },
{ "compiler.misc.type.req.ref", "reference" },
{ "compiler.misc.type.var", "{0}#{1}" },
{ "compiler.misc.unable.to.access.file", "unable to access file: {0}" },
{ "compiler.misc.unchecked.assign", "unchecked conversion" },
{ "compiler.misc.unchecked.cast.to.type", "unchecked cast" },
{ "compiler.misc.unchecked.clash.with", "{0} in {1} overrides {2} in {3}" },
{ "compiler.misc.unchecked.implement", "{0} in {1} implements {2} in {3}" },
{ "compiler.misc.unchecked.override", "{0} in {1} overrides {2} in {3}" },
{ "compiler.misc.undecl.type.var", "undeclared type variable: {0}" },
{ "compiler.misc.unexpected.ret.val", "unexpected return value" },
{ "compiler.misc.unicode.str.not.supported", "unicode string in class file not supported" },
{ "compiler.misc.unnamed.package", "unnamed package" },
{ "compiler.misc.varargs.argument.mismatch", "varargs mismatch; {0}" },
{ "compiler.misc.varargs.clash.with", "{0} in {1} overrides {2} in {3}" },
{ "compiler.misc.varargs.implement", "{0} in {1} implements {2} in {3}" },
{ "compiler.misc.varargs.override", "{0} in {1} overrides {2} in {3}" },
{ "compiler.misc.varargs.trustme.on.non.varargs.meth", "Method {0} is not a varargs method." },
{ "compiler.misc.varargs.trustme.on.reifiable.varargs", "Varargs element type {0} is reifiable." },
{ "compiler.misc.varargs.trustme.on.virtual.varargs", "Instance method {0} is not final." },
{ "compiler.misc.verbose.checking.attribution", "[checking {0}]" },
{ "compiler.misc.verbose.classpath", "[search path for class files: {0}]" },
{ "compiler.misc.verbose.loading", "[loading {0}]" },
{ "compiler.misc.verbose.parsing.done", "[parsing completed {0}ms]" },
{ "compiler.misc.verbose.parsing.started", "[parsing started {0}]" },
{ "compiler.misc.verbose.retro", "[retrofitting {0}]" },
{ "compiler.misc.verbose.retro.with", "\tretrofitting {0} with {1}" },
{ "compiler.misc.verbose.retro.with.list", "\tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}" },
{ "compiler.misc.verbose.sourcepath", "[search path for source files: {0}]" },
{ "compiler.misc.verbose.total", "[total {0}ms]" },
{ "compiler.misc.verbose.wrote.file", "[wrote {0}]" },
{ "compiler.misc.version.not.available", "(version info not available)" },
{ "compiler.misc.where.captured", "{0} extends {1} super: {2} from capture of {3}" },
{ "compiler.misc.where.captured.1", "{0} extends {1} from capture of {3}" },
{ "compiler.misc.where.description.captured", "where {0} is a fresh type-variable:" },
{ "compiler.misc.where.description.captured.1", "where {0} are fresh type-variables:" },
{ "compiler.misc.where.description.intersection", "where {0} is an intersection type:" },
{ "compiler.misc.where.description.intersection.1", "where {0} are intersection types:" },
{ "compiler.misc.where.description.typevar", "where {0} is a type-variable:" },
{ "compiler.misc.where.description.typevar.1", "where {0} are type-variables:" },
{ "compiler.misc.where.fresh.typevar", "{0} extends {1}" },
{ "compiler.misc.where.intersection", "{0} extends {1}" },
{ "compiler.misc.where.typevar", "{0} extends {1} declared in {2} {3}" },
{ "compiler.misc.where.typevar.1", "{0} declared in {2} {3}" },
{ "compiler.misc.wrong.version", "class file has wrong version {0}.{1}, should be {2}.{3}" },
{ "compiler.misc.x.print.processor.info", "Processor {0} matches {1} and returns {2}." },
{ "compiler.misc.x.print.rounds", "Round {0}:\n\tinput files: {1}\n\tannotations: {2}\n\tlast round: {3}" },
{ "compiler.note.compressed.diags", "Some messages have been simplified; recompile with -Xdiags:verbose to get full output" },
{ "compiler.note.deferred.method.inst", "Deferred instantiation of method {0}\ninstantiated signature: {1}\ntarget-type: {2}" },
{ "compiler.note.deprecated.filename", "{0} uses or overrides a deprecated API." },
{ "compiler.note.deprecated.filename.additional", "{0} has additional uses or overrides of a deprecated API." },
{ "compiler.note.deprecated.plural", "Some input files use or override a deprecated API." },
{ "compiler.note.deprecated.plural.additional", "Some input files additionally use or override a deprecated API." },
{ "compiler.note.deprecated.recompile", "Recompile with -Xlint:deprecation for details." },
{ "compiler.note.lambda.stat", "Translating lambda expression\nalternate metafactory = {0}\nsynthetic method = {1}" },
{ "compiler.note.mref.stat", "Translating method reference\nalternate metafactory = {0}\n" },
{ "compiler.note.mref.stat.1", "Translating method reference\nalternate metafactory = {0}\nbridge method = {1}" },
{ "compiler.note.note", "Note: " },
{ "compiler.note.potential.lambda.found", "This anonymous inner class creation can be turned into a lambda expression." },
{ "compiler.note.proc.messager", "{0}" },
{ "compiler.note.sunapi.filename", "{0} uses internal proprietary API that may be removed in a future release." },
{ "compiler.note.sunapi.filename.additional", "{0} uses additional internal proprietary API that may be removed in a future release." },
{ "compiler.note.sunapi.plural", "Some input files use internal proprietary API that may be removed in a future release." },
{ "compiler.note.sunapi.plural.additional", "Some input files additionally use internal proprietary API that may be removed in a future release." },
{ "compiler.note.sunapi.recompile", "Recompile with -Xlint:sunapi for details." },
{ "compiler.note.unchecked.filename", "{0} uses unchecked or unsafe operations." },
{ "compiler.note.unchecked.filename.additional", "{0} has additional unchecked or unsafe operations." },
{ "compiler.note.unchecked.plural", "Some input files use unchecked or unsafe operations." },
{ "compiler.note.unchecked.plural.additional", "Some input files additionally use unchecked or unsafe operations." },
{ "compiler.note.unchecked.recompile", "Recompile with -Xlint:unchecked for details." },
{ "compiler.note.verbose.resolve.multi", "resolving method {0} in type {1} to candidate {2}\nphase: {3}\nwith actuals: {4}\nwith type-args: {5}\ncandidates:" },
{ "compiler.note.verbose.resolve.multi.1", "erroneous resolution for method {0} in type {1}\nphase: {3}\nwith actuals: {4}\nwith type-args: {5}\ncandidates:" },
{ "compiler.warn.access.to.sensitive.member.from.serializable.element", "access to sensitive member {0} from serializable element can be publicly accessible to untrusted code" },
{ "compiler.warn.annotation.method.not.found", "Cannot find annotation method ''{1}()'' in type ''{0}''" },
{ "compiler.warn.annotation.method.not.found.reason", "Cannot find annotation method ''{1}()'' in type ''{0}'': {2}" },
{ "compiler.warn.assert.as.identifier", "as of release 1.4, ''assert'' is a keyword, and may not be used as an identifier\n(use -source 1.4 or higher to use ''assert'' as a keyword)" },
{ "compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file", "auxiliary class {0} in {1} should not be accessed from outside its own source file" },
{ "compiler.warn.big.major.version", "{0}: major version {1} is newer than {2}, the highest major version supported by this compiler.\nIt is recommended that the compiler be upgraded." },
{ "compiler.warn.constant.SVUID", "serialVersionUID must be constant in class {0}" },
{ "compiler.warn.diamond.redundant.args", "redundant type arguments in new expression (use diamond operator instead)." },
{ "compiler.warn.diamond.redundant.args.1", "redundant type arguments in new expression (use diamond operator instead).\nexplicit: {0}\ninferred: {1}" },
{ "compiler.warn.dir.path.element.not.found", "bad path element \"{0}\": no such directory" },
{ "compiler.warn.div.zero", "division by zero" },
{ "compiler.warn.empty.if", "empty statement after if" },
{ "compiler.warn.enum.as.identifier", "as of release 5, ''enum'' is a keyword, and may not be used as an identifier\n(use -source 5 or higher to use ''enum'' as a keyword)" },
{ "compiler.warn.finally.cannot.complete", "finally clause cannot complete normally" },
{ "compiler.warn.forward.ref", "reference to variable ''{0}'' before it has been initialized" },
{ "compiler.warn.future.attr", "{0} attribute introduced in version {1}.{2} class files is ignored in version {3}.{4} class files" },
{ "compiler.warn.has.been.deprecated", "{0} in {1} has been deprecated" },
{ "compiler.warn.illegal.char.for.encoding", "unmappable character for encoding {0}" },
{ "compiler.warn.improper.SVUID", "serialVersionUID must be declared static final in class {0}" },
{ "compiler.warn.inexact.non-varargs.call", "non-varargs call of varargs method with inexact argument type for last parameter;\ncast to {0} for a varargs call\ncast to {1} for a non-varargs call and to suppress this warning" },
{ "compiler.warn.invalid.archive.file", "Unexpected file on path: {0}" },
{ "compiler.warn.lintOption", "[{0}] " },
{ "compiler.warn.long.SVUID", "serialVersionUID must be of type long in class {0}" },
{ "compiler.warn.missing.SVUID", "serializable class {0} has no definition of serialVersionUID" },
{ "compiler.warn.missing.deprecated.annotation", "deprecated item is not annotated with @Deprecated" },
{ "compiler.warn.option.obsolete.source", "source value {0} is obsolete and will be removed in a future release" },
{ "compiler.warn.option.obsolete.suppression", "To suppress warnings about obsolete options, use -Xlint:-options." },
{ "compiler.warn.option.obsolete.target", "target value {0} is obsolete and will be removed in a future release" },
{ "compiler.warn.override.bridge", "{0}; overridden method is a bridge method" },
{ "compiler.warn.override.equals.but.not.hashcode", "Class {0} overrides equals, but neither it nor any superclass overrides hashCode method" },
{ "compiler.warn.override.unchecked.ret", "{0}\nreturn type requires unchecked conversion from {1} to {2}" },
{ "compiler.warn.override.unchecked.thrown", "{0}\noverridden method does not throw {1}" },
{ "compiler.warn.override.varargs.extra", "{0}; overriding method is missing ''...''" },
{ "compiler.warn.override.varargs.missing", "{0}; overridden method has no ''...''" },
{ "compiler.warn.path.element.not.found", "bad path element \"{0}\": no such file or directory" },
{ "compiler.warn.pkg-info.already.seen", "a package-info.java file has already been seen for package {0}" },
{ "compiler.warn.position.overflow", "Position encoding overflows at line {0}" },
{ "compiler.warn.possible.fall-through.into.case", "possible fall-through into case" },
{ "compiler.warn.potentially.ambiguous.overload", "{0} in {1} is potentially ambiguous with {2} in {3}" },
{ "compiler.warn.prob.found.req", "{0}\nrequired: {2}\nfound: {1}" },
{ "compiler.warn.proc.annotations.without.processors", "No processor claimed any of these annotations: {0}" },
{ "compiler.warn.proc.file.create.last.round", "File for type ''{0}'' created in the last round will not be subject to annotation processing." },
{ "compiler.warn.proc.file.reopening", "Attempt to create a file for ''{0}'' multiple times" },
{ "compiler.warn.proc.illegal.file.name", "Cannot create file for illegal name ''{0}''." },
{ "compiler.warn.proc.malformed.supported.string", "Malformed string ''{0}'' for a supported annotation type returned by processor ''{1}''" },
{ "compiler.warn.proc.messager", "{0}" },
{ "compiler.warn.proc.package.does.not.exist", "package {0} does not exist" },
{ "compiler.warn.proc.proc-only.requested.no.procs", "Annotation processing without compilation requested but no processors were found." },
{ "compiler.warn.proc.processor.incompatible.source.version", "Supported source version ''{0}'' from annotation processor ''{1}'' less than -source ''{2}''" },
{ "compiler.warn.proc.suspicious.class.name", "Creating file for a type whose name ends in {1}: ''{0}''" },
{ "compiler.warn.proc.type.already.exists", "A file for type ''{0}'' already exists on the sourcepath or classpath" },
{ "compiler.warn.proc.type.recreate", "Attempt to create a file for type ''{0}'' multiple times" },
{ "compiler.warn.proc.unclosed.type.files", "Unclosed files for the types ''{0}''; these types will not undergo annotation processing" },
{ "compiler.warn.proc.unmatched.processor.options", "The following options were not recognized by any processor: ''{0}''" },
{ "compiler.warn.proc.use.implicit", "Implicitly compiled files were not subject to annotation processing.\nUse -implicit to specify a policy for implicit compilation." },
{ "compiler.warn.proc.use.proc.or.implicit", "Implicitly compiled files were not subject to annotation processing.\nUse -proc:none to disable annotation processing or -implicit to specify a policy for implicit compilation." },
{ "compiler.warn.raw.class.use", "found raw type: {0}\nmissing type arguments for generic class {1}" },
{ "compiler.warn.redundant.cast", "redundant cast to {0}" },
{ "compiler.warn.self.ref", "self-reference in initializer of variable ''{0}''" },
{ "compiler.warn.source.no.bootclasspath", "bootstrap class path not set in conjunction with -source {0}" },
{ "compiler.warn.static.not.qualified.by.type", "static {0} should be qualified by type name, {1}, instead of by an expression" },
{ "compiler.warn.sun.proprietary", "{0} is internal proprietary API and may be removed in a future release" },
{ "compiler.warn.synthetic.name.conflict", "the symbol {0} conflicts with a compiler-synthesized symbol in {1}" },
{ "compiler.warn.try.explicit.close.call", "explicit call to close() on an auto-closeable resource" },
{ "compiler.warn.try.resource.not.referenced", "auto-closeable resource {0} is never referenced in body of corresponding try statement" },
{ "compiler.warn.try.resource.throws.interrupted.exc", "auto-closeable resource {0} has a member method close() that could throw InterruptedException" },
{ "compiler.warn.unchecked.assign", "unchecked assignment: {0} to {1}" },
{ "compiler.warn.unchecked.assign.to.var", "unchecked assignment to variable {0} as member of raw type {1}" },
{ "compiler.warn.unchecked.call.mbr.of.raw.type", "unchecked call to {0} as a member of the raw type {1}" },
{ "compiler.warn.unchecked.cast.to.type", "unchecked cast to type {0}" },
{ "compiler.warn.unchecked.generic.array.creation", "unchecked generic array creation for varargs parameter of type {0}" },
{ "compiler.warn.unchecked.meth.invocation.applied", "unchecked method invocation: {0} {1} in {4} {5} is applied to given types\nrequired: {2}\nfound: {3}" },
{ "compiler.warn.unchecked.varargs.non.reifiable.type", "Possible heap pollution from parameterized vararg type {0}" },
{ "compiler.warn.underscore.as.identifier", "''_'' used as an identifier\n(use of ''_'' as an identifier might not be supported in releases after Java SE 8)" },
{ "compiler.warn.unexpected.archive.file", "Unexpected extension for archive file: {0}" },
{ "compiler.warn.unknown.enum.constant", "unknown enum constant {1}.{2}" },
{ "compiler.warn.unknown.enum.constant.reason", "unknown enum constant {1}.{2}\nreason: {3}" },
{ "compiler.warn.unreachable.catch", "unreachable catch clause\nthrown type {0} has already been caught" },
{ "compiler.warn.unreachable.catch.1", "unreachable catch clause\nthrown types {0} have already been caught" },
{ "compiler.warn.varargs.redundant.trustme.anno", "Redundant {0} annotation. {1}" },
{ "compiler.warn.varargs.unsafe.use.varargs.param", "Varargs method could cause heap pollution from non-reifiable varargs parameter {0}" },
{ "compiler.warn.warning", "warning: " },
};
}
}

623
jdkSrc/jdk8/com/sun/tools/javac/resources/compiler_ja.java Normal file
View File

@@ -0,0 +1,623 @@
package com.sun.tools.javac.resources;
public final class compiler_ja extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "compiler.err.abstract.cant.be.accessed.directly", "\u62BD\u8C61{0}\u3067\u3042\u308B{1}({2}\u5185)\u306B\u76F4\u63A5\u30A2\u30AF\u30BB\u30B9\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.abstract.cant.be.instantiated", "{0}\u306Fabstract\u3067\u3059\u3002\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u3092\u751F\u6210\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.abstract.meth.cant.have.body", "abstract\u30E1\u30BD\u30C3\u30C9\u304C\u672C\u4F53\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.already.annotated", "{0} {1}\u306F\u6CE8\u91C8\u304C\u4ED8\u3044\u3066\u3044\u307E\u3059" },
{ "compiler.err.already.defined", "{0} {1}\u306F\u3059\u3067\u306B{2} {3}\u3067\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.already.defined.in.clinit", "{0} {1}\u306F\u3059\u3067\u306B{3} {4}\u306E{2}\u3067\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.already.defined.single.import", "\u540C\u3058\u5358\u7D14\u540D\u306E\u578B\u304C{0}\u306E\u5358\u4E00\u578B\u30A4\u30F3\u30DD\u30FC\u30C8\u306B\u3088\u3063\u3066\u3059\u3067\u306B\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.already.defined.static.single.import", "\u540C\u3058\u5358\u7D14\u540D\u306E\u578B\u304C{0}\u306Estatic\u5358\u4E00\u578B\u30A4\u30F3\u30DD\u30FC\u30C8\u306B\u3088\u3063\u3066\u3059\u3067\u306B\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.already.defined.this.unit", "{0}\u306F\u30B3\u30F3\u30D1\u30A4\u30EB\u5358\u4F4D\u3067\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.annotation.missing.default.value", "\u6CE8\u91C8@{0}\u306B\u306F\u8981\u7D20''{1}''\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.annotation.missing.default.value.1", "\u6CE8\u91C8@{0}\u306B\u306F\u8981\u7D20{1}\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.annotation.not.valid.for.type", "\u6CE8\u91C8\u306F\u578B{0}\u306E\u8981\u7D20\u306B\u5BFE\u3057\u3066\u6709\u52B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.annotation.type.not.applicable", "\u6CE8\u91C8\u578B\u306F\u3053\u306E\u7A2E\u985E\u306E\u5BA3\u8A00\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.annotation.value.must.be.annotation", "\u6CE8\u91C8\u306E\u5024\u306F\u6CE8\u91C8\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.annotation.value.must.be.class.literal", "\u6CE8\u91C8\u306E\u5024\u306F\u30AF\u30E9\u30B9\u30FB\u30EA\u30C6\u30E9\u30EB\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.annotation.value.must.be.name.value", "\u6CE8\u91C8\u306E\u5024\u306F''name=value''\u3068\u3044\u3046\u5F62\u5F0F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.annotation.value.not.allowable.type", "\u4F7F\u7528\u3067\u304D\u306A\u3044\u578B\u306E\u6CE8\u91C8\u306E\u5024\u3067\u3059" },
{ "compiler.err.annotations.after.type.params.not.supported.in.source", "\u30E1\u30BD\u30C3\u30C9\u30FB\u30BF\u30A4\u30D7\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF\u306E\u5F8C\u306E\u6CE8\u91C8\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30E1\u30BD\u30C3\u30C9\u30FB\u30BF\u30A4\u30D7\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF\u306E\u5F8C\u306E\u6CE8\u91C8\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.annotations.not.supported.in.source", "\u6CE8\u91C8\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u6CE8\u91C8\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.anon.class.impl.intf.no.args", "\u533F\u540D\u30AF\u30E9\u30B9\u304C\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3092\u5B9F\u88C5\u3057\u3066\u3044\u307E\u3059\u3002\u5F15\u6570\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.anon.class.impl.intf.no.qual.for.new", "\u533F\u540D\u30AF\u30E9\u30B9\u304C\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3092\u5B9F\u88C5\u3057\u3066\u3044\u307E\u3059\u3002new\u306B\u4FEE\u98FE\u5B50\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002" },
{ "compiler.err.anon.class.impl.intf.no.typeargs", "\u533F\u540D\u30AF\u30E9\u30B9\u304C\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3092\u5B9F\u88C5\u3057\u3066\u3044\u307E\u3059\u3002\u578B\u5F15\u6570\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.array.and.receiver", "\u65E7\u5F0F\u306E\u914D\u5217\u8868\u8A18\u6CD5\u306F\u53D7\u53D6\u308A\u5074\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.array.and.varargs", "{2}\u3067{0}\u3068{1}\u306E\u4E21\u65B9\u3092\u5BA3\u8A00\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.array.dimension.missing", "\u914D\u5217\u306E\u5927\u304D\u3055\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.array.req.but.found", "\u914D\u5217\u304C\u8981\u6C42\u3055\u308C\u307E\u3057\u305F\u304C\u3001{0}\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.err.assert.as.identifier", "\u30EA\u30EA\u30FC\u30B91.4\u304B\u3089''assert''\u306F\u30AD\u30FC\u30EF\u30FC\u30C9\u306A\u306E\u3067\u3001\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\n(''assert''\u3092\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u306B\u306F\u3001-source 1.3\u4EE5\u524D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.attribute.value.must.be.constant", "\u8981\u7D20\u5024\u306F\u5B9A\u6570\u5F0F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.bad.functional.intf.anno", "\u4E88\u671F\u3057\u306A\u3044@FunctionalInterface\u6CE8\u91C8" },
{ "compiler.err.bad.functional.intf.anno.1", "\u4E88\u671F\u3057\u306A\u3044@FunctionalInterface\u6CE8\u91C8\n{0}" },
{ "compiler.err.bad.initializer", "{0}\u306E\u4E0D\u6B63\u306A\u521D\u671F\u5316\u5B50" },
{ "compiler.err.break.outside.switch.loop", "break\u304Cswitch\u6587\u307E\u305F\u306F\u30EB\u30FC\u30D7\u306E\u5916\u306B\u3042\u308A\u307E\u3059" },
{ "compiler.err.call.must.be.first.stmt.in.ctor", "{0}\u306E\u547C\u51FA\u3057\u306F\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u5148\u982D\u6587\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.call.to.super.not.allowed.in.enum.ctor", "\u5217\u6319\u578B\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u3067\u306F\u3001\u30B9\u30FC\u30D1\u30FC\u30AF\u30E9\u30B9\u306E\u547C\u51FA\u3057\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cannot.create.array.with.diamond", "''<>''\u3092\u6301\u3064\u914D\u5217\u306F\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cannot.create.array.with.type.arguments", "\u578B\u5F15\u6570\u3092\u6301\u3064\u914D\u5217\u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.access", "{0}\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093\n{1}" },
{ "compiler.err.cant.apply.diamond", "{0}\u306E\u578B\u5F15\u6570\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.apply.diamond.1", "{0}\u306E\u578B\u5F15\u6570\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093\n\u7406\u7531: {1}" },
{ "compiler.err.cant.apply.symbol", "{4} {5}\u306E{0} {1}\u306F\u6307\u5B9A\u3055\u308C\u305F\u578B\u306B\u9069\u7528\u3067\u304D\u307E\u305B\u3093\u3002\n\u671F\u5F85\u5024: {2}\n\u691C\u51FA\u5024: {3}\n\u7406\u7531: {6}" },
{ "compiler.err.cant.apply.symbols", "{1}\u306B\u9069\u5207\u306A{0}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093({2})" },
{ "compiler.err.cant.assign.val.to.final.var", "final\u5909\u6570{0}\u306B\u5024\u3092\u4EE3\u5165\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.deref", "{0}\u306F\u9593\u63A5\u53C2\u7167\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.extend.intf.annotation", "@interfaces\u3067\u306F''extends''\u306F\u8A31\u53EF\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.err.cant.inherit.diff.arg", "{0}\u3092\u7570\u306A\u308B\u5F15\u6570<{1}>\u3068<{2}>\u3067\u7D99\u627F\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.inherit.from.anon", "\u533F\u540D\u30AF\u30E9\u30B9\u304B\u3089\u7D99\u627F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.inherit.from.final", "final {0}\u304B\u3089\u306F\u7D99\u627F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.read.file", "{0}\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093" },
{ "compiler.err.cant.ref.before.ctor.called", "\u30B9\u30FC\u30D1\u30FC\u30BF\u30A4\u30D7\u306E\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u547C\u51FA\u3057\u524D\u306F{0}\u3092\u53C2\u7167\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.ref.non.effectively.final.var", "{1}\u304B\u3089\u53C2\u7167\u3055\u308C\u308B\u30ED\u30FC\u30AB\u30EB\u5909\u6570\u306F\u3001final\u307E\u305F\u306F\u4E8B\u5B9F\u4E0A\u306Efinal\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.cant.resolve", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} {1}" },
{ "compiler.err.cant.resolve.args", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} {1}({3})" },
{ "compiler.err.cant.resolve.args.params", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} <{2}>{1}({3})" },
{ "compiler.err.cant.resolve.location", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} {1}\n\u5834\u6240: {4}" },
{ "compiler.err.cant.resolve.location.args", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} {1}({3})\n\u5834\u6240: {4}" },
{ "compiler.err.cant.resolve.location.args.params", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} <{2}>{1}({3})\n\u5834\u6240: {4}" },
{ "compiler.err.cant.select.static.class.from.param.type", "\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u3055\u308C\u305F\u578B\u304B\u3089static\u30AF\u30E9\u30B9\u3092\u9078\u629E\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.cant.type.annotate.scoping", "\u30B9\u30B3\u30FC\u30D7\u30FB\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30C8\u3092\u578B\u4F7F\u7528\u6CE8\u91C8\u3067\u6CE8\u91C8\u4ED8\u3051\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093: {0}" },
{ "compiler.err.cant.type.annotate.scoping.1", "\u30B9\u30B3\u30FC\u30D7\u30FB\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30C8\u3092\u578B\u4F7F\u7528\u6CE8\u91C8\u3067\u6CE8\u91C8\u4ED8\u3051\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093: {0}" },
{ "compiler.err.catch.without.try", "''catch''\u3078\u306E''try''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.clash.with.pkg.of.same.name", "{0} {1}\u306F\u540C\u540D\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u3068\u7AF6\u5408\u3057\u307E\u3059" },
{ "compiler.err.class.cant.write", "{0}\u306E\u66F8\u8FBC\u307F\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F: {1}" },
{ "compiler.err.class.not.allowed", "\u30AF\u30E9\u30B9\u3001\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u307E\u305F\u306F\u5217\u6319\u578B\u306E\u5BA3\u8A00\u3092\u3053\u3053\u3067\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.class.public.should.be.in.file", "\u30AF\u30E9\u30B9{0}\u306Fpublic\u3067\u3042\u308A\u3001\u30D5\u30A1\u30A4\u30EB{0}.java\u3067\u5BA3\u8A00\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.concrete.inheritance.conflict", "{1}\u306E\u30E1\u30BD\u30C3\u30C9{0}\u3068{3}\u306E{2}\u306F\u540C\u3058\u30B7\u30B0\u30CD\u30C1\u30E3\u304B\u3089\u7D99\u627F\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.const.expr.req", "\u5B9A\u6570\u5F0F\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.cont.outside.loop", "continue\u304C\u30EB\u30FC\u30D7\u306E\u5916\u306B\u3042\u308A\u307E\u3059" },
{ "compiler.err.cyclic.annotation.element", "\u8981\u7D20{0}\u306E\u578B\u304C\u30EB\u30FC\u30D7\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.cyclic.inheritance", "{0}\u3092\u542B\u3080\u7D99\u627F\u304C\u30EB\u30FC\u30D7\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.dc.bad.entity", "HTML\u30A8\u30F3\u30C6\u30A3\u30C6\u30A3\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.dc.bad.gt", "''>''\u306E\u4F7F\u7528\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.dc.bad.inline.tag", "\u30A4\u30F3\u30E9\u30A4\u30F3\u30FB\u30BF\u30B0\u306E\u4F7F\u7528\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.dc.gt.expected", "''>''\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.dc.identifier.expected", "\u8B58\u5225\u5B50\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.dc.malformed.html", "HTML\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.dc.missing.semicolon", "\u30BB\u30DF\u30B3\u30ED\u30F3\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.dc.no.content", "\u30B3\u30F3\u30C6\u30F3\u30C4\u306A\u3057" },
{ "compiler.err.dc.no.tag.name", "'@'\u306E\u5F8C\u306B\u30BF\u30B0\u540D\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.dc.ref.bad.parens", "\u53C2\u7167\u306B'')''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.dc.ref.syntax.error", "\u53C2\u7167\u306B\u69CB\u6587\u30A8\u30E9\u30FC\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.dc.ref.unexpected.input", "\u4E88\u671F\u3057\u306A\u3044\u30C6\u30AD\u30B9\u30C8\u3067\u3059" },
{ "compiler.err.dc.unexpected.content", "\u4E88\u671F\u3057\u306A\u3044\u30B3\u30F3\u30C6\u30F3\u30C4\u3067\u3059" },
{ "compiler.err.dc.unterminated.inline.tag", "\u30A4\u30F3\u30E9\u30A4\u30F3\u30FB\u30BF\u30B0\u304C\u7D42\u4E86\u3057\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.dc.unterminated.signature", "\u30B7\u30B0\u30CD\u30C1\u30E3\u304C\u7D42\u4E86\u3057\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.dc.unterminated.string", "\u6587\u5B57\u5217\u304C\u7D42\u4E86\u3057\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.default.allowed.in.intf.annotation.member", "\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u306F\u6CE8\u91C8\u578B\u306E\u5BA3\u8A00\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059" },
{ "compiler.err.default.methods.not.supported.in.source", "\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30E1\u30BD\u30C3\u30C9\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30E1\u30BD\u30C3\u30C9\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.default.overrides.object.member", "{1} {2}\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30E1\u30BD\u30C3\u30C9{0}\u306Fjava.lang.Object\u306E\u30E1\u30F3\u30D0\u30FC\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059" },
{ "compiler.err.diamond.not.supported.in.source", "\u30C0\u30A4\u30E4\u30E2\u30F3\u30C9\u6F14\u7B97\u5B50\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30C0\u30A4\u30E4\u30E2\u30F3\u30C9\u6F14\u7B97\u5B50\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.does.not.override.abstract", "{0}\u306Fabstract\u3067\u306A\u304F\u3001{2}\u5185\u306Eabstract\u30E1\u30BD\u30C3\u30C9{1}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u305B\u3093" },
{ "compiler.err.doesnt.exist", "\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u306F\u5B58\u5728\u3057\u307E\u305B\u3093" },
{ "compiler.err.dot.class.expected", "''.class''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.duplicate.annotation.invalid.repeated", "\u6CE8\u91C8{0}\u306F\u6709\u52B9\u306A\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.duplicate.annotation.member.value", "\u6CE8\u91C8@{1}\u306B\u91CD\u8907\u3057\u305F\u8981\u7D20''{0}''\u304C\u3042\u308A\u307E\u3059\u3002" },
{ "compiler.err.duplicate.annotation.missing.container", "{0}\u306F\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u578B\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.duplicate.case.label", "case\u30E9\u30D9\u30EB\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.duplicate.class", "\u30AF\u30E9\u30B9{0}\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.duplicate.default.label", "default\u30E9\u30D9\u30EB\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.else.without.if", "''else''\u3078\u306E''if''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.empty.char.lit", "\u7A7A\u306E\u6587\u5B57\u30EA\u30C6\u30E9\u30EB\u3067\u3059" },
{ "compiler.err.encl.class.required", "{0}\u3092\u542B\u3080\u56F2\u3046\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.enum.annotation.must.be.enum.constant", "\u5217\u6319\u578B\u6CE8\u91C8\u5024\u306F\u3001\u5217\u6319\u578B\u5B9A\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.enum.as.identifier", "\u30EA\u30EA\u30FC\u30B95\u304B\u3089''enum''\u306F\u30AD\u30FC\u30EF\u30FC\u30C9\u306A\u306E\u3067\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\n(''enum''\u3092\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u306B\u306F-source 1.4\u4EE5\u524D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.enum.cant.be.instantiated", "\u5217\u6319\u578B\u306F\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.enum.label.must.be.unqualified.enum", "\u5217\u6319\u578B\u306Eswitch case\u30E9\u30D9\u30EB\u306F\u5217\u6319\u578B\u5B9A\u6570\u306E\u975E\u4FEE\u98FE\u540D\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.enum.no.finalize", "\u5217\u6319\u578B\u306Ffinalize\u30E1\u30BD\u30C3\u30C9\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.enum.no.subclassing", "\u30AF\u30E9\u30B9\u306F\u76F4\u63A5java.lang.Enum\u3092\u62E1\u5F35\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.enum.types.not.extensible", "\u5217\u6319\u578B\u306F\u62E1\u5F35\u53EF\u80FD\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.enums.must.be.static", "\u5217\u6319\u578B\u306E\u5BA3\u8A00\u306Fstatic\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059" },
{ "compiler.err.enums.not.supported.in.source", "\u5217\u6319\u578B\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u5217\u6319\u578B\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.error", "\u30A8\u30E9\u30FC: " },
{ "compiler.err.error.reading.file", "{0}\u306E\u8AAD\u8FBC\u307F\u30A8\u30E9\u30FC\u3067\u3059\u3002{1}" },
{ "compiler.err.except.already.caught", "\u4F8B\u5916{0}\u306F\u3059\u3067\u306B\u6355\u6349\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.except.never.thrown.in.try", "\u4F8B\u5916{0}\u306F\u5BFE\u5FDC\u3059\u308Btry\u6587\u306E\u672C\u4F53\u3067\u306F\u30B9\u30ED\u30FC\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.err.expected", "{0}\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.expected2", "{0}\u307E\u305F\u306F{1}\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.expected3", "{0}\u3001{1}\u307E\u305F\u306F{2}\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.final.parameter.may.not.be.assigned", "final\u30D1\u30E9\u30E1\u30FC\u30BF{0}\u306B\u5024\u3092\u4EE3\u5165\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.finally.without.try", "''finally''\u3078\u306E''try''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.foreach.not.applicable.to.type", "for-each\u306F\u5F0F\u306E\u30BF\u30A4\u30D7\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\n\u671F\u5F85\u5024: {1}\n\u691C\u51FA\u5024: {0}" },
{ "compiler.err.foreach.not.supported.in.source", "\u62E1\u5F35for\u30EB\u30FC\u30D7\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(for-each\u30EB\u30FC\u30D7\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.fp.number.too.large", "\u6D6E\u52D5\u5C0F\u6570\u70B9\u6570\u304C\u5927\u304D\u3059\u304E\u307E\u3059" },
{ "compiler.err.fp.number.too.small", "\u6D6E\u52D5\u5C0F\u6570\u70B9\u6570\u304C\u5C0F\u3055\u3059\u304E\u307E\u3059" },
{ "compiler.err.generic.array.creation", "\u6C4E\u7528\u914D\u5217\u3092\u4F5C\u6210\u3057\u307E\u3059" },
{ "compiler.err.generic.throwable", "\u6C4E\u7528\u30AF\u30E9\u30B9\u306Fjava.lang.Throwable\u3092\u62E1\u5F35\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.generics.not.supported.in.source", "\u7DCF\u79F0\u578B\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u7DCF\u79F0\u578B\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.icls.cant.have.static.decl", "\u5185\u90E8\u30AF\u30E9\u30B9{0}\u306E\u9759\u7684\u5BA3\u8A00\u304C\u4E0D\u6B63\u3067\u3059\n\u4FEE\u98FE\u5B50''static''\u306F\u5B9A\u6570\u304A\u3088\u3073\u5909\u6570\u306E\u5BA3\u8A00\u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059" },
{ "compiler.err.illegal.char", "''{0}''\u306F\u4E0D\u6B63\u306A\u6587\u5B57\u3067\u3059" },
{ "compiler.err.illegal.char.for.encoding", "\u3053\u306E\u6587\u5B57\u306F\u3001\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0{0}\u306B\u30DE\u30C3\u30D7\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.illegal.combination.of.modifiers", "\u4FEE\u98FE\u5B50{0}\u3068{1}\u306E\u7D44\u5408\u305B\u306F\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.default.super.call", "\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u30B9\u30FC\u30D1\u30FC\u30FB\u30B3\u30FC\u30EB\u306E\u578B\u4FEE\u98FE\u5B50{0}\u304C\u4E0D\u6B63\u3067\u3059\n{1}" },
{ "compiler.err.illegal.dot", "\u4E0D\u6B63\u306A''.''\u3067\u3059" },
{ "compiler.err.illegal.enum.static.ref", "\u521D\u671F\u5316\u5B50\u304B\u3089static\u30D5\u30A3\u30FC\u30EB\u30C9\u3078\u306E\u53C2\u7167\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.esc.char", "\u30A8\u30B9\u30B1\u30FC\u30D7\u6587\u5B57\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.forward.ref", "\u524D\u65B9\u53C2\u7167\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.generic.type.for.instof", "instanceof\u306E\u7DCF\u79F0\u578B\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.initializer.for.type", "{0}\u306E\u521D\u671F\u5316\u5B50\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.line.end.in.char.lit", "\u6587\u5B57\u30EA\u30C6\u30E9\u30EB\u306E\u884C\u672B\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.nonascii.digit", "\u4E0D\u6B63\u306A\u975EASCII\u6570\u5B57\u3067\u3059" },
{ "compiler.err.illegal.qual.not.icls", "\u4FEE\u98FE\u5B50\u304C\u4E0D\u6B63\u3067\u3059\u3002{0}\u306F\u5185\u90E8\u30AF\u30E9\u30B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.illegal.self.ref", "\u521D\u671F\u5316\u5B50\u5185\u306E\u81EA\u5DF1\u53C2\u7167" },
{ "compiler.err.illegal.start.of.expr", "\u5F0F\u306E\u958B\u59CB\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.start.of.stmt", "\u6587\u306E\u958B\u59CB\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.start.of.type", "\u578B\u306E\u958B\u59CB\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.illegal.static.intf.meth.call", "static\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u30FB\u30E1\u30BD\u30C3\u30C9\u30FB\u30B3\u30FC\u30EB\u304C\u4E0D\u6B63\u3067\u3059\n\u53D7\u4FE1\u5F0F\u306F\u578B\u4FEE\u98FE\u5B50''{0}''\u3067\u7F6E\u63DB\u3055\u308C\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.illegal.underscore", "\u4E0D\u6B63\u306A\u30A2\u30F3\u30C0\u30FC\u30B9\u30B3\u30A2\u3067\u3059" },
{ "compiler.err.illegal.unicode.esc", "Unicode\u30A8\u30B9\u30B1\u30FC\u30D7\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.import.requires.canonical", "\u30A4\u30F3\u30DD\u30FC\u30C8\u306B\u306F{0}\u306E\u6A19\u6E96\u540D\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.improperly.formed.type.inner.raw.param", "\u578B\u306E\u5F62\u5F0F\u304C\u4E0D\u9069\u5207\u3067\u3059\u3002raw\u578B\u306B\u6307\u5B9A\u3055\u308C\u305F\u578B\u5F15\u6570\u3067\u3059" },
{ "compiler.err.improperly.formed.type.param.missing", "\u578B\u306E\u5F62\u5F0F\u304C\u4E0D\u9069\u5207\u3067\u3059\u3002\u30D1\u30E9\u30E1\u30FC\u30BF\u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.incomparable.types", "\u578B{0}\u3068{1}\u306F\u6BD4\u8F03\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.incompatible.thrown.types.in.mref", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306E\u30B9\u30ED\u30FC\u3055\u308C\u305F\u30BF\u30A4\u30D7{0}\u306F\u4E0D\u9069\u5408\u3067\u3059" },
{ "compiler.err.incorrect.constructor.receiver.name", "\u53D7\u53D6\u308A\u5074\u306E\u540D\u524D\u304C\u3001\u5305\u542B\u3059\u308B\u5916\u90E8\u30AF\u30E9\u30B9\u30FB\u30BF\u30A4\u30D7\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\n\u5FC5\u9808: {0}\n\u691C\u51FA: {1}" },
{ "compiler.err.incorrect.constructor.receiver.type", "\u53D7\u53D6\u308A\u5074\u306E\u30BF\u30A4\u30D7\u304C\u3001\u5305\u542B\u3059\u308B\u5916\u90E8\u30AF\u30E9\u30B9\u30FB\u30BF\u30A4\u30D7\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\n\u5FC5\u9808: {0}\n\u691C\u51FA: {1}" },
{ "compiler.err.incorrect.receiver.name", "\u53D7\u53D6\u308A\u5074\u306E\u540D\u524D\u304C\u3001\u5305\u542B\u3059\u308B\u30AF\u30E9\u30B9\u30FB\u30BF\u30A4\u30D7\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\n\u5FC5\u9808: {0}\n\u691C\u51FA: {1}" },
{ "compiler.err.incorrect.receiver.type", "\u53D7\u53D6\u308A\u5074\u306E\u30BF\u30A4\u30D7\u304C\u3001\u5305\u542B\u3059\u308B\u30AF\u30E9\u30B9\u30FB\u30BF\u30A4\u30D7\u3068\u4E00\u81F4\u3057\u307E\u305B\u3093\n\u5FC5\u9808: {0}\n\u691C\u51FA: {1}" },
{ "compiler.err.initializer.must.be.able.to.complete.normally", "\u521D\u671F\u5316\u5B50\u306F\u6B63\u5E38\u306B\u5B8C\u4E86\u3067\u304D\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.int.number.too.large", "\u6574\u6570{0}\u304C\u5927\u304D\u3059\u304E\u307E\u3059" },
{ "compiler.err.intersection.types.in.cast.not.supported.in.source", "\u30AD\u30E3\u30B9\u30C8\u5185\u306Eintersection\u578B\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30E1\u30BD\u30C3\u30C9\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.intf.annotation.cant.have.type.params", "\u6CE8\u91C8\u578B{0}\u306F\u6C4E\u7528\u306B\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.intf.annotation.member.clash", "\u6CE8\u91C8\u578B{1}\u3067\u30E1\u30BD\u30C3\u30C9{0}\u3068\u540C\u3058\u540D\u524D\u306E\u8981\u7D20\u304C\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.intf.annotation.members.cant.have.params", "\u6CE8\u91C8\u578B\u5BA3\u8A00\u5185\u306E\u8981\u7D20\u304C\u4EEE\u30D1\u30E9\u30E1\u30FC\u30BF\u3092\u5BA3\u8A00\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.intf.annotation.members.cant.have.type.params", "\u6CE8\u91C8\u578B\u5BA3\u8A00\u5185\u306E\u8981\u7D20\u306F\u6C4E\u7528\u30E1\u30BD\u30C3\u30C9\u306B\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.intf.expected.here", "\u3053\u3053\u306B\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.intf.meth.cant.have.body", "\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u62BD\u8C61\u30E1\u30BD\u30C3\u30C9\u304C\u672C\u4F53\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.intf.not.allowed.here", "\u3053\u3053\u3067\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306F\u8A31\u53EF\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.err.invalid.annotation.member.type", "\u6CE8\u91C8\u578B\u306E\u8981\u7D20{0}\u306E\u578B\u304C\u7121\u52B9\u3067\u3059" },
{ "compiler.err.invalid.binary.number", "2\u9032\u6570\u5B57\u306F\u5C11\u306A\u304F\u3068\u30821\u6841\u306E2\u9032\u6570\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.invalid.hex.number", "16\u9032\u6570\u5B57\u306F\u5C11\u306A\u304F\u3068\u30821\u6841\u306E16\u9032\u6570\u3092\u542B\u3080\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.invalid.meth.decl.ret.type.req", "\u7121\u52B9\u306A\u30E1\u30BD\u30C3\u30C9\u5BA3\u8A00\u3067\u3059\u3002\u623B\u308A\u5024\u306E\u578B\u304C\u5FC5\u8981\u3067\u3059\u3002" },
{ "compiler.err.invalid.mref", "{0}\u53C2\u7167\u304C\u7121\u52B9\u3067\u3059\n{1}" },
{ "compiler.err.invalid.repeatable.annotation", "\u6CE8\u91C8\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059: {0}\u306F\u7121\u52B9\u306A@Repeatable\u6CE8\u91C8\u3067\u6CE8\u91C8\u4ED8\u3051\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.elem.nondefault", "\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B{0}\u306B\u306F\u8981\u7D20{1}\u306E\u30C7\u30D5\u30A9\u30EB\u30C8\u5024\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.invalid.repeatable.annotation.incompatible.target", "\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B({0})\u306F\u3001\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u578B({1})\u3088\u308A\u591A\u304F\u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u306B\u9069\u7528\u3055\u308C\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.invalid.value", "{0}\u306F\u6709\u52B9\u306A@Repeatable\u3067\u306F\u3042\u308A\u307E\u305B\u3093: \u5024\u8981\u7D20\u304C\u7121\u52B9\u3067\u3059" },
{ "compiler.err.invalid.repeatable.annotation.multiple.values", "{0}\u306F\u6709\u52B9\u306A@Repeatable\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002{1}\u8981\u7D20\u30E1\u30BD\u30C3\u30C9''value''\u304C\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.no.value", "{0}\u306F\u6709\u52B9\u306A@Repeatable\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u5024\u8981\u7D20\u30E1\u30BD\u30C3\u30C9\u304C\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.invalid.repeatable.annotation.not.documented", "\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u578B({1})\u306F@Documented\u3067\u3059\u304C\u3001\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B({0})\u306F\u9055\u3044\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.not.inherited", "\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u578B({1})\u306F@Inherited\u3067\u3059\u304C\u3001\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B({0})\u306F\u9055\u3044\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.repeated.and.container.present", "\u30B3\u30F3\u30C6\u30CA{0}\u306F\u542B\u307E\u308C\u3066\u3044\u308B\u8981\u7D20\u3068\u540C\u6642\u306B\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.invalid.repeatable.annotation.retention", "\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B({0})\u306E\u4FDD\u6709\u304C\u3001\u7E70\u8FD4\u3057\u53EF\u80FD\u306A\u6CE8\u91C8\u578B({2})\u306E\u4FDD\u6709\u3088\u308A\u77ED\u304F\u306A\u3063\u3066\u3044\u307E\u3059" },
{ "compiler.err.invalid.repeatable.annotation.value.return", "\u5305\u542B\u3059\u308B\u6CE8\u91C8\u578B({0})\u306F\u578B{2}\u306E\u8981\u7D20''value''\u3092\u5BA3\u8A00\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.io.exception", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u8AAD\u53D6\u308A\u30A8\u30E9\u30FC\u3067\u3059: {0}" },
{ "compiler.err.label.already.in.use", "\u30E9\u30D9\u30EB{0}\u306F\u3059\u3067\u306B\u4F7F\u7528\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.lambda.body.neither.value.nor.void.compatible", "\u30E9\u30E0\u30C0\u30FB\u30DC\u30C7\u30A3\u306F\u5024\u4E92\u63DB\u3067\u3082void\u4E92\u63DB\u3067\u3082\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.lambda.not.supported.in.source", "\u30E9\u30E0\u30C0\u5F0F\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30E9\u30E0\u30C0\u5F0F\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.limit.code", "\u30B3\u30FC\u30C9\u304C\u5927\u304D\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.code.too.large.for.try.stmt", "try\u6587\u306E\u30B3\u30FC\u30C9\u304C\u5927\u304D\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.dimensions", "\u914D\u5217\u578B\u306E\u6B21\u5143\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.locals", "\u30ED\u30FC\u30AB\u30EB\u5909\u6570\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.parameters", "\u30D1\u30E9\u30E1\u30FC\u30BF\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.pool", "\u5B9A\u6570\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.pool.in.class", "\u30AF\u30E9\u30B9{0}\u5185\u306E\u5B9A\u6570\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.stack", "\u30B3\u30FC\u30C9\u304C\u8981\u6C42\u3059\u308B\u30B9\u30BF\u30C3\u30AF\u304C\u591A\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.string", "\u5B9A\u6570\u6587\u5B57\u5217\u304C\u9577\u3059\u304E\u307E\u3059" },
{ "compiler.err.limit.string.overflow", "\u6587\u5B57\u5217\"{0}...\"\u306EUTF8\u8868\u73FE\u304C\u3001\u5B9A\u6570\u30D7\u30FC\u30EB\u306B\u5BFE\u3057\u3066\u9577\u3059\u304E\u307E\u3059" },
{ "compiler.err.local.enum", "\u5217\u6319\u578B\u306F\u30ED\u30FC\u30AB\u30EB\u306B\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.local.var.accessed.from.icls.needs.final", "\u30ED\u30FC\u30AB\u30EB\u5909\u6570{0}\u306F\u5185\u90E8\u30AF\u30E9\u30B9\u304B\u3089\u30A2\u30AF\u30BB\u30B9\u3055\u308C\u307E\u3059\u3002final\u3067\u5BA3\u8A00\u3055\u308C\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.malformed.fp.lit", "\u6D6E\u52D5\u5C0F\u6570\u70B9\u30EA\u30C6\u30E9\u30EB\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.method.does.not.override.superclass", "\u30E1\u30BD\u30C3\u30C9\u306F\u30B9\u30FC\u30D1\u30FC\u30BF\u30A4\u30D7\u306E\u30E1\u30BD\u30C3\u30C9\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u307E\u305F\u306F\u5B9F\u88C5\u3057\u307E\u305B\u3093" },
{ "compiler.err.method.invoked.with.incorrect.number.arguments", "\u30E1\u30BD\u30C3\u30C9\u3092\u8D77\u52D5\u3057\u305F\u5F15\u6570\u306E\u6570\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093\u3002\u4E88\u671F\u3055\u308C\u308B\u6570\u306F{0}\u3067\u3059\u304C\u3001{1}\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.err.method.references.not.supported.in.source", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.missing.meth.body.or.decl.abstract", "\u30E1\u30BD\u30C3\u30C9\u672C\u4F53\u304C\u306A\u3044\u304B\u3001abstract\u3068\u3057\u3066\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.missing.ret.stmt", "return\u6587\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.mod.not.allowed.here", "\u4FEE\u98FE\u5B50{0}\u3092\u3053\u3053\u3067\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.multicatch.not.supported.in.source", "\u8907\u6570catch\u6587\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u8907\u6570catch\u6587\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.multicatch.parameter.may.not.be.assigned", "\u8907\u6570catch\u30D1\u30E9\u30E1\u30FC\u30BF{0}\u306B\u5024\u3092\u4EE3\u5165\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.multicatch.types.must.be.disjoint", "\u8907\u6570catch\u6587\u306E\u4EE3\u66FF\u3092\u30B5\u30D6\u30AF\u30E9\u30B9\u5316\u306B\u3088\u3063\u3066\u95A2\u9023\u4ED8\u3051\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\n\u4EE3\u66FF{0}\u306F\u4EE3\u66FF{1}\u306E\u30B5\u30D6\u30AF\u30E9\u30B9\u3067\u3059" },
{ "compiler.err.name.clash.same.erasure", "\u540D\u524D\u304C\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059\u3002{0}\u3068{1}\u306F\u524A\u9664\u5F8C\u306E\u540D\u524D\u304C\u540C\u3058\u3067\u3059" },
{ "compiler.err.name.clash.same.erasure.no.hide", "\u540D\u524D\u304C\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059\u3002{1}\u306E{0}\u3068{3}\u306E{2}\u306F\u307E\u3060\u4ED6\u65B9\u3092\u975E\u8868\u793A\u306B\u3057\u3066\u3044\u307E\u305B\u3093\u304C\u3001\u524A\u9664\u5F8C\u306E\u540D\u524D\u304C\u540C\u3058\u3067\u3059" },
{ "compiler.err.name.clash.same.erasure.no.override", "\u540D\u524D\u304C\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059\u3002{1}\u306E{0}\u3068{3}\u306E{2}\u306F\u307E\u3060\u4ED6\u65B9\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u307E\u305B\u3093\u304C\u3001\u524A\u9664\u5F8C\u306E\u540D\u524D\u304C\u540C\u3058\u3067\u3059" },
{ "compiler.err.name.clash.same.erasure.no.override.1", "\u540D\u524D\u304C\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059\u3002{1}\u306E{0}\u306E\u3069\u3061\u3089\u3082\u3001\u4ED6\u65B9\u306E\u6700\u521D\u306E\u30E1\u30BD\u30C3\u30C9\u3092\u307E\u3060\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u307E\u305B\u3093\u304C\u3001\u524A\u9664\u5F8C\u306E\u540D\u524D\u304C\u5225\u306E\u30E1\u30BD\u30C3\u30C9\u3068\u540C\u3058\u30E1\u30BD\u30C3\u30C9\u3092\n\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059\u3002\u6700\u521D\u306E\u30E1\u30BD\u30C3\u30C9: {3}\u306E{2}\n2\u756A\u76EE\u306E\u30E1\u30BD\u30C3\u30C9: {5}\u306E{4}" },
{ "compiler.err.name.reserved.for.internal.use", "{0}\u306F\u5185\u90E8\u3067\u306E\u4F7F\u7528\u306E\u305F\u3081\u4E88\u7D04\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.native.meth.cant.have.body", "native\u30E1\u30BD\u30C3\u30C9\u304C\u672C\u4F53\u3092\u6301\u3064\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.neither.conditional.subtype", "?\u306B\u5BFE\u3059\u308B\u4E0D\u9069\u5408\u306A\u578B : \u3069\u3061\u3089\u3082\u4ED6\u65B9\u306E\u30B5\u30D6\u30BF\u30A4\u30D7\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\n2\u756A\u76EE\u306E\u30AA\u30DA\u30E9\u30F3\u30C9 : {0}\n3\u756A\u76EE\u306E\u30AA\u30DA\u30E9\u30F3\u30C9 : {1}" },
{ "compiler.err.new.not.allowed.in.annotation", "''new''\u306F\u6CE8\u91C8\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.no.annotation.member", "{1}\u306E\u6CE8\u91C8\u30E1\u30F3\u30D0\u30FC{0}\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.no.annotations.on.dot.class", "\u6CE8\u91C8\u306F\u30AF\u30E9\u30B9\u30FB\u30EA\u30C6\u30E9\u30EB\u306E\u30BF\u30A4\u30D7\u3067\u8A31\u53EF\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.err.no.encl.instance.of.type.in.scope", "\u578B{0}\u306E\u5185\u90E8\u30AF\u30E9\u30B9\u3092\u56F2\u3080\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u30B9\u30B3\u30FC\u30D7\u5185\u306B\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.no.intf.expected.here", "\u3053\u3053\u306B\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306F\u5FC5\u8981\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.no.match.entry", "{0}\u306F{1}\u306E\u30A8\u30F3\u30C8\u30EA\u306B\u9069\u5408\u3057\u307E\u305B\u3093\u3002{2}\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.no.superclass", "{0}\u306B\u306F\u30B9\u30FC\u30D1\u30FC\u30AF\u30E9\u30B9\u304C\u3042\u308A\u307E\u305B\u3093\u3002" },
{ "compiler.err.non-static.cant.be.ref", "static\u3067\u306A\u3044{0} {1}\u3092static\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u304B\u3089\u53C2\u7167\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.not.annotation.type", "{0}\u306F\u6CE8\u91C8\u578B\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.not.def.access.class.intf.cant.access", "{1}\u306E{0}\u304C\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u306A\u3044\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.not.def.public.cant.access", "{1}\u306E{0}\u306Fpublic\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u30D1\u30C3\u30B1\u30FC\u30B8\u5916\u304B\u3089\u306F\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.not.encl.class", "{0}\u306F\u5185\u90E8\u30AF\u30E9\u30B9\u3092\u56F2\u307F\u307E\u305B\u3093" },
{ "compiler.err.not.in.profile", "{0}\u306F\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB''{1}''\u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.not.loop.label", "{0}\u306F\u30EB\u30FC\u30D7\u30FB\u30E9\u30D9\u30EB\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.not.stmt", "\u6587\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.not.within.bounds", "\u578B\u5F15\u6570{0}\u306F\u578B\u5909\u6570{1}\u306E\u5883\u754C\u5185\u306B\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.operator.cant.be.applied", "\u5358\u9805\u6F14\u7B97\u5B50''{0}''\u306E\u30AA\u30DA\u30E9\u30F3\u30C9\u578B{1}\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.operator.cant.be.applied.1", "\u4E8C\u9805\u6F14\u7B97\u5B50''{0}''\u306E\u30AA\u30DA\u30E9\u30F3\u30C9\u578B\u304C\u4E0D\u6B63\u3067\u3059\n\u6700\u521D\u306E\u578B: {1}\n2\u756A\u76EE\u306E\u578B: {2}" },
{ "compiler.err.orphaned", "{0}\u306B\u306F\u89AA\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.override.incompatible.ret", "{0}\n\u623B\u308A\u5024\u306E\u578B{1}\u306F{2}\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.override.meth", "{0}\n\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u306F{1}\u3067\u3059" },
{ "compiler.err.override.meth.doesnt.throw", "{0}\n\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u306F{1}\u3092\u30B9\u30ED\u30FC\u3057\u307E\u305B\u3093" },
{ "compiler.err.override.static", "{0}\n\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B\u30E1\u30BD\u30C3\u30C9\u304Cstatic\u3067\u3059" },
{ "compiler.err.override.weaker.access", "{0}\n({1})\u3088\u308A\u5F31\u3044\u30A2\u30AF\u30BB\u30B9\u6A29\u9650\u3092\u5272\u308A\u5F53\u3066\u3088\u3046\u3068\u3057\u307E\u3057\u305F" },
{ "compiler.err.pkg.annotations.sb.in.package-info.java", "\u30D1\u30C3\u30B1\u30FC\u30B8\u306E\u6CE8\u91C8\u306F\u30D5\u30A1\u30A4\u30EBpackage-info.java\u5185\u306B\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.pkg.clashes.with.class.of.same.name", "\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u306F\u540C\u540D\u306E\u30AF\u30E9\u30B9\u3068\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.err.premature.eof", "\u69CB\u6587\u89E3\u6790\u4E2D\u306B\u30D5\u30A1\u30A4\u30EB\u306E\u7D42\u308F\u308A\u306B\u79FB\u308A\u307E\u3057\u305F" },
{ "compiler.err.prob.found.req", "\u4E0D\u9069\u5408\u306A\u578B: {0}" },
{ "compiler.err.proc.bad.config.file", "\u30B5\u30FC\u30D3\u30B9\u69CB\u6210\u30D5\u30A1\u30A4\u30EB\u304C\u4E0D\u6B63\u3067\u3042\u308B\u304B\u3001\u30D7\u30ED\u30BB\u30C3\u30B5\u30FB\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u306E\u69CB\u7BC9\u4E2D\u306B\u4F8B\u5916\u304C\u30B9\u30ED\u30FC\u3055\u308C\u307E\u3057\u305F: {0}" },
{ "compiler.err.proc.cant.access", "{0}\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093\n{1}\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n{2}" },
{ "compiler.err.proc.cant.access.1", "{0}\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093\n{1}" },
{ "compiler.err.proc.cant.create.loader", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u306E\u30AF\u30E9\u30B9\u30FB\u30ED\u30FC\u30C0\u30FC\u3092\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F: {0}" },
{ "compiler.err.proc.cant.find.class", "''{0}''\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F\u3002" },
{ "compiler.err.proc.messager", "{0}" },
{ "compiler.err.proc.no.explicit.annotation.processing.requested", "\u30AF\u30E9\u30B9\u540D''{0}''\u304C\u53D7\u3051\u5165\u308C\u3089\u308C\u308B\u306E\u306F\u3001\u6CE8\u91C8\u51E6\u7406\u304C\u660E\u793A\u7684\u306B\u30EA\u30AF\u30A8\u30B9\u30C8\u3055\u308C\u305F\u5834\u5408\u306E\u307F\u3067\u3059" },
{ "compiler.err.proc.no.service", "\u30B5\u30FC\u30D3\u30B9\u30FB\u30ED\u30FC\u30C0\u30FC\u304C\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F\u304C\u3001\u6CE8\u91C8\u51E6\u7406\u306B\u5FC5\u8981\u3067\u3059\u3002" },
{ "compiler.err.proc.processor.bad.option.name", "\u30D7\u30ED\u30BB\u30C3\u30B5''{1}''\u306B\u3088\u3063\u3066\u6307\u5B9A\u3055\u308C\u305F\u30AA\u30D7\u30B7\u30E7\u30F3\u540D''{0}''\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.err.proc.processor.cant.instantiate", "\u30D7\u30ED\u30BB\u30C3\u30B5''{0}''\u306E\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u3092\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F" },
{ "compiler.err.proc.processor.not.found", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5''{0}''\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
{ "compiler.err.proc.processor.wrong.type", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5''{0}''\u304Cjavax.annotation.processing.Processor\u3092\u5B9F\u88C5\u3057\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.proc.service.problem", "\u30D7\u30ED\u30BB\u30C3\u30B5\u3092\u30ED\u30FC\u30C9\u3059\u308B\u305F\u3081\u306E\u30B5\u30FC\u30D3\u30B9\u30FB\u30ED\u30FC\u30C0\u30FC\u3092\u4F5C\u6210\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002" },
{ "compiler.err.qualified.new.of.static.class", "static\u30AF\u30E9\u30B9\u306Enew\u304C\u4FEE\u98FE\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class", "\u53D7\u53D6\u308A\u5074\u30D1\u30E9\u30E1\u30FC\u30BF\u306F\u6700\u4E0A\u4F4D\u30EC\u30D9\u30EB\u30FB\u30AF\u30E9\u30B9\u306E\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306B\u9069\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.recursive.ctor.invocation", "\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u547C\u51FA\u3057\u304C\u518D\u5E30\u7684\u3067\u3059" },
{ "compiler.err.ref.ambiguous", "{0}\u306E\u53C2\u7167\u306F\u3042\u3044\u307E\u3044\u3067\u3059\n{3}\u306E{1} {2}\u3068{6}\u306E{4} {5}\u306E\u4E21\u65B9\u304C\u4E00\u81F4\u3057\u307E\u3059" },
{ "compiler.err.repeatable.annotations.not.supported.in.source", "\u7E70\u8FD4\u3057\u6CE8\u91C8\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u7E70\u8FD4\u3057\u6CE8\u91C8\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.repeated.annotation.target", "\u6CE8\u91C8\u30BF\u30FC\u30B2\u30C3\u30C8\u304C\u7E70\u308A\u8FD4\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.repeated.interface", "\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u304C\u7E70\u308A\u8FD4\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.repeated.modifier", "\u4FEE\u98FE\u5B50\u304C\u7E70\u308A\u8FD4\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.err.report.access", "{0}\u306F{2}\u3067{1}\u30A2\u30AF\u30BB\u30B9\u3055\u308C\u307E\u3059" },
{ "compiler.err.ret.outside.meth", "\u30E1\u30BD\u30C3\u30C9\u306E\u5916\u306Ereturn\u6587\u3067\u3059" },
{ "compiler.err.signature.doesnt.match.intf", "\u30B7\u30B0\u30CD\u30C1\u30E3\u304C{0}\u306B\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002\u4E0D\u9069\u5408\u306A\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3067\u3059" },
{ "compiler.err.signature.doesnt.match.supertype", "\u30B7\u30B0\u30CD\u30C1\u30E3\u304C{0}\u306B\u4E00\u81F4\u3057\u307E\u305B\u3093\u3002\u4E0D\u9069\u5408\u306A\u30B9\u30FC\u30D1\u30FC\u30BF\u30A4\u30D7\u3067\u3059" },
{ "compiler.err.source.cant.overwrite.input.file", "\u30BD\u30FC\u30B9\u306E\u66F8\u8FBC\u307F\u30A8\u30E9\u30FC\u3067\u3059\u3002\u5165\u529B\u30D5\u30A1\u30A4\u30EB{0}\u3092\u4E0A\u66F8\u304D\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.stack.sim.error", "\u5185\u90E8\u30A8\u30E9\u30FC: {0}\u3067\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30B7\u30DF\u30E5\u30EC\u30FC\u30B7\u30E7\u30F3\u30FB\u30A8\u30E9\u30FC" },
{ "compiler.err.static.imp.only.classes.and.interfaces", "static import\u306F\u30AF\u30E9\u30B9\u3068\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u304B\u3089\u306E\u307F\u3068\u306A\u308A\u307E\u3059" },
{ "compiler.err.static.import.not.supported.in.source", "static import\u5BA3\u8A00\u306F -source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(static import\u5BA3\u8A00\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.static.intf.method.invoke.not.supported.in.source", "static\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u30FB\u30E1\u30BD\u30C3\u30C9\u547C\u51FA\u3057\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(static\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u30FB\u30E1\u30BD\u30C3\u30C9\u547C\u51FA\u3057\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.static.intf.methods.not.supported.in.source", "static\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(static\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.string.const.req", "\u5B9A\u6570\u306E\u6587\u5B57\u5217\u5F0F\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.err.string.switch.not.supported.in.source", "switch\u5185\u306E\u6587\u5B57\u5217\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(switch\u5185\u306E\u6587\u5B57\u5217\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.synthetic.name.conflict", "\u30B7\u30F3\u30DC\u30EB{0}\u304C\u3001{1}\u3067\u30B3\u30F3\u30D1\u30A4\u30E9\u304C\u5408\u6210\u3057\u305F\u30B7\u30F3\u30DC\u30EB\u3068\u7AF6\u5408\u3057\u307E\u3059" },
{ "compiler.err.this.as.identifier", "\u30EA\u30EA\u30FC\u30B98\u304B\u3089''this''\u306F\u53D7\u4FE1\u30BF\u30A4\u30D7\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u540D\u3068\u3057\u3066\u306E\u307F\u8A31\u53EF\u3055\u308C\u3001\u6700\u521D\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.throws.not.allowed.in.intf.annotation", "throws\u7BC0\u3092@interface\u30E1\u30F3\u30D0\u30FC\u3067\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.try.resource.may.not.be.assigned", "\u81EA\u52D5\u30AF\u30ED\u30FC\u30BA\u53EF\u80FD\u306A\u30EA\u30BD\u30FC\u30B9{0}\u306B\u5024\u3092\u4EE3\u5165\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.try.with.resources.not.supported.in.source", "try-with-resource\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(try-with-resource\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.try.without.catch.finally.or.resource.decls", "''try''\u3078\u306E''catch''\u3001''finally''\u307E\u305F\u306F\u30EA\u30BD\u30FC\u30B9\u5BA3\u8A00\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.try.without.catch.or.finally", "''try''\u3078\u306E''catch''\u307E\u305F\u306F''finally''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.type.annotations.not.supported.in.source", "\u30BF\u30A4\u30D7\u6CE8\u91C8\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30BF\u30A4\u30D7\u6CE8\u91C8\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 8\u4EE5\u4E0A\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.type.doesnt.take.params", "\u578B{0}\u306F\u30D1\u30E9\u30E1\u30FC\u30BF\u3092\u3068\u308A\u307E\u305B\u3093" },
{ "compiler.err.type.found.req", "\u4E88\u671F\u3057\u306A\u3044\u578B\n\u671F\u5F85\u5024: {1}\n\u691C\u51FA\u5024: {0}" },
{ "compiler.err.type.var.cant.be.deref", "\u578B\u5909\u6570\u304B\u3089\u9078\u629E\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.type.var.may.not.be.followed.by.other.bounds", "\u3053\u306E\u578B\u5909\u6570\u306E\u5F8C\u308D\u306B\u4ED6\u306E\u5883\u754C\u3092\u914D\u7F6E\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.type.var.more.than.once", "\u578B\u5909\u6570{0}\u306F{1}\u306E\u623B\u308A\u5024\u306E\u578B\u30672\u56DE\u4EE5\u4E0A\u51FA\u73FE\u3057\u307E\u3059\u3002\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u751F\u6210\u3055\u308C\u306A\u3044\u307E\u307E\u306B\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.type.var.more.than.once.in.result", "\u578B\u5909\u6570{0}\u306F{1}\u306E\u578B\u30672\u56DE\u4EE5\u4E0A\u51FA\u73FE\u3057\u307E\u3059\u3002\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u751F\u6210\u3055\u308C\u306A\u3044\u307E\u307E\u306B\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.types.incompatible.abstract.default", "{0} {1}\u306F\u578B{4}\u3068{5}\u304B\u3089{2}({3})\u306E\u62BD\u8C61\u3068\u30C7\u30D5\u30A9\u30EB\u30C8\u3092\u7D99\u627F\u3057\u307E\u3059" },
{ "compiler.err.types.incompatible.diff.ret", "\u578B{0}\u3068\u578B{1}\u304C\u9069\u5408\u3057\u3066\u3044\u307E\u305B\u3093\u3002\u4E21\u65B9\u3068\u3082{2}\u3092\u5B9A\u7FA9\u3057\u3066\u3044\u307E\u3059\u304C\u3001\u623B\u308A\u5024\u306E\u578B\u304C\u7121\u95A2\u4FC2\u3067\u3059" },
{ "compiler.err.types.incompatible.unrelated.defaults", "{0} {1}\u306F\u578B{4}\u3068{5}\u304B\u3089{2}({3})\u306E\u95A2\u9023\u3057\u306A\u3044\u30C7\u30D5\u30A9\u30EB\u30C8\u3092\u7D99\u627F\u3057\u307E\u3059" },
{ "compiler.err.unclosed.char.lit", "\u6587\u5B57\u30EA\u30C6\u30E9\u30EB\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.unclosed.comment", "\u30B3\u30E1\u30F3\u30C8\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.unclosed.str.lit", "\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.undef.label", "\u30E9\u30D9\u30EB{0}\u306F\u672A\u5B9A\u7FA9\u3067\u3059" },
{ "compiler.err.underscore.as.identifier.in.lambda", "''_''\u304C\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3055\u308C\u3066\u3044\u307E\u3059\n(\u30E9\u30E0\u30C0\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u306F''_''\u3092\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u7981\u6B62\u3055\u308C\u3066\u3044\u307E\u3059)" },
{ "compiler.err.unexpected.lambda", "\u3053\u3053\u3067\u306F\u30E9\u30E0\u30C0\u5F0F\u306F\u4E88\u671F\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.unexpected.mref", "\u3053\u3053\u3067\u306F\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306F\u4E88\u671F\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.unexpected.type", "\u4E88\u671F\u3057\u306A\u3044\u578B\n\u671F\u5F85\u5024: {0}\n\u691C\u51FA\u5024: {1}" },
{ "compiler.err.unreachable.stmt", "\u3053\u306E\u6587\u306B\u5236\u5FA1\u304C\u79FB\u308B\u3053\u3068\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.err.unreported.exception.default.constructor", "\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u5185\u306B\u5831\u544A\u3055\u308C\u306A\u3044\u4F8B\u5916{0}\u304C\u5B58\u5728\u3057\u307E\u3059" },
{ "compiler.err.unreported.exception.implicit.close", "\u5831\u544A\u3055\u308C\u306A\u3044\u4F8B\u5916{0}\u306F\u3001\u30B9\u30ED\u30FC\u3059\u308B\u306B\u306F\u6355\u6349\u307E\u305F\u306F\u5BA3\u8A00\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\n\u30EA\u30BD\u30FC\u30B9\u5909\u6570''{1}''\u3067\u306Eclose()\u306E\u6697\u9ED9\u7684\u306A\u30B3\u30FC\u30EB\u304B\u3089\u4F8B\u5916\u304C\u30B9\u30ED\u30FC\u3055\u308C\u307E\u3057\u305F" },
{ "compiler.err.unreported.exception.need.to.catch.or.throw", "\u4F8B\u5916{0}\u306F\u5831\u544A\u3055\u308C\u307E\u305B\u3093\u3002\u30B9\u30ED\u30FC\u3059\u308B\u306B\u306F\u3001\u6355\u6349\u307E\u305F\u306F\u5BA3\u8A00\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.unsupported.binary.lit", "2\u9032\u6570\u30EA\u30C6\u30E9\u30EB\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(2\u9032\u6570\u30EA\u30C6\u30E9\u30EB\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.unsupported.cross.fp.lit", "16\u9032\u6D6E\u52D5\u5C0F\u6570\u70B9\u30EA\u30C6\u30E9\u30EB\u306F\u3053\u306EVM\u3067\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.unsupported.encoding", "\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u306A\u3044\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0\u3067\u3059: {0}" },
{ "compiler.err.unsupported.fp.lit", "16\u9032\u6570\u6D6E\u52D5\u5C0F\u6570\u70B9\u30EA\u30C6\u30E9\u30EB\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(16\u9032\u6570\u6D6E\u52D5\u5C0F\u6570\u70B9\u30EA\u30C6\u30E9\u30EB\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.unsupported.underscore.lit", "\u30EA\u30C6\u30E9\u30EB\u5185\u306E\u30A2\u30F3\u30C0\u30FC\u30B9\u30B3\u30A2\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u30EA\u30C6\u30E9\u30EB\u5185\u306E\u30A2\u30F3\u30C0\u30FC\u30B9\u30B3\u30A2\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 7\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.var.might.already.be.assigned", "\u5909\u6570{0}\u306F\u3059\u3067\u306B\u4EE3\u5165\u3055\u308C\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.var.might.be.assigned.in.loop", "\u5909\u6570{0}\u306F\u30EB\u30FC\u30D7\u5185\u3067\u4EE3\u5165\u3055\u308C\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.var.might.not.have.been.initialized", "\u5909\u6570{0}\u306F\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.err.var.not.initialized.in.default.constructor", "\u5909\u6570{0}\u306F\u3001\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u3067\u521D\u671F\u5316\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.err.varargs.and.old.array.syntax", "\u65E7\u5F0F\u306E\u914D\u5217\u8868\u8A18\u6CD5\u306F\u53EF\u5909\u5F15\u6570\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.varargs.and.receiver", "varargs\u8868\u8A18\u306F\u53D7\u53D6\u308A\u5074\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.varargs.invalid.trustme.anno", "{0}\u6CE8\u91C8\u304C\u7121\u52B9\u3067\u3059\u3002{1}" },
{ "compiler.err.varargs.not.supported.in.source", "\u53EF\u5909\u5F15\u6570\u30E1\u30BD\u30C3\u30C9\u306F-source {0}\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093\n(\u53EF\u5909\u5F15\u6570\u30E1\u30BD\u30C3\u30C9\u3092\u4F7F\u7528\u53EF\u80FD\u306B\u3059\u308B\u306B\u306F\u3001-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.err.variable.not.allowed", "\u5909\u6570\u306E\u5BA3\u8A00\u3092\u3053\u3053\u3067\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.void.not.allowed.here", "\u3053\u3053\u3067''void''\u578B\u3092\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.err.warnings.and.werror", "\u8B66\u544A\u304C\u898B\u3064\u304B\u308A-Werror\u304C\u6307\u5B9A\u3055\u308C\u307E\u3057\u305F" },
{ "compiler.err.wrong.number.type.args", "\u578B\u5F15\u6570\u306E\u6570\u304C\u4E0D\u6B63\u3067\u3059\u3002{0}\u500B\u5FC5\u8981\u3067\u3059" },
{ "compiler.misc.anonymous.class", "<anonymous {0}>" },
{ "compiler.misc.applicable.method.found", "#{0}\u500B\u306E\u4F7F\u7528\u53EF\u80FD\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F: {1}" },
{ "compiler.misc.applicable.method.found.1", "#{0}\u500B\u306E\u4F7F\u7528\u53EF\u80FD\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F: {1}\n({2})" },
{ "compiler.misc.arg.length.mismatch", "\u5B9F\u5F15\u6570\u30EA\u30B9\u30C8\u3068\u4EEE\u5F15\u6570\u30EA\u30B9\u30C8\u306E\u9577\u3055\u304C\u7570\u306A\u308A\u307E\u3059" },
{ "compiler.misc.bad.class.file.header", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB{0}\u306F\u4E0D\u6B63\u3067\u3059\n{1}\n\u524A\u9664\u3059\u308B\u304B\u3001\u30AF\u30E9\u30B9\u30D1\u30B9\u306E\u6B63\u3057\u3044\u30B5\u30D6\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u3042\u308B\u304B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.misc.bad.class.signature", "\u30AF\u30E9\u30B9{0}\u306E\u30B7\u30B0\u30CD\u30C1\u30E3\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.bad.const.pool.entry", "{0}\u306E\u5B9A\u6570\u30D7\u30FC\u30EB\u30FB\u30A8\u30F3\u30C8\u30EA\u304C\u4E0D\u6B63\u3067\u3059\n\u7D22\u5F15{2}\u3067\u306F{1}\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.misc.bad.const.pool.tag", "\u5B9A\u6570\u30D7\u30FC\u30EB\u30FB\u30BF\u30B0{0}\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.bad.const.pool.tag.at", "\u5B9A\u6570\u30D7\u30FC\u30EB\u30FB\u30BF\u30B0{1}\u3067\u306E{0}\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.bad.enclosing.class", "{0}\u306E\u5185\u90E8\u30AF\u30E9\u30B9\u304C\u4E0D\u6B63\u3067\u3059: {1}" },
{ "compiler.misc.bad.enclosing.method", "\u30AF\u30E9\u30B9{0}\u306E\u56F2\u3093\u3067\u3044\u308B\u30E1\u30BD\u30C3\u30C9\u5C5E\u6027\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.bad.intersection.target.for.functional.expr", "\u30E9\u30E0\u30C0\u307E\u305F\u306F\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306E\u4EA4\u5DEE\u30BF\u30A4\u30D7\u30FB\u30BF\u30FC\u30B2\u30C3\u30C8\u304C\u4E0D\u6B63\u3067\u3059\n{0}" },
{ "compiler.misc.bad.runtime.invisible.param.annotations", "RuntimeInvisibleParameterAnnotations\u5C5E\u6027\u304C\u4E0D\u6B63\u3067\u3059: {0}" },
{ "compiler.misc.bad.signature", "\u30B7\u30B0\u30CD\u30C1\u30E3{0}\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.bad.source.file.header", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB{0}\u306F\u4E0D\u6B63\u3067\u3059\n{1}\n\u524A\u9664\u3059\u308B\u304B\u3001\u30BD\u30FC\u30B9\u30FB\u30D1\u30B9\u306E\u6B63\u3057\u3044\u30B5\u30D6\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u3042\u308B\u304B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.misc.bad.type.annotation.value", "\u6CE8\u91C8\u30BF\u30FC\u30B2\u30C3\u30C8\u578B\u306E\u5024\u306E\u578B\u304C\u4E0D\u6B63\u3067\u3059: {0}" },
{ "compiler.misc.base.membership", "\u3059\u3079\u3066\u306E\u30D9\u30FC\u30B9\u30FB\u30AF\u30E9\u30B9\u304C\u30E1\u30F3\u30D0\u30FC\u3067\u3059" },
{ "compiler.misc.cant.access.inner.cls.constr", "\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF{0}({1})\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093\n\u5185\u90E8\u30AF\u30E9\u30B9\u3092\u56F2\u3080\u578B{2}\u306E\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u30B9\u30B3\u30FC\u30D7\u5185\u306B\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.misc.cant.apply.diamond.1", "{0}\u306E\u578B\u5F15\u6570\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093\n\u7406\u7531: {1}" },
{ "compiler.misc.cant.apply.symbol", "{4} {5}\u306E{0} {1}\u306F\u6307\u5B9A\u3055\u308C\u305F\u578B\u306B\u9069\u7528\u3067\u304D\u307E\u305B\u3093\n\u671F\u5F85\u5024: {2}\n\u691C\u51FA\u5024: {3}\n\u7406\u7531: {6}" },
{ "compiler.misc.cant.apply.symbols", "{1}\u306B\u9069\u5207\u306A{0}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093({2})" },
{ "compiler.misc.cant.implement", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u5B9F\u88C5\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.cant.override", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.cant.resolve.location.args", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} {1}({3})\n\u5834\u6240: {4}" },
{ "compiler.misc.cant.resolve.location.args.params", "\u30B7\u30F3\u30DC\u30EB\u3092\u898B\u3064\u3051\u3089\u308C\u307E\u305B\u3093\n\u30B7\u30F3\u30DC\u30EB: {0} <{2}>{1}({3})\n\u5834\u6240: {4}" },
{ "compiler.misc.captured.type", "CAP#{0}" },
{ "compiler.misc.ccf.found.later.version", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB{0}\u306B\u4E88\u60F3\u5916\u306E\u65B0\u30D0\u30FC\u30B8\u30E7\u30F3\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.misc.ccf.unrecognized.attribute", "{0}\u306F\u8A8D\u8B58\u3055\u308C\u306A\u3044\u5C5E\u6027\u3067\u3059" },
{ "compiler.misc.clashes.with", "{1}\u306E{0}\u306F{3}\u306E{2}\u3068\u7AF6\u5408\u3057\u307E\u3059" },
{ "compiler.misc.class.file.not.found", "{0}\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
{ "compiler.misc.class.file.wrong.class", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB{0}\u306B\u4E0D\u6B63\u306A\u30AF\u30E9\u30B9\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.misc.conditional.target.cant.be.void", "\u6761\u4EF6\u5F0F\u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u578B\u306Fvoid\u306B\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.count.error", "\u30A8\u30E9\u30FC{0}\u500B" },
{ "compiler.misc.count.error.plural", "\u30A8\u30E9\u30FC{0}\u500B" },
{ "compiler.misc.count.warn", "\u8B66\u544A{0}\u500B" },
{ "compiler.misc.count.warn.plural", "\u8B66\u544A{0}\u500B" },
{ "compiler.misc.descriptor", "\u30C7\u30A3\u30B9\u30AF\u30EA\u30D7\u30BF: {2} {0}({1})" },
{ "compiler.misc.descriptor.throws", "\u30C7\u30A3\u30B9\u30AF\u30EA\u30D7\u30BF: {2} {0}({1})\u3067{3}\u304C\u30B9\u30ED\u30FC\u3055\u308C\u307E\u3059" },
{ "compiler.misc.diamond", "{0}<>" },
{ "compiler.misc.diamond.and.anon.class", "\u533F\u540D\u5185\u90E8\u30AF\u30E9\u30B9\u3067\u306F''<>''\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.diamond.and.explicit.params", "\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u660E\u793A\u7684\u306A\u578B\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u306F''<>''\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.diamond.non.generic", "\u975E\u6C4E\u7528\u30AF\u30E9\u30B9{0}\u3067''<>''\u3092\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.explicit.param.do.not.conform.to.bounds", "\u660E\u793A\u7684\u306A\u578B\u5F15\u6570{0}\u306F\u3001\u5BA3\u8A00\u3055\u308C\u305F\u5883\u754C{1}\u306B\u9069\u5408\u3057\u307E\u305B\u3093" },
{ "compiler.misc.fatal.err.cant.close", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC: \u30B3\u30F3\u30D1\u30A4\u30E9\u30FB\u30EA\u30BD\u30FC\u30B9\u3092\u9589\u3058\u308B\u3053\u3068\u304C\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.fatal.err.cant.locate.ctor", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC: {0}\u306E\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u3092\u691C\u51FA\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.fatal.err.cant.locate.field", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC: \u30D5\u30A3\u30FC\u30EB\u30C9{0}\u3092\u691C\u51FA\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.fatal.err.cant.locate.meth", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC: \u30E1\u30BD\u30C3\u30C9{0}\u3092\u691C\u51FA\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.fatal.err.no.java.lang", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC: \u30AF\u30E9\u30B9\u30D1\u30B9\u307E\u305F\u306F\u30D6\u30FC\u30C8\u30FB\u30AF\u30E9\u30B9\u30D1\u30B9\u3067\u30D1\u30C3\u30B1\u30FC\u30B8java.lang\u3092\u691C\u51FA\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.file.does.not.contain.package", "\u30D5\u30A1\u30A4\u30EB\u306B\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.misc.file.doesnt.contain.class", "\u30D5\u30A1\u30A4\u30EB\u306B\u30AF\u30E9\u30B9{0}\u304C\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.misc.illegal.start.of.class.file", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u958B\u59CB\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.misc.inaccessible.varargs.type", "\u4EEE\u53EF\u5909\u5F15\u6570\u8981\u7D20\u578B{0}\u306F{1} {2}\u304B\u3089\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.inapplicable.method", "{0} {1}.{2}\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\n({3})" },
{ "compiler.misc.incompatible.abstracts", "{0} {1}\u3067\u8907\u6570\u306E\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u306A\u3044\u62BD\u8C61\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.misc.incompatible.arg.types.in.lambda", "\u30E9\u30E0\u30C0\u5F0F\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u578B\u306F\u4E0D\u9069\u5408\u3067\u3059" },
{ "compiler.misc.incompatible.arg.types.in.mref", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u578B\u306F\u4E0D\u9069\u5408\u3067\u3059" },
{ "compiler.misc.incompatible.descs.in.functional.intf", "{0} {1}\u3067\u4E0D\u9069\u5408\u306A\u6A5F\u80FD\u30C7\u30A3\u30B9\u30AF\u30EA\u30D7\u30BF\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.misc.incompatible.eq.lower.bounds", "\u63A8\u8AD6\u5909\u6570{0}\u306B\u306F\u3001\u4E0D\u9069\u5408\u306A\u5883\u754C\u304C\u3042\u308A\u307E\u3059\n\u7B49\u4FA1\u5236\u7D04: {1}\n\u4E0B\u9650: {2}" },
{ "compiler.misc.incompatible.eq.upper.bounds", "\u63A8\u8AD6\u5909\u6570{0}\u306B\u306F\u3001\u4E0D\u9069\u5408\u306A\u5883\u754C\u304C\u3042\u308A\u307E\u3059\n\u7B49\u4FA1\u5236\u7D04: {1}\n\u4E0A\u9650: {2}" },
{ "compiler.misc.incompatible.ret.type.in.lambda", "\u30E9\u30E0\u30C0\u5F0F\u306E\u623B\u308A\u578B\u304C\u4E0D\u6B63\u3067\u3059\n{0}" },
{ "compiler.misc.incompatible.ret.type.in.mref", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306E\u623B\u308A\u578B\u304C\u4E0D\u6B63\u3067\u3059\n{0}" },
{ "compiler.misc.incompatible.type.in.conditional", "\u6761\u4EF6\u5F0F\u306E\u578B\u304C\u4E0D\u6B63\u3067\u3059\n{0}" },
{ "compiler.misc.incompatible.upper.bounds", "\u63A8\u8AD6\u5909\u6570{0}\u306B\u306F\u3001\u4E0D\u9069\u5408\u306A\u4E0A\u9650{1}\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.misc.inconvertible.types", "{0}\u3092{1}\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093:" },
{ "compiler.misc.infer.arg.length.mismatch", "\u578B\u5909\u6570{0}\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093\n(\u5B9F\u5F15\u6570\u30EA\u30B9\u30C8\u3068\u4EEE\u5F15\u6570\u30EA\u30B9\u30C8\u306E\u9577\u3055\u304C\u7570\u306A\u308A\u307E\u3059)" },
{ "compiler.misc.infer.no.conforming.assignment.exists", "\u578B\u5909\u6570{0}\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093\n(\u5F15\u6570\u306E\u4E0D\u4E00\u81F4: {1})" },
{ "compiler.misc.infer.no.conforming.instance.exists", "\u578B\u5909\u6570{0}\u306E\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u5B58\u5728\u3057\u306A\u3044\u306E\u3067\u3001{1}\u306F{2}\u306B\u9069\u5408\u3057\u307E\u305B\u3093" },
{ "compiler.misc.infer.varargs.argument.mismatch", "\u578B\u5909\u6570{0}\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093\n(\u53EF\u5909\u5F15\u6570\u306E\u4E0D\u4E00\u81F4: {1})" },
{ "compiler.misc.inferred.do.not.conform.to.eq.bounds", "\u63A8\u8AD6\u578B\u304C\u7B49\u4FA1\u5236\u7D04\u306B\u9069\u5408\u3057\u307E\u305B\u3093\n\u63A8\u8AD6: {0}\n\u7B49\u4FA1\u5236\u7D04: {1}" },
{ "compiler.misc.inferred.do.not.conform.to.lower.bounds", "\u63A8\u8AD6\u578B\u304C\u4E0B\u9650\u306B\u9069\u5408\u3057\u307E\u305B\u3093\n\u63A8\u8AD6: {0}\n\u4E0B\u9650: {1}" },
{ "compiler.misc.inferred.do.not.conform.to.upper.bounds", "\u63A8\u8AD6\u578B\u304C\u4E0A\u9650\u306B\u9069\u5408\u3057\u307E\u305B\u3093\n\u63A8\u8AD6: {0}\n\u4E0A\u9650: {1}" },
{ "compiler.misc.inner.cls", "\u5185\u90E8\u30AF\u30E9\u30B9" },
{ "compiler.misc.intersection.type", "INT#{0}" },
{ "compiler.misc.invalid.default.interface", "\u30D0\u30FC\u30B8\u30E7\u30F3{0}.{1}\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306B\u30C7\u30D5\u30A9\u30EB\u30C8\u30FB\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.misc.invalid.generic.lambda.target", "\u30E9\u30E0\u30C0\u5F0F\u306E\u6A5F\u80FD\u30C7\u30A3\u30B9\u30AF\u30EA\u30D7\u30BF\u304C\u7121\u52B9\u3067\u3059\n{1} {2}\u306E\u30E1\u30BD\u30C3\u30C9{0}\u306F\u6C4E\u7528\u3067\u3059" },
{ "compiler.misc.invalid.mref", "{0}\u53C2\u7167\u304C\u7121\u52B9\u3067\u3059\n{1}" },
{ "compiler.misc.invalid.static.interface", "\u30D0\u30FC\u30B8\u30E7\u30F3{0}.{1}\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306Bstatic\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.misc.kindname.annotation", "@interface" },
{ "compiler.misc.kindname.class", "\u30AF\u30E9\u30B9" },
{ "compiler.misc.kindname.constructor", "\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF" },
{ "compiler.misc.kindname.enum", "\u5217\u6319" },
{ "compiler.misc.kindname.instance.init", "\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u521D\u671F\u5316\u5B50" },
{ "compiler.misc.kindname.interface", "\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9" },
{ "compiler.misc.kindname.method", "\u30E1\u30BD\u30C3\u30C9" },
{ "compiler.misc.kindname.package", "\u30D1\u30C3\u30B1\u30FC\u30B8" },
{ "compiler.misc.kindname.static", "static" },
{ "compiler.misc.kindname.static.init", "static\u521D\u671F\u5316\u5B50" },
{ "compiler.misc.kindname.type.variable", "\u578B\u5909\u6570" },
{ "compiler.misc.kindname.type.variable.bound", "\u578B\u5909\u6570\u306E\u5883\u754C" },
{ "compiler.misc.kindname.value", "\u5024" },
{ "compiler.misc.kindname.variable", "\u5909\u6570" },
{ "compiler.misc.lambda", "\u30E9\u30E0\u30C0\u5F0F" },
{ "compiler.misc.location", "{0} {1}" },
{ "compiler.misc.location.1", "\u30BF\u30A4\u30D7{2}\u306E{0} {1}" },
{ "compiler.misc.missing.ret.val", "\u623B\u308A\u5024\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.misc.mref.infer.and.explicit.params", "\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u306E\u660E\u793A\u7684\u306A\u578B\u30D1\u30E9\u30E1\u30FC\u30BF\u3067\u306Fraw\u30B3\u30F3\u30B9\u30C8\u30E9\u30AF\u30BF\u53C2\u7167\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.no.abstracts", "{0} {1}\u3067\u62BD\u8C61\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
{ "compiler.misc.no.args", "\u5F15\u6570\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.misc.no.conforming.assignment.exists", "\u5F15\u6570\u306E\u4E0D\u4E00\u81F4: {0}" },
{ "compiler.misc.no.suitable.functional.intf.inst", "{0}\u306E\u6A5F\u80FD\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u30FB\u30C7\u30A3\u30B9\u30AF\u30EA\u30D7\u30BF\u3092\u63A8\u8AD6\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.no.unique.maximal.instance.exists", "\u578B\u5909\u6570{0}(\u4E0A\u9650{1})\u306E\u56FA\u6709\u306E\u6700\u5927\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u5B58\u5728\u3057\u307E\u305B\u3093" },
{ "compiler.misc.no.unique.minimal.instance.exists", "\u578B\u5909\u6570{0}(\u4E0B\u9650{1})\u306E\u56FA\u6709\u306E\u6700\u5C0F\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u304C\u5B58\u5728\u3057\u307E\u305B\u3093" },
{ "compiler.misc.non-static.cant.be.ref", "static\u3067\u306A\u3044{0} {1}\u3092static\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u304B\u3089\u53C2\u7167\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.not.a.functional.intf", "{0}\u306F\u6A5F\u80FD\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.misc.not.a.functional.intf.1", "{0}\u306F\u6A5F\u80FD\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093\n{1}" },
{ "compiler.misc.not.an.intf.component", "\u30B3\u30F3\u30DD\u30FC\u30CD\u30F3\u30C8\u30FB\u30BF\u30A4\u30D7{0}\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.misc.not.applicable.method.found", "#{0}\u500B\u306E\u4F7F\u7528\u3067\u304D\u306A\u3044\u30E1\u30BD\u30C3\u30C9\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F: {1}\n({2})" },
{ "compiler.misc.not.def.access.class.intf.cant.access", "{1}\u306E{0}\u304C\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u306A\u3044\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9\u306B\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.misc.not.def.public.cant.access", "{1}\u306E{0}\u306Fpublic\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002\u30D1\u30C3\u30B1\u30FC\u30B8\u5916\u304B\u3089\u306F\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.overridden.default", "{1}\u306E\u30E1\u30BD\u30C3\u30C9{0}\u306F\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u307E\u3059" },
{ "compiler.misc.partial.inst.sig", "\u90E8\u5206\u7684\u306B\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3055\u308C\u307E\u3057\u305F: {0}" },
{ "compiler.misc.possible.loss.of.precision", "\u7CBE\u5EA6\u304C\u5931\u308F\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B{0}\u304B\u3089{1}\u3078\u306E\u5909\u63DB" },
{ "compiler.misc.prob.found.req", "\u4E0D\u9069\u5408\u306A\u578B: {0}" },
{ "compiler.misc.redundant.supertype", "\u5197\u9577\u306A\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9{0}\u306F{1}\u306B\u3088\u3063\u3066\u62E1\u5F35\u3055\u308C\u307E\u3057\u305F" },
{ "compiler.misc.ref.ambiguous", "{0}\u306E\u53C2\u7167\u306F\u3042\u3044\u307E\u3044\u3067\u3059\n{3}\u306E{1} {2}\u3068{6}\u306E{4} {5}\u306E\u4E21\u65B9\u304C\u4E00\u81F4\u3057\u307E\u3059" },
{ "compiler.misc.report.access", "{0}\u306F{2}\u3067{1}\u30A2\u30AF\u30BB\u30B9\u3055\u308C\u307E\u3059" },
{ "compiler.misc.resume.abort", "R)\u518D\u958B,A)\u4E2D\u6B62>" },
{ "compiler.misc.source.unavailable", "(\u30BD\u30FC\u30B9\u304C\u5229\u7528\u4E0D\u53EF)" },
{ "compiler.misc.static.bound.mref", "static\u306E\u30D0\u30A4\u30F3\u30C7\u30A3\u30F3\u30B0\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u53C2\u7167" },
{ "compiler.misc.static.method.in.unbound.lookup", "\u975E\u30D0\u30A4\u30F3\u30C9\u691C\u7D22\u3067\u9759\u7684\u306A{0} {1}\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F" },
{ "compiler.misc.static.mref.with.targs", "static\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u306E\u30D1\u30E9\u30E1\u30FC\u30BF\u5316\u3055\u308C\u305F\u4FEE\u98FE\u5B50" },
{ "compiler.misc.token.bad-symbol", "<bad symbol>" },
{ "compiler.misc.token.character", "<character>" },
{ "compiler.misc.token.double", "<double>" },
{ "compiler.misc.token.end-of-input", "<end of input>" },
{ "compiler.misc.token.float", "<float>" },
{ "compiler.misc.token.identifier", "<identifier>" },
{ "compiler.misc.token.integer", "<integer>" },
{ "compiler.misc.token.long-integer", "<long integer>" },
{ "compiler.misc.token.string", "<string>" },
{ "compiler.misc.try.not.applicable.to.type", "try-with-resource\u306F\u5909\u6570\u578B\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\n({0})" },
{ "compiler.misc.type.captureof", "{1}\u306E\u30AD\u30E3\u30D7\u30C1\u30E3#{0}" },
{ "compiler.misc.type.captureof.1", "\u30AD\u30E3\u30D7\u30C1\u30E3#{0}" },
{ "compiler.misc.type.none", "<none>" },
{ "compiler.misc.type.null", "<null>" },
{ "compiler.misc.type.parameter", "\u578B\u30D1\u30E9\u30E1\u30FC\u30BF{0}" },
{ "compiler.misc.type.req.array.or.iterable", "\u914D\u5217\u307E\u305F\u306Fjava.lang.Iterable" },
{ "compiler.misc.type.req.class", "\u30AF\u30E9\u30B9" },
{ "compiler.misc.type.req.class.array", "\u30AF\u30E9\u30B9\u307E\u305F\u306F\u914D\u5217" },
{ "compiler.misc.type.req.exact", "\u5883\u754C\u306E\u306A\u3044\u30AF\u30E9\u30B9\u307E\u305F\u306F\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9" },
{ "compiler.misc.type.req.ref", "\u53C2\u7167" },
{ "compiler.misc.type.var", "{0}#{1}" },
{ "compiler.misc.unable.to.access.file", "\u30D5\u30A1\u30A4\u30EB{0}\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.misc.unchecked.assign", "\u7121\u691C\u67FB\u5909\u63DB" },
{ "compiler.misc.unchecked.cast.to.type", "\u7121\u691C\u67FB\u30AD\u30E3\u30B9\u30C8" },
{ "compiler.misc.unchecked.clash.with", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059" },
{ "compiler.misc.unchecked.implement", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u5B9F\u88C5\u3057\u307E\u3059" },
{ "compiler.misc.unchecked.override", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059" },
{ "compiler.misc.undecl.type.var", "\u578B\u5909\u6570{0}\u306F\u5BA3\u8A00\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.misc.unexpected.ret.val", "\u4E88\u671F\u3057\u306A\u3044\u623B\u308A\u5024" },
{ "compiler.misc.unicode.str.not.supported", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u5185\u306EUnicode\u6587\u5B57\u5217\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.misc.unnamed.package", "\u540D\u524D\u306E\u306A\u3044\u30D1\u30C3\u30B1\u30FC\u30B8" },
{ "compiler.misc.varargs.argument.mismatch", "\u53EF\u5909\u5F15\u6570\u306E\u4E0D\u4E00\u81F4: {0}" },
{ "compiler.misc.varargs.clash.with", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059" },
{ "compiler.misc.varargs.implement", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u5B9F\u88C5\u3057\u307E\u3059" },
{ "compiler.misc.varargs.override", "{1}\u306E{0}\u306F{3}\u306E{2}\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059" },
{ "compiler.misc.varargs.trustme.on.non.varargs.meth", "\u30E1\u30BD\u30C3\u30C9{0}\u306F\u53EF\u5909\u5F15\u6570\u30E1\u30BD\u30C3\u30C9\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002" },
{ "compiler.misc.varargs.trustme.on.reifiable.varargs", "\u53EF\u5909\u5F15\u6570\u8981\u7D20\u578B{0}\u306Freifiable\u578B\u3067\u3059\u3002" },
{ "compiler.misc.varargs.trustme.on.virtual.varargs", "\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u30FB\u30E1\u30BD\u30C3\u30C9{0}\u306Ffinal\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002" },
{ "compiler.misc.verbose.checking.attribution", "[{0}\u3092\u78BA\u8A8D\u4E2D]" },
{ "compiler.misc.verbose.classpath", "[\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u691C\u7D22\u30D1\u30B9: {0}]" },
{ "compiler.misc.verbose.loading", "[{0}\u3092\u8AAD\u8FBC\u307F\u4E2D]" },
{ "compiler.misc.verbose.parsing.done", "[{0}\u30DF\u30EA\u79D2\u3067\u69CB\u6587\u89E3\u6790\u5B8C\u4E86]" },
{ "compiler.misc.verbose.parsing.started", "[{0}\u3092\u69CB\u6587\u89E3\u6790\u958B\u59CB]" },
{ "compiler.misc.verbose.retro", "[{0}\u3092\u7D44\u66FF\u3048\u4E2D]" },
{ "compiler.misc.verbose.retro.with", "\t{0}\u3092{1}\u3067\u7D44\u66FF\u3048\u4E2D\u3067\u3059" },
{ "compiler.misc.verbose.retro.with.list", "\t{0}\u3092\u578B\u30D1\u30E9\u30E1\u30FC\u30BF{1}\u3001\u30B9\u30FC\u30D1\u30FC\u30BF\u30A4\u30D7{2}\u3001\u30A4\u30F3\u30BF\u30D5\u30A7\u30FC\u30B9{3}\u3067\u7D44\u66FF\u3048\u4E2D\u3067\u3059" },
{ "compiler.misc.verbose.sourcepath", "[\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u691C\u7D22\u30D1\u30B9: {0}]" },
{ "compiler.misc.verbose.total", "[\u5408\u8A08{0}\u30DF\u30EA\u79D2]" },
{ "compiler.misc.verbose.wrote.file", "[{0}\u3092\u66F8\u8FBC\u307F\u5B8C\u4E86]" },
{ "compiler.misc.version.not.available", "(\u30D0\u30FC\u30B8\u30E7\u30F3\u60C5\u5831\u304C\u3042\u308A\u307E\u305B\u3093)" },
{ "compiler.misc.where.captured", "{0}\u306F{3}\u306E\u30AD\u30E3\u30D7\u30C1\u30E3\u304B\u3089{1}\u3092\u62E1\u5F35\u3057{2}\u3092\u30B9\u30FC\u30D1\u30FC\u3057\u307E\u3059" },
{ "compiler.misc.where.captured.1", "{0}\u306F{3}\u306E\u30AD\u30E3\u30D7\u30C1\u30E3\u304B\u3089{1}\u3092\u62E1\u5F35\u3057\u307E\u3059" },
{ "compiler.misc.where.description.captured", "{0}\u304C\u65B0\u3057\u3044\u578B\u5909\u6570\u306E\u5834\u5408:" },
{ "compiler.misc.where.description.captured.1", "{0}\u304C\u65B0\u3057\u3044\u578B\u5909\u6570\u306E\u5834\u5408:" },
{ "compiler.misc.where.description.intersection", "{0}\u304Cintersection\u578B\u306E\u5834\u5408:" },
{ "compiler.misc.where.description.intersection.1", "{0}\u304Cintersection\u578B\u306E\u5834\u5408:" },
{ "compiler.misc.where.description.typevar", "{0}\u304C\u578B\u5909\u6570\u306E\u5834\u5408:" },
{ "compiler.misc.where.description.typevar.1", "{0}\u304C\u578B\u5909\u6570\u306E\u5834\u5408:" },
{ "compiler.misc.where.fresh.typevar", "{0}\u306F{1}\u3092\u62E1\u5F35\u3057\u307E\u3059" },
{ "compiler.misc.where.intersection", "{0}\u306F{1}\u3092\u62E1\u5F35\u3057\u307E\u3059" },
{ "compiler.misc.where.typevar", "{2} {3}\u3067\u5BA3\u8A00\u3055\u308C\u3066\u3044\u308B{0}\u306F{1}\u3092\u62E1\u5F35\u3057\u307E\u3059" },
{ "compiler.misc.where.typevar.1", "{2} {3}\u3067\u5BA3\u8A00\u3055\u308C\u305F{0}" },
{ "compiler.misc.wrong.version", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u30D0\u30FC\u30B8\u30E7\u30F3{0}.{1}\u306F\u4E0D\u6B63\u3067\u3059\u3002{2}.{3}\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.misc.x.print.processor.info", "\u30D7\u30ED\u30BB\u30C3\u30B5{0}\u306F{1}\u306B\u4E00\u81F4\u3057\u3001{2}\u3092\u8FD4\u3057\u307E\u3059\u3002" },
{ "compiler.misc.x.print.rounds", "\u5F80\u5FA9{0}:\n\t\u5165\u529B\u30D5\u30A1\u30A4\u30EB: {1}\n\t\u6CE8\u91C8: {2}\n\t\u6700\u5F8C\u306E\u5F80\u5FA9: {3}" },
{ "compiler.note.compressed.diags", "\u4E00\u90E8\u306E\u30E1\u30C3\u30BB\u30FC\u30B8\u306F\u7C21\u7565\u5316\u3055\u308C\u3066\u3044\u307E\u3059\u3002-Xdiags:verbose\u3067\u518D\u30B3\u30F3\u30D1\u30A4\u30EB\u3057\u3066\u5B8C\u5168\u306A\u51FA\u529B\u3092\u53D6\u5F97\u3057\u3066\u304F\u3060\u3055\u3044" },
{ "compiler.note.deferred.method.inst", "\u30E1\u30BD\u30C3\u30C9{0}\u306E\u9045\u5EF6\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\n\u30A4\u30F3\u30B9\u30BF\u30F3\u30B9\u5316\u3055\u308C\u305F\u30B7\u30B0\u30CD\u30C1\u30E3: {1}\n\u30BF\u30FC\u30B2\u30C3\u30C8\u578B: {2}" },
{ "compiler.note.deprecated.filename", "{0}\u306F\u975E\u63A8\u5968\u306EAPI\u3092\u4F7F\u7528\u307E\u305F\u306F\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.deprecated.filename.additional", "{0}\u306B\u975E\u63A8\u5968\u306EAPI\u306E\u8FFD\u52A0\u4F7F\u7528\u307E\u305F\u306F\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u304C\u3042\u308A\u307E\u3059\u3002" },
{ "compiler.note.deprecated.plural", "\u4E00\u90E8\u306E\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306F\u975E\u63A8\u5968\u306EAPI\u3092\u4F7F\u7528\u307E\u305F\u306F\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.deprecated.plural.additional", "\u4E00\u90E8\u306E\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306F\u975E\u63A8\u5968\u306EAPI\u3092\u8FFD\u52A0\u4F7F\u7528\u307E\u305F\u306F\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.deprecated.recompile", "\u8A73\u7D30\u306F\u3001-Xlint:deprecation\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6307\u5B9A\u3057\u3066\u518D\u30B3\u30F3\u30D1\u30A4\u30EB\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.note.lambda.stat", "\u30E9\u30E0\u30C0\u5F0F\u3092\u5909\u63DB\u3057\u3066\u3044\u307E\u3059\n\u4EE3\u66FFmetafactory = {0}\n\u5408\u6210\u30E1\u30BD\u30C3\u30C9 = {1}" },
{ "compiler.note.mref.stat", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u3092\u5909\u63DB\u3057\u3066\u3044\u307E\u3059\n\u4EE3\u66FFmetafactory = {0}\n" },
{ "compiler.note.mref.stat.1", "\u30E1\u30BD\u30C3\u30C9\u53C2\u7167\u3092\u5909\u63DB\u3057\u3066\u3044\u307E\u3059\n\u4EE3\u66FFmetafactory = {0}\n\u30D6\u30EA\u30C3\u30B8\u30FB\u30E1\u30BD\u30C3\u30C9 = {1}" },
{ "compiler.note.note", "\u6CE8\u610F:" },
{ "compiler.note.potential.lambda.found", "\u3053\u306E\u533F\u540D\u5185\u90E8\u30AF\u30E9\u30B9\u3092\u30E9\u30E0\u30C0\u5F0F\u306B\u5909\u63DB\u3067\u304D\u307E\u3059\u3002" },
{ "compiler.note.proc.messager", "{0}" },
{ "compiler.note.sunapi.filename", "{0}\u306F\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u5185\u90E8\u6240\u6709\u306EAPI\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.sunapi.filename.additional", "{0}\u306F\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u8FFD\u52A0\u306E\u5185\u90E8\u6240\u6709\u306EAPI\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.sunapi.plural", "\u4E00\u90E8\u306E\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306F\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u5185\u90E8\u6240\u6709\u306EAPI\u3092\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.sunapi.plural.additional", "\u4E00\u90E8\u306E\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306F\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u5185\u90E8\u6240\u6709\u306EAPI\u3092\u8FFD\u52A0\u3067\u4F7F\u7528\u3057\u3066\u3044\u307E\u3059\u3002" },
{ "compiler.note.sunapi.recompile", "\u8A73\u7D30\u306F\u3001-Xlint:sunapi\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6307\u5B9A\u3057\u3066\u518D\u30B3\u30F3\u30D1\u30A4\u30EB\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.note.unchecked.filename", "{0}\u306E\u64CD\u4F5C\u306F\u3001\u672A\u30C1\u30A7\u30C3\u30AF\u307E\u305F\u306F\u5B89\u5168\u3067\u306F\u3042\u308A\u307E\u305B\u3093\u3002" },
{ "compiler.note.unchecked.filename.additional", "{0}\u306B\u672A\u30C1\u30A7\u30C3\u30AF\u307E\u305F\u306F\u5B89\u5168\u3067\u306F\u306A\u3044\u64CD\u4F5C\u304C\u3055\u3089\u306B\u3042\u308A\u307E\u3059\u3002" },
{ "compiler.note.unchecked.plural", "\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306E\u64CD\u4F5C\u306E\u3046\u3061\u3001\u672A\u30C1\u30A7\u30C3\u30AF\u307E\u305F\u306F\u5B89\u5168\u3067\u306F\u306A\u3044\u3082\u306E\u304C\u3042\u308A\u307E\u3059\u3002" },
{ "compiler.note.unchecked.plural.additional", "\u5165\u529B\u30D5\u30A1\u30A4\u30EB\u306E\u64CD\u4F5C\u306E\u3046\u3061\u3001\u672A\u30C1\u30A7\u30C3\u30AF\u307E\u305F\u306F\u5B89\u5168\u3067\u306F\u306A\u3044\u3082\u306E\u304C\u3055\u3089\u306B\u3042\u308A\u307E\u3059\u3002" },
{ "compiler.note.unchecked.recompile", "\u8A73\u7D30\u306F\u3001-Xlint:unchecked\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u6307\u5B9A\u3057\u3066\u518D\u30B3\u30F3\u30D1\u30A4\u30EB\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.note.verbose.resolve.multi", "\u578B{1}\u306E\u30E1\u30BD\u30C3\u30C9{0}\u3092\u5019\u88DC{2}\u306B\u89E3\u6C7A\u3057\u3066\u3044\u307E\u3059\n\u30D5\u30A7\u30FC\u30BA: {3}\n\u5B9F\u969B\u306E\u578B: {4}\n\u578B\u5F15\u6570: {5}\n\u5019\u88DC:" },
{ "compiler.note.verbose.resolve.multi.1", "\u578B{1}\u306E\u30E1\u30BD\u30C3\u30C9{0}\u306E\u89E3\u6C7A\u306B\u30A8\u30E9\u30FC\u304C\u3042\u308A\u307E\u3059\n\u30D5\u30A7\u30FC\u30BA: {3}\n\u5B9F\u969B\u306E\u578B: {4}\n\u578B\u5F15\u6570: {5}\n\u5019\u88DC:" },
{ "compiler.warn.access.to.sensitive.member.from.serializable.element", "\u76F4\u5217\u5316\u53EF\u80FD\u8981\u7D20\u304B\u3089\u6A5F\u5BC6\u30E1\u30F3\u30D0\u30FC{0}\u3078\u306E\u30A2\u30AF\u30BB\u30B9\u306F\u3001\u4FE1\u983C\u3067\u304D\u306A\u3044\u30B3\u30FC\u30C9\u304B\u3089\u30D1\u30D6\u30EA\u30C3\u30AF\u306B\u30A2\u30AF\u30BB\u30B9\u53EF\u80FD\u3067\u3042\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.annotation.method.not.found", "\u30BF\u30A4\u30D7''{0}''\u5185\u306B\u6CE8\u91C8\u30E1\u30BD\u30C3\u30C9''{1}()''\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
{ "compiler.warn.annotation.method.not.found.reason", "\u30BF\u30A4\u30D7''{0}''\u5185\u306B\u6CE8\u91C8\u30E1\u30BD\u30C3\u30C9''{1}()''\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: {2}" },
{ "compiler.warn.assert.as.identifier", "\u30EA\u30EA\u30FC\u30B91.4\u304B\u3089''assert''\u306F\u30AD\u30FC\u30EF\u30FC\u30C9\u306A\u306E\u3067\u3001\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\n(''assert''\u3092\u30AD\u30FC\u30EF\u30FC\u30C9\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u306B\u306F\u3001-source 1.4\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file", "{1}\u306E\u88DC\u52A9\u30AF\u30E9\u30B9{0}\u306B\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u5916\u304B\u3089\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.warn.big.major.version", "{0}: \u30E1\u30B8\u30E3\u30FC\u30FB\u30D0\u30FC\u30B8\u30E7\u30F3{1}\u306F\u3001\u3053\u306E\u30B3\u30F3\u30D1\u30A4\u30E9\u3067\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u308B\u6700\u65B0\u306E\u30E1\u30B8\u30E3\u30FC\u30FB\u30D0\u30FC\u30B8\u30E7\u30F3{2}\u3088\u308A\u65B0\u3057\u3044\u3067\u3059\u3002\n\u30B3\u30F3\u30D1\u30A4\u30E9\u306E\u30A2\u30C3\u30D7\u30B0\u30EC\u30FC\u30C9\u3092\u304A\u85A6\u3081\u3057\u307E\u3059\u3002" },
{ "compiler.warn.constant.SVUID", "serialVersionUID\u306F\u30AF\u30E9\u30B9{0}\u306E\u5B9A\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.diamond.redundant.args", "\u65B0\u3057\u3044\u5F0F\u306E\u578B\u5F15\u6570\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059(\u304B\u308F\u308A\u306B\u30C0\u30A4\u30E4\u30E2\u30F3\u30C9\u6F14\u7B97\u5B50\u3092\u4F7F\u7528\u3057\u307E\u3059)\u3002" },
{ "compiler.warn.diamond.redundant.args.1", "\u65B0\u3057\u3044\u5F0F\u306E\u578B\u5F15\u6570\u304C\u91CD\u8907\u3057\u3066\u3044\u307E\u3059(\u304B\u308F\u308A\u306B\u30C0\u30A4\u30E4\u30E2\u30F3\u30C9\u6F14\u7B97\u5B50\u3092\u4F7F\u7528\u3057\u307E\u3059)\u3002\n\u660E\u793A\u7684: {0}\n\u63A8\u8AD6: {1}" },
{ "compiler.warn.dir.path.element.not.found", "\u4E0D\u6B63\u306A\u30D1\u30B9\u8981\u7D20\"{0}\": \u305D\u306E\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306F\u5B58\u5728\u3057\u307E\u305B\u3093" },
{ "compiler.warn.div.zero", "\u30BC\u30ED\u3067\u9664\u7B97" },
{ "compiler.warn.empty.if", "if\u4EE5\u964D\u304C\u7A7A\u306E\u6587\u3067\u3059" },
{ "compiler.warn.enum.as.identifier", "\u30EA\u30EA\u30FC\u30B95\u304B\u3089''enum''\u306F\u30AD\u30FC\u30EF\u30FC\u30C9\u306A\u306E\u3067\u8B58\u5225\u5B50\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\n(''enum''\u3092\u30AD\u30FC\u30EF\u30FC\u30C9\u3068\u3057\u3066\u4F7F\u7528\u3059\u308B\u306B\u306F-source 5\u4EE5\u964D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044)" },
{ "compiler.warn.finally.cannot.complete", "finally\u7BC0\u304C\u6B63\u5E38\u306B\u5B8C\u4E86\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.warn.forward.ref", "\u521D\u671F\u5316\u3055\u308C\u308B\u524D\u306E\u5909\u6570''{0}''\u3092\u53C2\u7167\u3057\u3088\u3046\u3068\u3057\u307E\u3057\u305F" },
{ "compiler.warn.future.attr", "\u30D0\u30FC\u30B8\u30E7\u30F3{1}.{2}\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3067\u5C0E\u5165\u3055\u308C\u305F{0}\u5C5E\u6027\u306F\u3001\u30D0\u30FC\u30B8\u30E7\u30F3{3}.{4}\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3067\u306F\u7121\u8996\u3055\u308C\u307E\u3059" },
{ "compiler.warn.has.been.deprecated", "{1}\u306E{0}\u306F\u975E\u63A8\u5968\u306B\u306A\u308A\u307E\u3057\u305F" },
{ "compiler.warn.illegal.char.for.encoding", "\u3053\u306E\u6587\u5B57\u306F\u3001\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0{0}\u306B\u30DE\u30C3\u30D7\u3067\u304D\u307E\u305B\u3093" },
{ "compiler.warn.improper.SVUID", "serialVersionUID\u306F\u3001\u30AF\u30E9\u30B9{0}\u306Bstatic final\u3092\u5BA3\u8A00\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.inexact.non-varargs.call", "\u6700\u7D42\u30D1\u30E9\u30E1\u30FC\u30BF\u306E\u4E0D\u6B63\u78BA\u306A\u5F15\u6570\u578B\u3092\u6301\u3063\u305F\u53EF\u5909\u5F15\u6570\u30E1\u30BD\u30C3\u30C9\u306E\u975E\u53EF\u5909\u5F15\u6570\u547C\u51FA\u3057\u3002\n\u53EF\u5909\u5F15\u6570\u547C\u51FA\u3057\u306B\u95A2\u3057\u3066\u306F{0}\u306B\u30AD\u30E3\u30B9\u30C8\u3057\u307E\u3059\u3002\n\u975E\u53EF\u5909\u5F15\u6570\u547C\u51FA\u3057\u306B\u95A2\u3057\u3066\u306F{1}\u306B\u30AD\u30E3\u30B9\u30C8\u3057\u3066\u3053\u306E\u8B66\u544A\u3092\u51FA\u3055\u306A\u3044\u3088\u3046\u306B\u3057\u307E\u3059" },
{ "compiler.warn.invalid.archive.file", "\u30D1\u30B9\u4E0A\u306E\u4E88\u671F\u3057\u306A\u3044\u30D5\u30A1\u30A4\u30EB: {0}" },
{ "compiler.warn.lintOption", "[{0}] " },
{ "compiler.warn.long.SVUID", "serialVersionUID\u306F\u3001\u30AF\u30E9\u30B9{0}\u306Elong\u578B\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.missing.SVUID", "\u76F4\u5217\u5316\u53EF\u80FD\u306A\u30AF\u30E9\u30B9{0}\u306B\u306F\u3001serialVersionUID\u304C\u5B9A\u7FA9\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.warn.missing.deprecated.annotation", "\u975E\u63A8\u5968\u306E\u9805\u76EE\u306F@Deprecated\u3067\u6CE8\u91C8\u304C\u4ED8\u3051\u3089\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.warn.option.obsolete.source", "\u30BD\u30FC\u30B9\u5024{0}\u306F\u5EC3\u6B62\u3055\u308C\u3066\u3044\u3066\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u4E88\u5B9A\u3067\u3059" },
{ "compiler.warn.option.obsolete.suppression", "\u5EC3\u6B62\u3055\u308C\u305F\u30AA\u30D7\u30B7\u30E7\u30F3\u306B\u3064\u3044\u3066\u306E\u8B66\u544A\u3092\u8868\u793A\u3057\u306A\u3044\u3088\u3046\u306B\u3059\u308B\u306B\u306F\u3001-Xlint:\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u4F7F\u7528\u3057\u307E\u3059\u3002" },
{ "compiler.warn.option.obsolete.target", "\u30BF\u30FC\u30B2\u30C3\u30C8\u5024{0}\u306F\u5EC3\u6B62\u3055\u308C\u3066\u3044\u3066\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u4E88\u5B9A\u3067\u3059" },
{ "compiler.warn.override.bridge", "{0}\u3002\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u306F\u30D6\u30EA\u30C3\u30B8\u30FB\u30E1\u30BD\u30C3\u30C9\u3067\u3059" },
{ "compiler.warn.override.equals.but.not.hashcode", "\u30AF\u30E9\u30B9{0}\u306Fequals\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u3059\u304C\u3001\u3053\u306E\u30AF\u30E9\u30B9\u3082\u3001\u307E\u305F\u3001\u3044\u304B\u306A\u308B\u30B9\u30FC\u30D1\u30FC\u30AF\u30E9\u30B9\u3082\u3001hashCode\u30E1\u30BD\u30C3\u30C9\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u307E\u305B\u3093" },
{ "compiler.warn.override.unchecked.ret", "{0}\n\u623B\u308A\u5024\u306E\u578B\u306F{1}\u304B\u3089{2}\u3078\u306E\u7121\u691C\u67FB\u5909\u63DB\u304C\u5FC5\u8981\u3067\u3059" },
{ "compiler.warn.override.unchecked.thrown", "{0}\n\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u306F{1}\u3092\u30B9\u30ED\u30FC\u3057\u307E\u305B\u3093" },
{ "compiler.warn.override.varargs.extra", "{0}\u3002\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3057\u3066\u3044\u308B\u30E1\u30BD\u30C3\u30C9\u306B\u306F''...''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.warn.override.varargs.missing", "{0}\u3002\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3055\u308C\u305F\u30E1\u30BD\u30C3\u30C9\u306B\u306F''...''\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.warn.path.element.not.found", "\u4E0D\u6B63\u306A\u30D1\u30B9\u8981\u7D20\"{0}\": \u305D\u306E\u30D5\u30A1\u30A4\u30EB\u307E\u305F\u306F\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.warn.pkg-info.already.seen", "package-info.java\u30D5\u30A1\u30A4\u30EB\u304C\u3059\u3067\u306B\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u7528\u306B\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.warn.position.overflow", "\u4F4D\u7F6E\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0\u304C\u884C{0}\u3067\u30AA\u30FC\u30D0\u30FC\u30D5\u30ED\u30FC\u3057\u307E\u3059" },
{ "compiler.warn.possible.fall-through.into.case", "case\u306Bfall-through\u3059\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.potentially.ambiguous.overload", "{1}\u5185\u306E{0}\u306F{3}\u5185\u306E{2}\u3068\u77DB\u76FE\u3059\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.prob.found.req", "{0}\n\u671F\u5F85\u5024: {2}\n\u691C\u51FA\u5024: {1}" },
{ "compiler.warn.proc.annotations.without.processors", "\u3053\u308C\u3089\u306E\u6CE8\u91C8\u3092\u8981\u6C42\u3059\u308B\u30D7\u30ED\u30BB\u30C3\u30B5\u306F\u3042\u308A\u307E\u305B\u3093\u3067\u3057\u305F: {0}" },
{ "compiler.warn.proc.file.create.last.round", "\u6700\u5F8C\u306B\u4F5C\u6210\u3055\u308C\u305F\u30BF\u30A4\u30D7''{0}''\u306E\u30D5\u30A1\u30A4\u30EB\u306F\u6CE8\u91C8\u51E6\u7406\u306B\u6E21\u3055\u308C\u307E\u305B\u3093\u3002" },
{ "compiler.warn.proc.file.reopening", "''{0}''\u7528\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u8907\u6570\u56DE\u4F5C\u6210\u3057\u3088\u3046\u3068\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.warn.proc.illegal.file.name", "\u7121\u52B9\u306A\u540D\u524D''{0}''\u306E\u30D5\u30A1\u30A4\u30EB\u306F\u4F5C\u6210\u3067\u304D\u307E\u305B\u3093\u3002" },
{ "compiler.warn.proc.malformed.supported.string", "\u30D7\u30ED\u30BB\u30C3\u30B5''{1}''\u304C\u8FD4\u3057\u305F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u308B\u6CE8\u91C8\u578B\u306E\u6587\u5B57\u5217''{0}''\u304C\u4E0D\u6B63\u3067\u3059" },
{ "compiler.warn.proc.messager", "{0}" },
{ "compiler.warn.proc.package.does.not.exist", "\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u306F\u5B58\u5728\u3057\u307E\u305B\u3093" },
{ "compiler.warn.proc.proc-only.requested.no.procs", "\u30B3\u30F3\u30D1\u30A4\u30EB\u306A\u3057\u306E\u6CE8\u91C8\u51E6\u7406\u304C\u30EA\u30AF\u30A8\u30B9\u30C8\u3055\u308C\u307E\u3057\u305F\u304C\u3001\u30D7\u30ED\u30BB\u30C3\u30B5\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F\u3002" },
{ "compiler.warn.proc.processor.incompatible.source.version", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5''{1}''\u304B\u3089-source ''{2}''\u3088\u308A\u5C0F\u3055\u3044\u30BD\u30FC\u30B9\u30FB\u30D0\u30FC\u30B8\u30E7\u30F3''{0}''\u304C\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.warn.proc.suspicious.class.name", "\u540D\u524D\u304C{1}\u3067\u7D42\u308F\u308B\u578B\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u4F5C\u6210\u3057\u3066\u3044\u307E\u3059: ''{0}''" },
{ "compiler.warn.proc.type.already.exists", "\u30BF\u30A4\u30D7''{0}''\u306E\u30D5\u30A1\u30A4\u30EB\u306F\u3059\u3067\u306B\u30BD\u30FC\u30B9\u30FB\u30D1\u30B9\u307E\u305F\u306F\u30AF\u30E9\u30B9\u30D1\u30B9\u306B\u5B58\u5728\u3057\u307E\u3059" },
{ "compiler.warn.proc.type.recreate", "\u30BF\u30A4\u30D7''{0}''\u306E\u30D5\u30A1\u30A4\u30EB\u3092\u8907\u6570\u56DE\u4F5C\u6210\u3057\u3088\u3046\u3068\u3057\u3066\u3044\u307E\u3059" },
{ "compiler.warn.proc.unclosed.type.files", "\u30BF\u30A4\u30D7''{0}''\u306E\u30D5\u30A1\u30A4\u30EB\u304C\u9589\u3058\u3089\u308C\u3066\u3044\u307E\u305B\u3093\u3002\u3053\u308C\u3089\u306E\u30BF\u30A4\u30D7\u306F\u6CE8\u91C8\u51E6\u7406\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.warn.proc.unmatched.processor.options", "\u6B21\u306E\u30AA\u30D7\u30B7\u30E7\u30F3\u306F\u3069\u306E\u30D7\u30ED\u30BB\u30C3\u30B5\u3067\u3082\u8A8D\u8B58\u3055\u308C\u307E\u305B\u3093\u3067\u3057\u305F: ''{0}''" },
{ "compiler.warn.proc.use.implicit", "\u6697\u9ED9\u7684\u306B\u30B3\u30F3\u30D1\u30A4\u30EB\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB\u306F\u6CE8\u91C8\u51E6\u7406\u306B\u6E21\u3055\u308C\u307E\u305B\u3093\u3002\n-implicit\u3092\u4F7F\u7528\u3057\u6697\u9ED9\u7684\u30B3\u30F3\u30D1\u30A4\u30EB\u306E\u30DD\u30EA\u30B7\u30FC\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.warn.proc.use.proc.or.implicit", "\u6697\u9ED9\u7684\u306B\u30B3\u30F3\u30D1\u30A4\u30EB\u3055\u308C\u305F\u30D5\u30A1\u30A4\u30EB\u306F\u6CE8\u91C8\u51E6\u7406\u306B\u6E21\u3055\u308C\u307E\u305B\u3093\u3002\n-proc:none\u3092\u4F7F\u7528\u3057\u6CE8\u91C8\u51E6\u7406\u3092\u7121\u52B9\u306B\u3059\u308B\u304B -implicit\u3092\u4F7F\u7528\u3057\u6697\u9ED9\u7684\u30B3\u30F3\u30D1\u30A4\u30EB\u306E\u30DD\u30EA\u30B7\u30FC\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
{ "compiler.warn.raw.class.use", "raw\u578B\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F: {0}\n\u6C4E\u7528\u30AF\u30E9\u30B9{1}\u306E\u578B\u5F15\u6570\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "compiler.warn.redundant.cast", "{0}\u3078\u306E\u5197\u9577\u306A\u30AD\u30E3\u30B9\u30C8\u3067\u3059" },
{ "compiler.warn.self.ref", "\u521D\u671F\u5316\u5B50\u5185\u306E\u5909\u6570''{0}''\u306E\u81EA\u5DF1\u53C2\u7167" },
{ "compiler.warn.source.no.bootclasspath", "\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30D1\u30B9\u304C-source {0}\u3068\u4E00\u7DD2\u306B\u8A2D\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "compiler.warn.static.not.qualified.by.type", "static {0}\u306F\u5F0F\u3067\u306F\u306A\u304F\u578B\u540D{1}\u3067\u4FEE\u98FE\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.sun.proprietary", "{0}\u306F\u5185\u90E8\u6240\u6709\u306EAPI\u3067\u3042\u308A\u3001\u4ECA\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u524A\u9664\u3055\u308C\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.synthetic.name.conflict", "\u30B7\u30F3\u30DC\u30EB{0}\u304C\u3001{1}\u3067\u30B3\u30F3\u30D1\u30A4\u30E9\u304C\u5408\u6210\u3057\u305F\u30B7\u30F3\u30DC\u30EB\u3068\u7AF6\u5408\u3057\u307E\u3059" },
{ "compiler.warn.try.explicit.close.call", "\u81EA\u52D5\u30AF\u30ED\u30FC\u30BA\u53EF\u80FD\u306A\u30EA\u30BD\u30FC\u30B9\u306B\u304A\u3051\u308Bclose()\u306E\u660E\u793A\u7684\u547C\u51FA\u3057" },
{ "compiler.warn.try.resource.not.referenced", "\u81EA\u52D5\u30AF\u30ED\u30FC\u30BA\u53EF\u80FD\u306A\u30EA\u30BD\u30FC\u30B9{0}\u306F\u5BFE\u5FDC\u3059\u308Btry\u6587\u306E\u672C\u4F53\u3067\u306F\u53C2\u7167\u3055\u308C\u307E\u305B\u3093" },
{ "compiler.warn.try.resource.throws.interrupted.exc", "\u81EA\u52D5\u30AF\u30ED\u30FC\u30BA\u53EF\u80FD\u306A\u30EA\u30BD\u30FC\u30B9{0}\u306B\u3001InterruptedException\u3092\u30B9\u30ED\u30FC\u3059\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u30E1\u30F3\u30D0\u30FC\u30FB\u30E1\u30BD\u30C3\u30C9close()\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.unchecked.assign", "{0}\u304B\u3089{1}\u3078\u306E\u7121\u691C\u67FB\u4EE3\u5165\u3067\u3059" },
{ "compiler.warn.unchecked.assign.to.var", "raw\u578B{1}\u306E\u30E1\u30F3\u30D0\u30FC\u3068\u3057\u3066\u5909\u6570{0}\u3078\u306E\u7121\u691C\u67FB\u4EE3\u5165\u3067\u3059" },
{ "compiler.warn.unchecked.call.mbr.of.raw.type", "raw\u578B{1}\u306E\u30E1\u30F3\u30D0\u30FC\u3068\u3057\u3066\u306E{0}\u3078\u306E\u7121\u691C\u67FB\u547C\u51FA\u3057\u3067\u3059" },
{ "compiler.warn.unchecked.cast.to.type", "\u578B{0}\u3078\u306E\u7121\u691C\u67FB\u30AD\u30E3\u30B9\u30C8\u3067\u3059" },
{ "compiler.warn.unchecked.generic.array.creation", "\u578B{0}\u306E\u53EF\u5909\u5F15\u6570\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u5BFE\u3059\u308B\u7DCF\u79F0\u578B\u914D\u5217\u306E\u7121\u691C\u67FB\u4F5C\u6210\u3067\u3059" },
{ "compiler.warn.unchecked.meth.invocation.applied", "\u7121\u691C\u67FB\u30E1\u30BD\u30C3\u30C9\u547C\u51FA\u3057: {4} {5}\u306E{0} {1}\u306F\u6307\u5B9A\u3055\u308C\u305F\u578B\u306B\u9069\u7528\u3055\u308C\u307E\u3059\n\u671F\u5F85\u5024: {2}\n\u691C\u51FA\u5024: {3}" },
{ "compiler.warn.unchecked.varargs.non.reifiable.type", "\u30D1\u30E9\u30E1\u30FC\u30BF\u5316\u3055\u308C\u305F\u53EF\u5909\u5F15\u6570\u578B{0}\u304B\u3089\u306E\u30D2\u30FC\u30D7\u6C5A\u67D3\u306E\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.underscore.as.identifier", "\u8B58\u5225\u5B50\u3068\u3057\u3066''_''\u304C\u4F7F\u7528\u3055\u308C\u307E\u3057\u305F\n(\u8B58\u5225\u5B50\u3068\u3057\u3066\u306E''_''\u306E\u4F7F\u7528\u306F\u3001Java SE 8\u3088\u308A\u5F8C\u306E\u30EA\u30EA\u30FC\u30B9\u3067\u306F\u30B5\u30DD\u30FC\u30C8\u3055\u308C\u306A\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059)" },
{ "compiler.warn.unexpected.archive.file", "\u30A2\u30FC\u30AB\u30A4\u30D6\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u4E88\u671F\u3057\u306A\u3044\u62E1\u5F35\u5B50: {0}" },
{ "compiler.warn.unknown.enum.constant", "\u4E0D\u660E\u306A\u5217\u6319\u578B\u5B9A\u6570\u3067\u3059{1}.{2}" },
{ "compiler.warn.unknown.enum.constant.reason", "\u4E0D\u660E\u306A\u5217\u6319\u578B\u5B9A\u6570\u3067\u3059{1}.{2}\n\u7406\u7531: {3}" },
{ "compiler.warn.unreachable.catch", "catch\u53E5\u306B\u79FB\u3059\u3053\u3068\u304C\u3067\u304D\u307E\u305B\u3093\n\u30B9\u30ED\u30FC\u3055\u308C\u305F\u30BF\u30A4\u30D7{0}\u306F\u3059\u3067\u306B\u6355\u6349\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.warn.unreachable.catch.1", "catch\u53E5\u306B\u79FB\u3059\u3053\u3068\u304C\u3067\u304D\u307E\u305B\u3093\n\u30B9\u30ED\u30FC\u3055\u308C\u305F\u30BF\u30A4\u30D7{0}\u306F\u3059\u3067\u306B\u6355\u6349\u3055\u308C\u3066\u3044\u307E\u3059" },
{ "compiler.warn.varargs.redundant.trustme.anno", "{0}\u6CE8\u91C8\u304C\u5197\u9577\u3067\u3059\u3002{1}" },
{ "compiler.warn.varargs.unsafe.use.varargs.param", "\u53EF\u5909\u5F15\u6570\u30E1\u30BD\u30C3\u30C9\u306F\u3001\u578B\u60C5\u5831\u4FDD\u6301\u53EF\u80FD\u3067\u306A\u3044\u53EF\u5909\u5F15\u6570\u30D1\u30E9\u30E1\u30FC\u30BF{0}\u304B\u3089\u306E\u30D2\u30FC\u30D7\u6C5A\u67D3\u306E\u539F\u56E0\u3068\u306A\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059" },
{ "compiler.warn.warning", "\u8B66\u544A: " },
};
}
}

623
jdkSrc/jdk8/com/sun/tools/javac/resources/compiler_zh_CN.java Normal file
View File

@@ -0,0 +1,623 @@
package com.sun.tools.javac.resources;
public final class compiler_zh_CN extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "compiler.err.abstract.cant.be.accessed.directly", "\u65E0\u6CD5\u76F4\u63A5\u8BBF\u95EE{2}\u4E2D\u7684\u62BD\u8C61{0} {1}" },
{ "compiler.err.abstract.cant.be.instantiated", "{0}\u662F\u62BD\u8C61\u7684; \u65E0\u6CD5\u5B9E\u4F8B\u5316" },
{ "compiler.err.abstract.meth.cant.have.body", "\u62BD\u8C61\u65B9\u6CD5\u4E0D\u80FD\u6709\u4E3B\u4F53" },
{ "compiler.err.already.annotated", "{0} {1}\u5DF2\u8FDB\u884C\u6CE8\u91CA" },
{ "compiler.err.already.defined", "\u5DF2\u5728{2} {3}\u4E2D\u5B9A\u4E49\u4E86{0} {1}" },
{ "compiler.err.already.defined.in.clinit", "\u5DF2\u5728{3} {4}\u7684{2}\u4E2D\u5B9A\u4E49\u4E86{0} {1}" },
{ "compiler.err.already.defined.single.import", "{0}\u7684 single-type-import \u5DF2\u5B9A\u4E49\u5177\u6709\u76F8\u540C\u7B80\u540D\u7684\u7C7B\u578B" },
{ "compiler.err.already.defined.static.single.import", "{0}\u7684\u9759\u6001 single-type-import \u5DF2\u5B9A\u4E49\u5177\u6709\u76F8\u540C\u7B80\u540D\u7684\u7C7B\u578B" },
{ "compiler.err.already.defined.this.unit", "\u5DF2\u5728\u8BE5\u7F16\u8BD1\u5355\u5143\u4E2D\u5B9A\u4E49{0}" },
{ "compiler.err.annotation.missing.default.value", "\u5BF9\u4E8E\u5143\u7D20 ''{1}'', \u6CE8\u91CA @{0} \u7F3A\u5C11\u9ED8\u8BA4\u503C" },
{ "compiler.err.annotation.missing.default.value.1", "\u5BF9\u4E8E\u5143\u7D20{1}, \u6CE8\u91CA @{0} \u7F3A\u5C11\u9ED8\u8BA4\u503C" },
{ "compiler.err.annotation.not.valid.for.type", "\u6CE8\u91CA\u5BF9\u4E8E\u7C7B\u578B{0}\u7684\u5143\u7D20\u65E0\u6548" },
{ "compiler.err.annotation.type.not.applicable", "\u6CE8\u91CA\u7C7B\u578B\u4E0D\u9002\u7528\u4E8E\u8BE5\u7C7B\u578B\u7684\u58F0\u660E" },
{ "compiler.err.annotation.value.must.be.annotation", "\u6CE8\u91CA\u503C\u5FC5\u987B\u4E3A\u6CE8\u91CA" },
{ "compiler.err.annotation.value.must.be.class.literal", "\u6CE8\u91CA\u503C\u5FC5\u987B\u4E3A\u7C7B\u6587\u5B57" },
{ "compiler.err.annotation.value.must.be.name.value", "\u6CE8\u91CA\u503C\u5FC5\u987B\u91C7\u7528 ''name=value'' \u683C\u5F0F" },
{ "compiler.err.annotation.value.not.allowable.type", "\u6CE8\u91CA\u503C\u4E0D\u662F\u5141\u8BB8\u7684\u7C7B\u578B" },
{ "compiler.err.annotations.after.type.params.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u65B9\u6CD5\u7C7B\u578B\u53C2\u6570\u540E\u7684\u6CE8\u91CA\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u65B9\u6CD5\u7C7B\u578B\u53C2\u6570\u540E\u7684\u6CE8\u91CA)" },
{ "compiler.err.annotations.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u6CE8\u91CA\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u6CE8\u91CA)" },
{ "compiler.err.anon.class.impl.intf.no.args", "\u533F\u540D\u7C7B\u5B9E\u73B0\u63A5\u53E3; \u4E0D\u80FD\u6709\u53C2\u6570" },
{ "compiler.err.anon.class.impl.intf.no.qual.for.new", "\u533F\u540D\u7C7B\u5B9E\u73B0\u63A5\u53E3; \u4E0D\u80FD\u6709\u9650\u5B9A\u7B26 - \u5BF9\u4E8E\u65B0" },
{ "compiler.err.anon.class.impl.intf.no.typeargs", "\u533F\u540D\u7C7B\u5B9E\u73B0\u63A5\u53E3; \u4E0D\u80FD\u5177\u6709\u7C7B\u578B\u53C2\u6570" },
{ "compiler.err.array.and.receiver", "\u63A5\u6536\u65B9\u53C2\u6570\u4E0D\u5141\u8BB8\u4F7F\u7528\u4F20\u7EDF\u6570\u7EC4\u8BB0\u53F7" },
{ "compiler.err.array.and.varargs", "\u65E0\u6CD5\u5728{2}\u4E2D\u540C\u65F6\u58F0\u660E{0}\u548C{1}" },
{ "compiler.err.array.dimension.missing", "\u7F3A\u5C11\u6570\u7EC4\u7EF4" },
{ "compiler.err.array.req.but.found", "\u9700\u8981\u6570\u7EC4, \u4F46\u627E\u5230{0}" },
{ "compiler.err.assert.as.identifier", "\u4ECE\u53D1\u884C\u7248 1.4 \u5F00\u59CB, ''assert'' \u662F\u4E00\u4E2A\u5173\u952E\u5B57, \u4F46\u4E0D\u80FD\u7528\u4F5C\u6807\u8BC6\u7B26\n(\u8BF7\u4F7F\u7528 -source 1.3 \u6216\u66F4\u4F4E\u7248\u672C\u4EE5\u5C06 ''assert'' \u7528\u4F5C\u6807\u8BC6\u7B26)" },
{ "compiler.err.attribute.value.must.be.constant", "\u5143\u7D20\u503C\u5FC5\u987B\u4E3A\u5E38\u91CF\u8868\u8FBE\u5F0F" },
{ "compiler.err.bad.functional.intf.anno", "\u610F\u5916\u7684 @FunctionalInterface \u6CE8\u91CA" },
{ "compiler.err.bad.functional.intf.anno.1", "\u610F\u5916\u7684 @FunctionalInterface \u6CE8\u91CA\n{0}" },
{ "compiler.err.bad.initializer", "{0}\u7684\u521D\u59CB\u5316\u7A0B\u5E8F\u9519\u8BEF" },
{ "compiler.err.break.outside.switch.loop", "\u5728 switch \u6216 loop \u5916\u90E8\u4E2D\u65AD" },
{ "compiler.err.call.must.be.first.stmt.in.ctor", "\u5BF9{0}\u7684\u8C03\u7528\u5FC5\u987B\u662F\u6784\u9020\u5668\u4E2D\u7684\u7B2C\u4E00\u4E2A\u8BED\u53E5" },
{ "compiler.err.call.to.super.not.allowed.in.enum.ctor", "\u5728\u679A\u4E3E\u6784\u9020\u5668\u4E2D\u4E0D\u5141\u8BB8\u8C03\u7528\u8D85\u7C7B" },
{ "compiler.err.cannot.create.array.with.diamond", "\u65E0\u6CD5\u521B\u5EFA\u5177\u6709 ''<>'' \u7684\u6570\u7EC4" },
{ "compiler.err.cannot.create.array.with.type.arguments", "\u65E0\u6CD5\u521B\u5EFA\u5177\u6709\u7C7B\u578B\u53D8\u91CF\u7684\u6570\u7EC4" },
{ "compiler.err.cant.access", "\u65E0\u6CD5\u8BBF\u95EE{0}\n{1}" },
{ "compiler.err.cant.apply.diamond", "\u65E0\u6CD5\u63A8\u65AD{0}\u7684\u7C7B\u578B\u53C2\u6570" },
{ "compiler.err.cant.apply.diamond.1", "\u65E0\u6CD5\u63A8\u65AD{0}\u7684\u7C7B\u578B\u53C2\u6570\n\u539F\u56E0: {1}" },
{ "compiler.err.cant.apply.symbol", "\u65E0\u6CD5\u5C06{4} {5}\u4E2D\u7684{0} {1}\u5E94\u7528\u5230\u7ED9\u5B9A\u7C7B\u578B;\n\u9700\u8981: {2}\n\u627E\u5230: {3}\n\u539F\u56E0: {6}" },
{ "compiler.err.cant.apply.symbols", "\u5BF9\u4E8E{1}({2}), \u627E\u4E0D\u5230\u5408\u9002\u7684{0}" },
{ "compiler.err.cant.assign.val.to.final.var", "\u65E0\u6CD5\u4E3A\u6700\u7EC8\u53D8\u91CF{0}\u5206\u914D\u503C" },
{ "compiler.err.cant.deref", "\u65E0\u6CD5\u53D6\u6D88\u5F15\u7528{0}" },
{ "compiler.err.cant.extend.intf.annotation", "\u5BF9\u4E8E @interfaces, \u4E0D\u5141\u8BB8 ''extends''" },
{ "compiler.err.cant.inherit.diff.arg", "\u65E0\u6CD5\u4F7F\u7528\u4EE5\u4E0B\u4E0D\u540C\u7684\u53C2\u6570\u7EE7\u627F{0}: <{1}> \u548C <{2}>" },
{ "compiler.err.cant.inherit.from.anon", "\u65E0\u6CD5\u4ECE\u533F\u540D\u7C7B\u7EE7\u627F" },
{ "compiler.err.cant.inherit.from.final", "\u65E0\u6CD5\u4ECE\u6700\u7EC8{0}\u8FDB\u884C\u7EE7\u627F" },
{ "compiler.err.cant.read.file", "\u65E0\u6CD5\u8BFB\u53D6: {0}" },
{ "compiler.err.cant.ref.before.ctor.called", "\u65E0\u6CD5\u5728\u8C03\u7528\u8D85\u7C7B\u578B\u6784\u9020\u5668\u4E4B\u524D\u5F15\u7528{0}" },
{ "compiler.err.cant.ref.non.effectively.final.var", "\u4ECE{1}\u5F15\u7528\u7684\u672C\u5730\u53D8\u91CF\u5FC5\u987B\u662F\u6700\u7EC8\u53D8\u91CF\u6216\u5B9E\u9645\u4E0A\u7684\u6700\u7EC8\u53D8\u91CF" },
{ "compiler.err.cant.resolve", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} {1}" },
{ "compiler.err.cant.resolve.args", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} {1}({3})" },
{ "compiler.err.cant.resolve.args.params", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} <{2}>{1}({3})" },
{ "compiler.err.cant.resolve.location", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} {1}\n\u4F4D\u7F6E: {4}" },
{ "compiler.err.cant.resolve.location.args", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} {1}({3})\n\u4F4D\u7F6E: {4}" },
{ "compiler.err.cant.resolve.location.args.params", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} <{2}>{1}({3})\n\u4F4D\u7F6E: {4}" },
{ "compiler.err.cant.select.static.class.from.param.type", "\u65E0\u6CD5\u4ECE\u53C2\u6570\u5316\u7684\u7C7B\u578B\u4E2D\u9009\u62E9\u9759\u6001\u7C7B" },
{ "compiler.err.cant.type.annotate.scoping", "\u65E0\u6CD5\u4F7F\u7528 type-use \u6CE8\u91CA {0} \u6765\u6CE8\u91CA\u786E\u5B9A\u4F5C\u7528\u57DF\u7ED3\u6784" },
{ "compiler.err.cant.type.annotate.scoping.1", "\u65E0\u6CD5\u4F7F\u7528 type-use \u6CE8\u91CA {0} \u6765\u6CE8\u91CA\u786E\u5B9A\u4F5C\u7528\u57DF\u7ED3\u6784" },
{ "compiler.err.catch.without.try", "\u6709 ''catch'', \u4F46\u662F\u6CA1\u6709 ''try''" },
{ "compiler.err.clash.with.pkg.of.same.name", "{0} {1}\u4E0E\u5E26\u6709\u76F8\u540C\u540D\u79F0\u7684\u7A0B\u5E8F\u5305\u51B2\u7A81" },
{ "compiler.err.class.cant.write", "\u5199\u5165{0}\u65F6\u51FA\u9519: {1}" },
{ "compiler.err.class.not.allowed", "\u6B64\u5904\u4E0D\u5141\u8BB8\u4F7F\u7528\u7C7B, \u63A5\u53E3\u6216\u679A\u4E3E\u58F0\u660E" },
{ "compiler.err.class.public.should.be.in.file", "\u7C7B{0}\u662F\u516C\u5171\u7684, \u5E94\u5728\u540D\u4E3A {0}.java \u7684\u6587\u4EF6\u4E2D\u58F0\u660E" },
{ "compiler.err.concrete.inheritance.conflict", "{1}\u4E2D\u7684\u65B9\u6CD5{0}\u548C{3}\u4E2D\u7684\u65B9\u6CD5{2}\u662F\u4F7F\u7528\u76F8\u540C\u7684\u7B7E\u540D\u7EE7\u627F\u7684" },
{ "compiler.err.const.expr.req", "\u9700\u8981\u5E38\u91CF\u8868\u8FBE\u5F0F" },
{ "compiler.err.cont.outside.loop", "continue \u5728 loop \u5916\u90E8" },
{ "compiler.err.cyclic.annotation.element", "\u5143\u7D20 {0} \u7684\u7C7B\u578B\u4E3A\u5FAA\u73AF" },
{ "compiler.err.cyclic.inheritance", "\u6D89\u53CA{0}\u7684\u5FAA\u73AF\u7EE7\u627F" },
{ "compiler.err.dc.bad.entity", "HTML \u5B9E\u4F53\u9519\u8BEF" },
{ "compiler.err.dc.bad.gt", "''>'' \u7684\u7528\u6CD5\u9519\u8BEF" },
{ "compiler.err.dc.bad.inline.tag", "\u5185\u5D4C\u6807\u8BB0\u7684\u7528\u6CD5\u4E0D\u6B63\u786E" },
{ "compiler.err.dc.gt.expected", "\u9700\u8981 ''>''" },
{ "compiler.err.dc.identifier.expected", "\u9700\u8981\u6807\u8BC6\u7B26" },
{ "compiler.err.dc.malformed.html", "\u683C\u5F0F\u9519\u8BEF\u7684 HTML" },
{ "compiler.err.dc.missing.semicolon", "\u7F3A\u5C11\u5206\u53F7" },
{ "compiler.err.dc.no.content", "\u65E0\u5185\u5BB9" },
{ "compiler.err.dc.no.tag.name", "'@' \u540E\u6CA1\u6709\u6807\u8BB0\u540D" },
{ "compiler.err.dc.ref.bad.parens", "\u5F15\u7528\u4E2D\u7F3A\u5C11 '')''" },
{ "compiler.err.dc.ref.syntax.error", "\u5F15\u7528\u4E2D\u51FA\u73B0\u8BED\u6CD5\u9519\u8BEF" },
{ "compiler.err.dc.ref.unexpected.input", "\u610F\u5916\u7684\u6587\u672C" },
{ "compiler.err.dc.unexpected.content", "\u610F\u5916\u7684\u5185\u5BB9" },
{ "compiler.err.dc.unterminated.inline.tag", "\u672A\u7EC8\u6B62\u7684\u5185\u5D4C\u6807\u8BB0" },
{ "compiler.err.dc.unterminated.signature", "\u672A\u7EC8\u6B62\u7684\u7B7E\u540D" },
{ "compiler.err.dc.unterminated.string", "\u672A\u7EC8\u6B62\u7684\u5B57\u7B26\u4E32" },
{ "compiler.err.default.allowed.in.intf.annotation.member", "\u6CE8\u91CA\u7C7B\u578B\u58F0\u660E\u4E2D\u4EC5\u5141\u8BB8\u9ED8\u8BA4\u503C" },
{ "compiler.err.default.methods.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u9ED8\u8BA4\u65B9\u6CD5\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u9ED8\u8BA4\u65B9\u6CD5)" },
{ "compiler.err.default.overrides.object.member", "{1} {2} \u4E2D\u7684\u9ED8\u8BA4\u65B9\u6CD5{0}\u8986\u76D6\u4E86 java.lang.Object \u7684\u6210\u5458" },
{ "compiler.err.diamond.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 diamond \u8FD0\u7B97\u7B26\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 diamond \u8FD0\u7B97\u7B26)" },
{ "compiler.err.does.not.override.abstract", "{0}\u4E0D\u662F\u62BD\u8C61\u7684, \u5E76\u4E14\u672A\u8986\u76D6{2}\u4E2D\u7684\u62BD\u8C61\u65B9\u6CD5{1}" },
{ "compiler.err.doesnt.exist", "\u7A0B\u5E8F\u5305{0}\u4E0D\u5B58\u5728" },
{ "compiler.err.dot.class.expected", "\u9700\u8981 ''.class''" },
{ "compiler.err.duplicate.annotation.invalid.repeated", "\u6CE8\u91CA{0}\u4E0D\u662F\u6709\u6548\u7684\u53EF\u91CD\u590D\u6CE8\u91CA" },
{ "compiler.err.duplicate.annotation.member.value", "\u6CE8\u91CA@{1}\u4E2D\u7684\u5143\u7D20 ''{0}'' \u91CD\u590D\u3002" },
{ "compiler.err.duplicate.annotation.missing.container", "{0} \u4E0D\u662F\u53EF\u91CD\u590D\u7684\u6CE8\u91CA\u7C7B\u578B" },
{ "compiler.err.duplicate.case.label", "case \u6807\u7B7E\u91CD\u590D" },
{ "compiler.err.duplicate.class", "\u7C7B\u91CD\u590D: {0}" },
{ "compiler.err.duplicate.default.label", "default \u6807\u7B7E\u91CD\u590D" },
{ "compiler.err.else.without.if", "\u6709 ''if'', \u4F46\u662F\u6CA1\u6709 ''else''" },
{ "compiler.err.empty.char.lit", "\u7A7A\u5B57\u7B26\u6587\u5B57" },
{ "compiler.err.encl.class.required", "\u9700\u8981\u5305\u542B{0}\u7684\u5C01\u95ED\u5B9E\u4F8B" },
{ "compiler.err.enum.annotation.must.be.enum.constant", "\u679A\u4E3E\u6CE8\u91CA\u503C\u5FC5\u987B\u662F\u679A\u4E3E\u5E38\u91CF" },
{ "compiler.err.enum.as.identifier", "\u4ECE\u53D1\u884C\u7248 5 \u5F00\u59CB, ''enum'' \u4E3A\u5173\u952E\u5B57, \u800C\u4E0D\u7528\u4F5C\u6807\u8BC6\u7B26\n(\u8BF7\u4F7F\u7528 -source 1.4 \u6216\u66F4\u4F4E\u7248\u672C\u4EE5\u5C06 ''enum'' \u7528\u4F5C\u6807\u8BC6\u7B26)" },
{ "compiler.err.enum.cant.be.instantiated", "\u65E0\u6CD5\u5B9E\u4F8B\u5316\u679A\u4E3E\u7C7B\u578B" },
{ "compiler.err.enum.label.must.be.unqualified.enum", "\u679A\u4E3E switch case \u6807\u7B7E\u5FC5\u987B\u4E3A\u679A\u4E3E\u5E38\u91CF\u7684\u975E\u9650\u5B9A\u540D\u79F0" },
{ "compiler.err.enum.no.finalize", "\u679A\u4E3E\u4E0D\u80FD\u6709 finalize \u65B9\u6CD5" },
{ "compiler.err.enum.no.subclassing", "\u7C7B\u65E0\u6CD5\u76F4\u63A5\u6269\u5C55 java.lang.Enum" },
{ "compiler.err.enum.types.not.extensible", "\u679A\u4E3E\u7C7B\u578B\u4E0D\u53EF\u7EE7\u627F" },
{ "compiler.err.enums.must.be.static", "\u53EA\u6709\u5728\u9759\u6001\u4E0A\u4E0B\u6587\u4E2D\u624D\u5141\u8BB8\u4F7F\u7528\u679A\u4E3E\u58F0\u660E" },
{ "compiler.err.enums.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u679A\u4E3E\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u679A\u4E3E)" },
{ "compiler.err.error", "\u9519\u8BEF: " },
{ "compiler.err.error.reading.file", "\u8BFB\u53D6{0}\u65F6\u51FA\u9519; {1}" },
{ "compiler.err.except.already.caught", "\u5DF2\u6355\u83B7\u5230\u5F02\u5E38\u9519\u8BEF{0}" },
{ "compiler.err.except.never.thrown.in.try", "\u5728\u76F8\u5E94\u7684 try \u8BED\u53E5\u4E3B\u4F53\u4E2D\u4E0D\u80FD\u629B\u51FA\u5F02\u5E38\u9519\u8BEF{0}" },
{ "compiler.err.expected", "\u9700\u8981{0}" },
{ "compiler.err.expected2", "\u9700\u8981{0}\u6216{1}" },
{ "compiler.err.expected3", "\u9700\u8981{0}, {1}\u6216{2}" },
{ "compiler.err.final.parameter.may.not.be.assigned", "\u4E0D\u80FD\u5206\u914D\u6700\u7EC8\u53C2\u6570{0}" },
{ "compiler.err.finally.without.try", "\u6709 ''finally'', \u4F46\u662F\u6CA1\u6709 ''try''" },
{ "compiler.err.foreach.not.applicable.to.type", "for-each \u4E0D\u9002\u7528\u4E8E\u8868\u8FBE\u5F0F\u7C7B\u578B\n\u8981\u6C42: {1}\n\u627E\u5230: {0}" },
{ "compiler.err.foreach.not.supported.in.source", "-source {0}\u4E2D\u4E0D\u652F\u6301\u589E\u5F3A\u578B for \u5FAA\u73AF\n(\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 for-each \u5FAA\u73AF)" },
{ "compiler.err.fp.number.too.large", "\u6D6E\u70B9\u6570\u8FC7\u5927" },
{ "compiler.err.fp.number.too.small", "\u6D6E\u70B9\u6570\u8FC7\u5C0F" },
{ "compiler.err.generic.array.creation", "\u521B\u5EFA\u6CDB\u578B\u6570\u7EC4" },
{ "compiler.err.generic.throwable", "\u6CDB\u578B\u7C7B\u4E0D\u80FD\u6269\u5C55 java.lang.Throwable" },
{ "compiler.err.generics.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u6CDB\u578B\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u6CDB\u578B)" },
{ "compiler.err.icls.cant.have.static.decl", "\u5185\u90E8\u7C7B{0}\u4E2D\u7684\u9759\u6001\u58F0\u660E\u975E\u6CD5\n\u4FEE\u9970\u7B26 ''static'' \u4EC5\u5141\u8BB8\u5728\u5E38\u91CF\u53D8\u91CF\u58F0\u660E\u4E2D\u4F7F\u7528" },
{ "compiler.err.illegal.char", "\u975E\u6CD5\u5B57\u7B26: ''{0}''" },
{ "compiler.err.illegal.char.for.encoding", "\u7F16\u7801{0}\u7684\u4E0D\u53EF\u6620\u5C04\u5B57\u7B26" },
{ "compiler.err.illegal.combination.of.modifiers", "\u975E\u6CD5\u7684\u4FEE\u9970\u7B26\u7EC4\u5408: {0}\u548C{1}" },
{ "compiler.err.illegal.default.super.call", "\u9ED8\u8BA4\u8D85\u7EA7\u8C03\u7528\u4E2D\u7684\u7C7B\u578B\u9650\u5B9A\u7B26{0}\u9519\u8BEF\n{1}" },
{ "compiler.err.illegal.dot", "\u975E\u6CD5 ''.''" },
{ "compiler.err.illegal.enum.static.ref", "\u521D\u59CB\u5316\u7A0B\u5E8F\u4E2D\u5BF9\u9759\u6001\u5B57\u6BB5\u7684\u5F15\u7528\u4E0D\u5408\u6CD5" },
{ "compiler.err.illegal.esc.char", "\u975E\u6CD5\u8F6C\u4E49\u7B26" },
{ "compiler.err.illegal.forward.ref", "\u975E\u6CD5\u524D\u5411\u5F15\u7528" },
{ "compiler.err.illegal.generic.type.for.instof", "instanceof \u7684\u6CDB\u578B\u7C7B\u578B\u4E0D\u5408\u6CD5" },
{ "compiler.err.illegal.initializer.for.type", "{0}\u7684\u521D\u59CB\u5316\u7A0B\u5E8F\u4E0D\u5408\u6CD5" },
{ "compiler.err.illegal.line.end.in.char.lit", "\u5B57\u7B26\u6587\u5B57\u7684\u884C\u7ED3\u5C3E\u4E0D\u5408\u6CD5" },
{ "compiler.err.illegal.nonascii.digit", "\u975E\u6CD5\u7684\u975E ASCII \u6570\u5B57" },
{ "compiler.err.illegal.qual.not.icls", "\u975E\u6CD5\u9650\u5B9A\u7B26; {0}\u4E0D\u662F\u5185\u90E8\u7C7B" },
{ "compiler.err.illegal.self.ref", "\u521D\u59CB\u5316\u7A0B\u5E8F\u4E2D\u5B58\u5728\u81EA\u5F15\u7528" },
{ "compiler.err.illegal.start.of.expr", "\u975E\u6CD5\u7684\u8868\u8FBE\u5F0F\u5F00\u59CB" },
{ "compiler.err.illegal.start.of.stmt", "\u975E\u6CD5\u7684\u8BED\u53E5\u5F00\u59CB" },
{ "compiler.err.illegal.start.of.type", "\u975E\u6CD5\u7684\u7C7B\u578B\u5F00\u59CB" },
{ "compiler.err.illegal.static.intf.meth.call", "\u9759\u6001\u63A5\u53E3\u65B9\u6CD5\u8C03\u7528\u975E\u6CD5\n\u5E94\u5C06\u63A5\u6536\u65B9\u8868\u8FBE\u5F0F\u66FF\u6362\u4E3A\u7C7B\u578B\u9650\u5B9A\u7B26 ''{0}''" },
{ "compiler.err.illegal.underscore", "\u975E\u6CD5\u4E0B\u5212\u7EBF" },
{ "compiler.err.illegal.unicode.esc", "\u975E\u6CD5\u7684 Unicode \u8F6C\u4E49" },
{ "compiler.err.import.requires.canonical", "\u5BFC\u5165\u9700\u8981{0}\u7684\u89C4\u8303\u540D\u79F0" },
{ "compiler.err.improperly.formed.type.inner.raw.param", "\u7C7B\u578B\u7684\u683C\u5F0F\u4E0D\u6B63\u786E, \u7ED9\u51FA\u4E86\u539F\u59CB\u7C7B\u578B\u7684\u7C7B\u578B\u53C2\u6570" },
{ "compiler.err.improperly.formed.type.param.missing", "\u7C7B\u578B\u7684\u683C\u5F0F\u4E0D\u6B63\u786E, \u7F3A\u5C11\u67D0\u4E9B\u53C2\u6570" },
{ "compiler.err.incomparable.types", "\u4E0D\u53EF\u6BD4\u8F83\u7684\u7C7B\u578B: {0}\u548C{1}" },
{ "compiler.err.incompatible.thrown.types.in.mref", "\u65B9\u6CD5\u5F15\u7528\u4E2D\u629B\u51FA\u7684\u7C7B\u578B{0}\u4E0D\u517C\u5BB9" },
{ "compiler.err.incorrect.constructor.receiver.name", "\u63A5\u6536\u65B9\u540D\u79F0\u4E0E\u5916\u90E8\u5C01\u95ED\u7C7B\u7C7B\u578B\u4E0D\u5339\u914D\n\u9700\u8981: {0}\n\u627E\u5230: {1}" },
{ "compiler.err.incorrect.constructor.receiver.type", "\u63A5\u6536\u65B9\u7C7B\u578B\u4E0E\u5916\u90E8\u5C01\u95ED\u7C7B\u7C7B\u578B\u4E0D\u5339\u914D\n\u9700\u8981: {0}\n\u627E\u5230: {1}" },
{ "compiler.err.incorrect.receiver.name", "\u63A5\u6536\u65B9\u540D\u79F0\u4E0E\u5C01\u95ED\u7C7B\u7C7B\u578B\u4E0D\u5339\u914D\n\u9700\u8981: {0}\n\u627E\u5230: {1}" },
{ "compiler.err.incorrect.receiver.type", "\u63A5\u6536\u65B9\u7C7B\u578B\u4E0E\u5C01\u95ED\u7C7B\u7C7B\u578B\u4E0D\u5339\u914D\n\u9700\u8981: {0}\n\u627E\u5230: {1}" },
{ "compiler.err.initializer.must.be.able.to.complete.normally", "\u521D\u59CB\u5316\u7A0B\u5E8F\u5FC5\u987B\u80FD\u591F\u6B63\u5E38\u5B8C\u6210" },
{ "compiler.err.int.number.too.large", "\u8FC7\u5927\u7684\u6574\u6570: {0}" },
{ "compiler.err.intersection.types.in.cast.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u8F6C\u6362\u4E2D\u7684\u4EA4\u53C9\u7C7B\u578B\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u9ED8\u8BA4\u65B9\u6CD5)" },
{ "compiler.err.intf.annotation.cant.have.type.params", "\u6CE8\u91CA\u7C7B\u578B {0} \u4E0D\u80FD\u4E3A\u6CDB\u578B" },
{ "compiler.err.intf.annotation.member.clash", "\u6CE8\u91CA\u7C7B\u578B{1}\u58F0\u660E\u4E0E\u65B9\u6CD5 {0} \u540C\u540D\u7684\u5143\u7D20" },
{ "compiler.err.intf.annotation.members.cant.have.params", "\u6CE8\u91CA\u7C7B\u578B\u58F0\u660E\u4E2D\u7684\u5143\u7D20\u65E0\u6CD5\u58F0\u660E\u5F62\u53C2" },
{ "compiler.err.intf.annotation.members.cant.have.type.params", "\u6CE8\u91CA\u7C7B\u578B\u58F0\u660E\u4E2D\u7684\u5143\u7D20\u4E0D\u80FD\u4E3A\u6CDB\u578B\u65B9\u6CD5" },
{ "compiler.err.intf.expected.here", "\u6B64\u5904\u9700\u8981\u63A5\u53E3" },
{ "compiler.err.intf.meth.cant.have.body", "\u63A5\u53E3\u62BD\u8C61\u65B9\u6CD5\u4E0D\u80FD\u5E26\u6709\u4E3B\u4F53" },
{ "compiler.err.intf.not.allowed.here", "\u6B64\u5904\u4E0D\u5141\u8BB8\u4F7F\u7528\u63A5\u53E3" },
{ "compiler.err.invalid.annotation.member.type", "\u6CE8\u91CA\u7C7B\u578B\u5143\u7D20 {0} \u7684\u7C7B\u578B\u65E0\u6548" },
{ "compiler.err.invalid.binary.number", "\u4E8C\u8FDB\u5236\u6570\u5B57\u4E2D\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u4E00\u4E2A\u4E8C\u8FDB\u5236\u6570" },
{ "compiler.err.invalid.hex.number", "\u5341\u516D\u8FDB\u5236\u6570\u5B57\u5FC5\u987B\u5305\u542B\u81F3\u5C11\u4E00\u4F4D\u5341\u516D\u8FDB\u5236\u6570" },
{ "compiler.err.invalid.meth.decl.ret.type.req", "\u65B9\u6CD5\u58F0\u660E\u65E0\u6548; \u9700\u8981\u8FD4\u56DE\u7C7B\u578B" },
{ "compiler.err.invalid.mref", "{0}\u5F15\u7528\u65E0\u6548\n{1}" },
{ "compiler.err.invalid.repeatable.annotation", "\u6CE8\u91CA\u91CD\u590D: \u4F7F\u7528\u65E0\u6548\u7684 @Repeatable \u6CE8\u91CA\u5BF9{0}\u8FDB\u884C\u4E86\u6CE8\u91CA" },
{ "compiler.err.invalid.repeatable.annotation.elem.nondefault", "\u5BF9\u4E8E\u5143\u7D20 {1}, \u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u6CA1\u6709\u9ED8\u8BA4\u503C" },
{ "compiler.err.invalid.repeatable.annotation.incompatible.target", "\u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u9002\u7528\u7684\u76EE\u6807\u591A\u4E8E\u53EF\u91CD\u590D\u6CE8\u91CA\u7C7B\u578B ({1})" },
{ "compiler.err.invalid.repeatable.annotation.invalid.value", "{0}\u4E0D\u662F\u6709\u6548\u7684 @Repeatable: \u503C\u5143\u7D20\u65E0\u6548" },
{ "compiler.err.invalid.repeatable.annotation.multiple.values", "{0}\u4E0D\u662F\u6709\u6548\u7684 @Repeatable, \u5DF2\u58F0\u660E {1} \u4E2A\u540D\u4E3A ''value'' \u7684\u5143\u7D20\u65B9\u6CD5" },
{ "compiler.err.invalid.repeatable.annotation.no.value", "{0}\u4E0D\u662F\u6709\u6548\u7684 @Repeatable, \u672A\u58F0\u660E\u4EFB\u4F55\u503C\u5143\u7D20\u65B9\u6CD5" },
{ "compiler.err.invalid.repeatable.annotation.not.documented", "\u53EF\u91CD\u590D\u6CE8\u91CA\u7C7B\u578B ({1}) \u662F @Documented, \u800C\u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u5219\u4E0D\u662F" },
{ "compiler.err.invalid.repeatable.annotation.not.inherited", "\u53EF\u91CD\u590D\u6CE8\u91CA\u7C7B\u578B ({1}) \u662F @Inherited, \u800C\u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u5219\u4E0D\u662F" },
{ "compiler.err.invalid.repeatable.annotation.repeated.and.container.present", "\u5BB9\u5668 {0} \u4E0D\u5F97\u4E0E\u5176\u5305\u542B\u7684\u5143\u7D20\u540C\u65F6\u5B58\u5728" },
{ "compiler.err.invalid.repeatable.annotation.retention", "\u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u7684\u4FDD\u7559\u671F\u77ED\u4E8E\u53EF\u91CD\u590D\u6CE8\u91CA\u7C7B\u578B ({2}) \u7684\u4FDD\u7559\u671F" },
{ "compiler.err.invalid.repeatable.annotation.value.return", "\u5305\u542B\u6CE8\u91CA\u7C7B\u578B ({0}) \u5FC5\u987B\u58F0\u660E\u7C7B\u578B{2}\u7684\u540D\u4E3A ''value'' \u7684\u5143\u7D20" },
{ "compiler.err.io.exception", "\u8BFB\u53D6\u6E90\u6587\u4EF6\u65F6\u51FA\u9519: {0}" },
{ "compiler.err.label.already.in.use", "\u6807\u7B7E{0}\u5DF2\u4F7F\u7528" },
{ "compiler.err.lambda.body.neither.value.nor.void.compatible", "lambda \u4E3B\u4F53\u4E0D\u662F\u503C, \u4E5F\u4E0D\u4E0E void \u517C\u5BB9" },
{ "compiler.err.lambda.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 lambda \u8868\u8FBE\u5F0F\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 lambda \u8868\u8FBE\u5F0F)" },
{ "compiler.err.limit.code", "\u4EE3\u7801\u8FC7\u957F" },
{ "compiler.err.limit.code.too.large.for.try.stmt", "try \u8BED\u53E5\u7684\u4EE3\u7801\u8FC7\u957F" },
{ "compiler.err.limit.dimensions", "\u6570\u7EC4\u7C7B\u578B\u7EF4\u8FC7\u591A" },
{ "compiler.err.limit.locals", "\u672C\u5730\u53D8\u91CF\u8FC7\u591A" },
{ "compiler.err.limit.parameters", "\u53C2\u6570\u8FC7\u591A" },
{ "compiler.err.limit.pool", "\u5E38\u91CF\u8FC7\u591A" },
{ "compiler.err.limit.pool.in.class", "\u7C7B{0}\u4E2D\u7684\u5E38\u91CF\u8FC7\u591A" },
{ "compiler.err.limit.stack", "\u4EE3\u7801\u9700\u8981\u8FC7\u591A\u5806\u6808" },
{ "compiler.err.limit.string", "\u5E38\u91CF\u5B57\u7B26\u4E32\u8FC7\u957F" },
{ "compiler.err.limit.string.overflow", "\u5BF9\u4E8E\u5E38\u91CF\u6C60\u6765\u8BF4, \u5B57\u7B26\u4E32 \"{0}...\" \u7684 UTF8 \u8868\u793A\u8FC7\u957F" },
{ "compiler.err.local.enum", "\u679A\u4E3E\u7C7B\u578B\u4E0D\u80FD\u4E3A\u672C\u5730\u7C7B\u578B" },
{ "compiler.err.local.var.accessed.from.icls.needs.final", "\u4ECE\u5185\u90E8\u7C7B\u4E2D\u8BBF\u95EE\u672C\u5730\u53D8\u91CF{0}; \u9700\u8981\u88AB\u58F0\u660E\u4E3A\u6700\u7EC8\u7C7B\u578B" },
{ "compiler.err.malformed.fp.lit", "\u6D6E\u70B9\u6587\u5B57\u7684\u683C\u5F0F\u9519\u8BEF" },
{ "compiler.err.method.does.not.override.superclass", "\u65B9\u6CD5\u4E0D\u4F1A\u8986\u76D6\u6216\u5B9E\u73B0\u8D85\u7C7B\u578B\u7684\u65B9\u6CD5" },
{ "compiler.err.method.invoked.with.incorrect.number.arguments", "\u4F7F\u7528\u4E0D\u6B63\u786E\u6570\u91CF\u7684\u53C2\u6570\u8C03\u7528\u4E86\u65B9\u6CD5; \u9884\u671F\u4E3A {0} \u4E2A, \u627E\u5230 {1} \u4E2A" },
{ "compiler.err.method.references.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u65B9\u6CD5\u5F15\u7528\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u65B9\u6CD5\u5F15\u7528)" },
{ "compiler.err.missing.meth.body.or.decl.abstract", "\u7F3A\u5C11\u65B9\u6CD5\u4E3B\u4F53, \u6216\u58F0\u660E\u62BD\u8C61" },
{ "compiler.err.missing.ret.stmt", "\u7F3A\u5C11\u8FD4\u56DE\u8BED\u53E5" },
{ "compiler.err.mod.not.allowed.here", "\u6B64\u5904\u4E0D\u5141\u8BB8\u4F7F\u7528\u4FEE\u9970\u7B26{0}" },
{ "compiler.err.multicatch.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 multi-catch \u8BED\u53E5\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 multi-catch \u8BED\u53E5)" },
{ "compiler.err.multicatch.parameter.may.not.be.assigned", "\u53EF\u80FD\u672A\u5206\u914D multi-catch \u53C2\u6570{0}" },
{ "compiler.err.multicatch.types.must.be.disjoint", "multi-catch \u8BED\u53E5\u4E2D\u7684\u66FF\u4EE3\u65E0\u6CD5\u901A\u8FC7\u5B50\u7C7B\u5316\u5173\u8054\n\u66FF\u4EE3{0}\u662F\u66FF\u4EE3{1}\u7684\u5B50\u7C7B" },
{ "compiler.err.name.clash.same.erasure", "\u540D\u79F0\u51B2\u7A81: {0}\u548C{1}\u5177\u6709\u76F8\u540C\u7591\u7B26" },
{ "compiler.err.name.clash.same.erasure.no.hide", "\u540D\u79F0\u51B2\u7A81: {1} \u4E2D\u7684 {0} \u548C {3} \u4E2D\u7684 {2} \u5177\u6709\u76F8\u540C\u7591\u7B26, \u4F46\u4E24\u8005\u5747\u4E0D\u9690\u85CF\u5BF9\u65B9" },
{ "compiler.err.name.clash.same.erasure.no.override", "\u540D\u79F0\u51B2\u7A81: {1}\u4E2D\u7684{0}\u548C{3}\u4E2D\u7684{2}\u5177\u6709\u76F8\u540C\u7591\u7B26, \u4F46\u4E24\u8005\u5747\u4E0D\u8986\u76D6\u5BF9\u65B9" },
{ "compiler.err.name.clash.same.erasure.no.override.1", "\u540D\u79F0\u51B2\u7A81: {1} \u4E2D\u7684 {0} \u8986\u76D6\u7684\u65B9\u6CD5\u7684\u7591\u7B26\u4E0E\u53E6\u4E00\u4E2A\u65B9\u6CD5\u7684\u76F8\u540C, \u4F46\u4E24\u8005\u5747\u4E0D\u8986\u76D6\u5BF9\u65B9\n\u7B2C\u4E00\u4E2A\u65B9\u6CD5: {3} \u4E2D\u7684 {2}\n\u7B2C\u4E8C\u4E2A\u65B9\u6CD5: {5} \u4E2D\u7684 {4}" },
{ "compiler.err.name.reserved.for.internal.use", "{0}\u4E3A\u5185\u90E8\u4F7F\u7528\u4FDD\u7559" },
{ "compiler.err.native.meth.cant.have.body", "\u672C\u673A\u65B9\u6CD5\u4E0D\u80FD\u5E26\u6709\u4E3B\u4F53" },
{ "compiler.err.neither.conditional.subtype", "? \u7684\u4E0D\u517C\u5BB9\u7C7B\u578B: \u4E24\u8005\u90FD\u4E0D\u662F\u5BF9\u65B9\u7684\u5B50\u7C7B\u578B\n\u7B2C\u4E8C\u4E2A\u64CD\u4F5C\u6570: {0}\n\u7B2C\u4E09\u4E2A\u64CD\u4F5C\u6570: {1}" },
{ "compiler.err.new.not.allowed.in.annotation", "\u6CE8\u91CA\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528 ''new''" },
{ "compiler.err.no.annotation.member", "{1}\u4E2D\u6CA1\u6709\u6CE8\u91CA\u6210\u5458{0}" },
{ "compiler.err.no.annotations.on.dot.class", "\u7C7B\u6587\u5B57\u7C7B\u578B\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u4EFB\u4F55\u6CE8\u91CA" },
{ "compiler.err.no.encl.instance.of.type.in.scope", "\u4F5C\u7528\u57DF\u4E2D\u6CA1\u6709\u7C7B\u578B\u4E3A{0}\u7684\u5C01\u95ED\u5B9E\u4F8B" },
{ "compiler.err.no.intf.expected.here", "\u6B64\u5904\u4E0D\u9700\u8981\u63A5\u53E3" },
{ "compiler.err.no.match.entry", "{0}\u5728{1}\u7684\u6761\u76EE\u4E2D\u6CA1\u6709\u5339\u914D\u9879; \u9700\u8981{2}" },
{ "compiler.err.no.superclass", "{0}\u4E0D\u5177\u6709\u8D85\u7C7B\u3002" },
{ "compiler.err.non-static.cant.be.ref", "\u65E0\u6CD5\u4ECE\u9759\u6001\u4E0A\u4E0B\u6587\u4E2D\u5F15\u7528\u975E\u9759\u6001 {0} {1}" },
{ "compiler.err.not.annotation.type", "{0}\u4E0D\u662F\u6CE8\u91CA\u7C7B\u578B" },
{ "compiler.err.not.def.access.class.intf.cant.access", "{1}\u4E2D\u7684{0}\u662F\u5728\u4E0D\u53EF\u8BBF\u95EE\u7684\u7C7B\u6216\u63A5\u53E3\u4E2D\u5B9A\u4E49\u7684" },
{ "compiler.err.not.def.public.cant.access", "{0}\u5728{1}\u4E2D\u4E0D\u662F\u516C\u5171\u7684; \u65E0\u6CD5\u4ECE\u5916\u90E8\u7A0B\u5E8F\u5305\u4E2D\u5BF9\u5176\u8FDB\u884C\u8BBF\u95EE" },
{ "compiler.err.not.encl.class", "\u4E0D\u662F\u5C01\u95ED\u7C7B: {0}" },
{ "compiler.err.not.in.profile", "{0}\u5728\u914D\u7F6E\u6587\u4EF6 ''{1}'' \u4E2D\u4E0D\u53EF\u7528" },
{ "compiler.err.not.loop.label", "\u4E0D\u662F loop \u6807\u7B7E: {0}" },
{ "compiler.err.not.stmt", "\u4E0D\u662F\u8BED\u53E5" },
{ "compiler.err.not.within.bounds", "\u7C7B\u578B\u53C2\u6570{0}\u4E0D\u5728\u7C7B\u578B\u53D8\u91CF{1}\u7684\u8303\u56F4\u5185" },
{ "compiler.err.operator.cant.be.applied", "\u4E00\u5143\u8FD0\u7B97\u7B26 ''{0}'' \u7684\u64CD\u4F5C\u6570\u7C7B\u578B{1}\u9519\u8BEF" },
{ "compiler.err.operator.cant.be.applied.1", "\u4E8C\u5143\u8FD0\u7B97\u7B26 ''{0}'' \u7684\u64CD\u4F5C\u6570\u7C7B\u578B\u9519\u8BEF\n\u7B2C\u4E00\u4E2A\u7C7B\u578B: {1}\n\u7B2C\u4E8C\u4E2A\u7C7B\u578B: {2}" },
{ "compiler.err.orphaned", "\u5B64\u7ACB\u7684{0}" },
{ "compiler.err.override.incompatible.ret", "{0}\n\u8FD4\u56DE\u7C7B\u578B{1}\u4E0E{2}\u4E0D\u517C\u5BB9" },
{ "compiler.err.override.meth", "{0}\n\u88AB\u8986\u76D6\u7684\u65B9\u6CD5\u4E3A{1}" },
{ "compiler.err.override.meth.doesnt.throw", "{0}\n\u88AB\u8986\u76D6\u7684\u65B9\u6CD5\u672A\u629B\u51FA{1}" },
{ "compiler.err.override.static", "{0}\n\u8986\u76D6\u7684\u65B9\u6CD5\u4E3A static" },
{ "compiler.err.override.weaker.access", "{0}\n\u6B63\u5728\u5C1D\u8BD5\u5206\u914D\u66F4\u4F4E\u7684\u8BBF\u95EE\u6743\u9650; \u4EE5\u524D\u4E3A{1}" },
{ "compiler.err.pkg.annotations.sb.in.package-info.java", "\u7A0B\u5E8F\u5305\u6CE8\u91CA\u5E94\u5728\u6587\u4EF6 package-info.java \u4E2D" },
{ "compiler.err.pkg.clashes.with.class.of.same.name", "\u7A0B\u5E8F\u5305{0}\u4E0E\u5E26\u6709\u76F8\u540C\u540D\u79F0\u7684\u7C7B\u51B2\u7A81" },
{ "compiler.err.premature.eof", "\u89E3\u6790\u65F6\u5DF2\u5230\u8FBE\u6587\u4EF6\u7ED3\u5C3E" },
{ "compiler.err.prob.found.req", "\u4E0D\u517C\u5BB9\u7684\u7C7B\u578B: {0}" },
{ "compiler.err.proc.bad.config.file", "\u670D\u52A1\u914D\u7F6E\u6587\u4EF6\u4E0D\u6B63\u786E, \u6216\u6784\u9020\u5904\u7406\u7A0B\u5E8F\u5BF9\u8C61{0}\u65F6\u629B\u51FA\u5F02\u5E38\u9519\u8BEF" },
{ "compiler.err.proc.cant.access", "\u65E0\u6CD5\u8BBF\u95EE{0}\n{1}\n\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u53C2\u9605\u4EE5\u4E0B\u5806\u6808\u8DDF\u8E2A\u3002\n{2}" },
{ "compiler.err.proc.cant.access.1", "\u65E0\u6CD5\u8BBF\u95EE{0}\n{1}" },
{ "compiler.err.proc.cant.create.loader", "\u65E0\u6CD5\u4E3A\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F{0}\u521B\u5EFA\u7C7B\u52A0\u8F7D\u5668" },
{ "compiler.err.proc.cant.find.class", "\u627E\u4E0D\u5230 ''{0}'' \u7684\u7C7B\u6587\u4EF6\u3002" },
{ "compiler.err.proc.messager", "{0}" },
{ "compiler.err.proc.no.explicit.annotation.processing.requested", "\u4EC5\u5F53\u663E\u5F0F\u8BF7\u6C42\u6CE8\u91CA\u5904\u7406\u65F6\u624D\u63A5\u53D7\u7C7B\u540D\u79F0 ''{0}''" },
{ "compiler.err.proc.no.service", "ServiceLoader \u4E0D\u53EF\u7528, \u4F46\u5B83\u662F\u6CE8\u91CA\u5904\u7406\u6240\u5FC5\u9700\u7684\u3002" },
{ "compiler.err.proc.processor.bad.option.name", "\u5904\u7406\u7A0B\u5E8F ''{1}'' \u63D0\u4F9B\u7684\u9009\u9879\u540D\u79F0 ''{0}'' \u9519\u8BEF" },
{ "compiler.err.proc.processor.cant.instantiate", "\u65E0\u6CD5\u5B9E\u4F8B\u5316\u5904\u7406\u7A0B\u5E8F ''{0}'' \u7684\u5B9E\u4F8B" },
{ "compiler.err.proc.processor.not.found", "\u627E\u4E0D\u5230\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F ''{0}''" },
{ "compiler.err.proc.processor.wrong.type", "\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F ''{0}'' \u672A\u5B9E\u73B0 javax.annotation.processing.Processor" },
{ "compiler.err.proc.service.problem", "\u521B\u5EFA\u670D\u52A1\u52A0\u8F7D\u5668\u4EE5\u52A0\u8F7D\u5904\u7406\u7A0B\u5E8F\u65F6\u51FA\u9519\u3002" },
{ "compiler.err.qualified.new.of.static.class", "\u9650\u5B9A\u7684\u65B0\u9759\u6001\u7C7B" },
{ "compiler.err.receiver.parameter.not.applicable.constructor.toplevel.class", "\u63A5\u6536\u65B9\u53C2\u6570\u4E0D\u9002\u7528\u4E8E\u9876\u5C42\u7C7B\u7684\u6784\u9020\u5668" },
{ "compiler.err.recursive.ctor.invocation", "\u9012\u5F52\u6784\u9020\u5668\u8C03\u7528" },
{ "compiler.err.ref.ambiguous", "\u5BF9{0}\u7684\u5F15\u7528\u4E0D\u660E\u786E\n{3} \u4E2D\u7684{1} {2} \u548C {6} \u4E2D\u7684{4} {5} \u90FD\u5339\u914D" },
{ "compiler.err.repeatable.annotations.not.supported.in.source", "-source {0}\u4E2D\u4E0D\u652F\u6301\u91CD\u590D\u6CE8\u91CA\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u91CD\u590D\u6CE8\u91CA)" },
{ "compiler.err.repeated.annotation.target", "\u6CE8\u91CA\u76EE\u6807\u91CD\u590D" },
{ "compiler.err.repeated.interface", "\u63A5\u53E3\u91CD\u590D" },
{ "compiler.err.repeated.modifier", "\u4FEE\u9970\u7B26\u91CD\u590D" },
{ "compiler.err.report.access", "{0} \u5728 {2} \u4E2D\u662F {1} \u8BBF\u95EE\u63A7\u5236" },
{ "compiler.err.ret.outside.meth", "\u8FD4\u56DE\u5916\u90E8\u65B9\u6CD5" },
{ "compiler.err.signature.doesnt.match.intf", "\u7B7E\u540D\u4E0E{0}\u4E0D\u5339\u914D; \u4E0D\u517C\u5BB9\u7684\u63A5\u53E3" },
{ "compiler.err.signature.doesnt.match.supertype", "\u7B7E\u540D\u4E0E{0}\u4E0D\u5339\u914D; \u4E0D\u517C\u5BB9\u7684\u8D85\u7C7B\u578B" },
{ "compiler.err.source.cant.overwrite.input.file", "\u5199\u5165\u6E90\u65F6\u51FA\u9519; \u65E0\u6CD5\u8986\u76D6\u8F93\u5165\u6587\u4EF6{0}" },
{ "compiler.err.stack.sim.error", "\u5185\u90E8\u9519\u8BEF: {0}\u4E2D\u7684\u5806\u6808 sim \u9519\u8BEF" },
{ "compiler.err.static.imp.only.classes.and.interfaces", "\u4EC5\u4ECE\u7C7B\u548C\u63A5\u53E3\u9759\u6001\u5BFC\u5165" },
{ "compiler.err.static.import.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u9759\u6001\u5BFC\u5165\u58F0\u660E\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u9759\u6001\u5BFC\u5165\u58F0\u660E)" },
{ "compiler.err.static.intf.method.invoke.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u9759\u6001\u63A5\u53E3\u65B9\u6CD5\u8C03\u7528\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u9759\u6001\u63A5\u53E3\u65B9\u6CD5\u8C03\u7528)" },
{ "compiler.err.static.intf.methods.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u9759\u6001\u63A5\u53E3\u65B9\u6CD5\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u9759\u6001\u63A5\u53E3\u65B9\u6CD5)" },
{ "compiler.err.string.const.req", "\u9700\u8981\u5E38\u91CF\u5B57\u7B26\u4E32\u8868\u8FBE\u5F0F" },
{ "compiler.err.string.switch.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 switch \u4E2D\u5B58\u5728\u5B57\u7B26\u4E32\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u5141\u8BB8 switch \u4E2D\u5B58\u5728\u5B57\u7B26\u4E32)" },
{ "compiler.err.synthetic.name.conflict", "\u7B26\u53F7{0}\u4E0E{1}\u4E2D\u7684 compiler-synthesized \u7B26\u53F7\u51B2\u7A81" },
{ "compiler.err.this.as.identifier", "\u4ECE\u53D1\u884C\u7248 8 \u5F00\u59CB, ''this'' \u53EA\u80FD\u4F5C\u4E3A\u63A5\u6536\u65B9\u7C7B\u578B\u7684\u53C2\u6570\u540D, \u8BE5\u53C2\u6570\u5FC5\u987B\u4E3A\u7B2C\u4E00\u4E2A\u53C2\u6570" },
{ "compiler.err.throws.not.allowed.in.intf.annotation", "@interface \u6210\u5458\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528 throws \u5B50\u53E5" },
{ "compiler.err.try.resource.may.not.be.assigned", "\u53EF\u80FD\u672A\u5206\u914D\u53EF\u81EA\u52A8\u5173\u95ED\u7684\u8D44\u6E90{0}" },
{ "compiler.err.try.with.resources.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 try-with-resources\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 try-with-resources)" },
{ "compiler.err.try.without.catch.finally.or.resource.decls", "''try'' \u4E0D\u5E26\u6709 ''catch'', ''finally'' \u6216\u8D44\u6E90\u58F0\u660E" },
{ "compiler.err.try.without.catch.or.finally", "\u6709 ''try'', \u4F46\u662F\u6CA1\u6709 ''catch'' \u6216 ''finally''" },
{ "compiler.err.type.annotations.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301\u7C7B\u578B\u6CE8\u91CA\n(\u8BF7\u4F7F\u7528 -source 8 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u7C7B\u578B\u6CE8\u91CA)" },
{ "compiler.err.type.doesnt.take.params", "\u7C7B\u578B{0}\u4E0D\u5E26\u6709\u53C2\u6570" },
{ "compiler.err.type.found.req", "\u610F\u5916\u7684\u7C7B\u578B\n\u9700\u8981: {1}\n\u627E\u5230: {0}" },
{ "compiler.err.type.var.cant.be.deref", "\u65E0\u6CD5\u4ECE\u7C7B\u578B\u53D8\u91CF\u4E2D\u8FDB\u884C\u9009\u62E9" },
{ "compiler.err.type.var.may.not.be.followed.by.other.bounds", "\u7C7B\u578B\u53D8\u91CF\u540E\u9762\u4E0D\u80FD\u5E26\u6709\u5176\u4ED6\u9650\u5236\u8303\u56F4" },
{ "compiler.err.type.var.more.than.once", "\u7C7B\u578B\u53D8\u91CF{0}\u5728{1}\u7684\u7ED3\u679C\u7C7B\u578B\u4E2D\u591A\u6B21\u51FA\u73B0; \u5FC5\u987B\u5BF9\u5176\u8FDB\u884C\u5B9E\u4F8B\u5316" },
{ "compiler.err.type.var.more.than.once.in.result", "\u7C7B\u578B\u53D8\u91CF{0}\u5728{1}\u7684\u7C7B\u578B\u4E2D\u591A\u6B21\u51FA\u73B0; \u5FC5\u987B\u5BF9\u5176\u8FDB\u884C\u5B9E\u4F8B\u5316" },
{ "compiler.err.types.incompatible.abstract.default", "{0} {1}\u4ECE\u7C7B\u578B {4} \u548C {5} \u4E2D\u7EE7\u627F\u4E86{2}({3}) \u7684\u62BD\u8C61\u548C\u9ED8\u8BA4\u503C" },
{ "compiler.err.types.incompatible.diff.ret", "\u7C7B\u578B{0}\u548C{1}\u4E0D\u517C\u5BB9; \u4E24\u8005\u90FD\u5B9A\u4E49\u4E86{2}, \u4F46\u5374\u5E26\u6709\u4E0D\u76F8\u5173\u7684\u8FD4\u56DE\u7C7B\u578B" },
{ "compiler.err.types.incompatible.unrelated.defaults", "{0} {1}\u4ECE\u7C7B\u578B {4} \u548C {5} \u4E2D\u7EE7\u627F\u4E86{2}({3}) \u7684\u4E0D\u76F8\u5173\u9ED8\u8BA4\u503C" },
{ "compiler.err.unclosed.char.lit", "\u672A\u7ED3\u675F\u7684\u5B57\u7B26\u6587\u5B57" },
{ "compiler.err.unclosed.comment", "\u672A\u7ED3\u675F\u7684\u6CE8\u91CA" },
{ "compiler.err.unclosed.str.lit", "\u672A\u7ED3\u675F\u7684\u5B57\u7B26\u4E32\u6587\u5B57" },
{ "compiler.err.undef.label", "\u672A\u5B9A\u4E49\u7684\u6807\u7B7E: {0}" },
{ "compiler.err.underscore.as.identifier.in.lambda", "''_'' \u7528\u4F5C\u6807\u8BC6\u7B26\n(\u5BF9\u4E8E lambda \u53C2\u6570, \u7981\u6B62\u5C06 ''_'' \u7528\u4F5C\u6807\u8BC6\u7B26)" },
{ "compiler.err.unexpected.lambda", "\u6B64\u5904\u4E0D\u5E94\u4E3A lambda \u8868\u8FBE\u5F0F" },
{ "compiler.err.unexpected.mref", "\u6B64\u5904\u4E0D\u5E94\u4E3A\u65B9\u6CD5\u5F15\u7528" },
{ "compiler.err.unexpected.type", "\u610F\u5916\u7684\u7C7B\u578B\n\u9700\u8981: {0}\n\u627E\u5230: {1}" },
{ "compiler.err.unreachable.stmt", "\u65E0\u6CD5\u8BBF\u95EE\u7684\u8BED\u53E5" },
{ "compiler.err.unreported.exception.default.constructor", "\u9ED8\u8BA4\u6784\u9020\u5668\u4E2D\u672A\u62A5\u544A\u7684\u5F02\u5E38\u9519\u8BEF{0}" },
{ "compiler.err.unreported.exception.implicit.close", "\u672A\u62A5\u544A\u7684\u5F02\u5E38\u9519\u8BEF{0}; \u5FC5\u987B\u5BF9\u5176\u8FDB\u884C\u6355\u83B7\u6216\u58F0\u660E\u4EE5\u4FBF\u629B\u51FA\n\u5BF9\u8D44\u6E90\u53D8\u91CF ''{1}'' \u9690\u5F0F\u8C03\u7528 close() \u65F6\u629B\u51FA\u4E86\u5F02\u5E38\u9519\u8BEF" },
{ "compiler.err.unreported.exception.need.to.catch.or.throw", "\u672A\u62A5\u544A\u7684\u5F02\u5E38\u9519\u8BEF{0}; \u5FC5\u987B\u5BF9\u5176\u8FDB\u884C\u6355\u83B7\u6216\u58F0\u660E\u4EE5\u4FBF\u629B\u51FA" },
{ "compiler.err.unsupported.binary.lit", "-source {0} \u4E2D\u4E0D\u652F\u6301\u4E8C\u8FDB\u5236\u6587\u5B57\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u4E8C\u8FDB\u5236\u6587\u5B57)" },
{ "compiler.err.unsupported.cross.fp.lit", "\u8BE5 VM \u4E0D\u652F\u6301\u5341\u516D\u8FDB\u5236\u6D6E\u70B9\u6587\u5B57" },
{ "compiler.err.unsupported.encoding", "\u4E0D\u652F\u6301\u7684\u7F16\u7801: {0}" },
{ "compiler.err.unsupported.fp.lit", "-source {0} \u4E2D\u4E0D\u652F\u6301\u5341\u516D\u8FDB\u5236\u6D6E\u70B9\u6587\u5B57\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528\u5341\u516D\u8FDB\u5236\u6D6E\u70B9\u6587\u5B57)" },
{ "compiler.err.unsupported.underscore.lit", "-source {0} \u4E2D\u4E0D\u652F\u6301\u6587\u5B57\u4E2D\u5B58\u5728\u4E0B\u5212\u7EBF\n(\u8BF7\u4F7F\u7528 -source 7 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u5141\u8BB8\u6587\u5B57\u4E2D\u5B58\u5728\u4E0B\u5212\u7EBF)" },
{ "compiler.err.var.might.already.be.assigned", "\u53EF\u80FD\u5DF2\u5206\u914D\u53D8\u91CF{0}" },
{ "compiler.err.var.might.be.assigned.in.loop", "\u53EF\u80FD\u5728 loop \u4E2D\u5206\u914D\u4E86\u53D8\u91CF{0}" },
{ "compiler.err.var.might.not.have.been.initialized", "\u53EF\u80FD\u5C1A\u672A\u521D\u59CB\u5316\u53D8\u91CF{0}" },
{ "compiler.err.var.not.initialized.in.default.constructor", "\u53D8\u91CF {0} \u672A\u5728\u9ED8\u8BA4\u6784\u9020\u5668\u4E2D\u521D\u59CB\u5316" },
{ "compiler.err.varargs.and.old.array.syntax", "variable-arity \u53C2\u6570\u4E2D\u4E0D\u5141\u8BB8\u4F7F\u7528\u4F20\u7EDF\u6570\u7EC4\u8BB0\u53F7" },
{ "compiler.err.varargs.and.receiver", "\u63A5\u6536\u65B9\u53C2\u6570\u4E0D\u5141\u8BB8\u4F7F\u7528 varargs \u8BB0\u53F7" },
{ "compiler.err.varargs.invalid.trustme.anno", "{0} \u6CE8\u91CA\u65E0\u6548\u3002{1}" },
{ "compiler.err.varargs.not.supported.in.source", "-source {0} \u4E2D\u4E0D\u652F\u6301 variable-arity \u65B9\u6CD5\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u542F\u7528 variable-arity \u65B9\u6CD5)" },
{ "compiler.err.variable.not.allowed", "\u6B64\u5904\u4E0D\u5141\u8BB8\u4F7F\u7528\u53D8\u91CF\u58F0\u660E" },
{ "compiler.err.void.not.allowed.here", "\u6B64\u5904\u4E0D\u5141\u8BB8\u4F7F\u7528 ''\u7A7A'' \u7C7B\u578B" },
{ "compiler.err.warnings.and.werror", "\u53D1\u73B0\u8B66\u544A, \u4F46\u6307\u5B9A\u4E86 -Werror" },
{ "compiler.err.wrong.number.type.args", "\u7C7B\u578B\u53D8\u91CF\u6570\u76EE\u9519\u8BEF; \u9700\u8981{0}" },
{ "compiler.misc.anonymous.class", "<\u533F\u540D{0}>" },
{ "compiler.misc.applicable.method.found", "\u627E\u5230\u7B2C {0} \u4E2A\u9002\u7528\u65B9\u6CD5: {1}" },
{ "compiler.misc.applicable.method.found.1", "\u627E\u5230\u7B2C {0} \u4E2A\u9002\u7528\u65B9\u6CD5: {1}\n({2})" },
{ "compiler.misc.arg.length.mismatch", "\u5B9E\u9645\u53C2\u6570\u5217\u8868\u548C\u5F62\u5F0F\u53C2\u6570\u5217\u8868\u957F\u5EA6\u4E0D\u540C" },
{ "compiler.misc.bad.class.file.header", "\u9519\u8BEF\u7684\u7C7B\u6587\u4EF6: {0}\n{1}\n\u8BF7\u5220\u9664\u8BE5\u6587\u4EF6\u6216\u786E\u4FDD\u8BE5\u6587\u4EF6\u4F4D\u4E8E\u6B63\u786E\u7684\u7C7B\u8DEF\u5F84\u5B50\u76EE\u5F55\u4E2D\u3002" },
{ "compiler.misc.bad.class.signature", "\u9519\u8BEF\u7684\u7C7B\u7B7E\u540D: {0}" },
{ "compiler.misc.bad.const.pool.entry", "{0} \u4E2D\u9519\u8BEF\u7684\u5E38\u91CF\u6C60\u6761\u76EE\n\u9884\u671F\u4E3A\u7D22\u5F15 {2} \u5904\u7684 {1}" },
{ "compiler.misc.bad.const.pool.tag", "\u9519\u8BEF\u7684\u5E38\u91CF\u6C60\u6807\u8BB0: {0}" },
{ "compiler.misc.bad.const.pool.tag.at", "\u9519\u8BEF\u7684\u5E38\u91CF\u6C60\u6807\u8BB0: {0}, \u4F4D\u4E8E{1}" },
{ "compiler.misc.bad.enclosing.class", "{0}\u7684\u5C01\u95ED\u7C7B\u9519\u8BEF: {1}" },
{ "compiler.misc.bad.enclosing.method", "\u7C7B {0} \u7684\u5C01\u95ED\u65B9\u6CD5\u5C5E\u6027\u9519\u8BEF" },
{ "compiler.misc.bad.intersection.target.for.functional.expr", "lambda \u6216\u65B9\u6CD5\u5F15\u7528\u7684\u4EA4\u53C9\u7C7B\u578B\u76EE\u6807\u9519\u8BEF\n{0}" },
{ "compiler.misc.bad.runtime.invisible.param.annotations", "\u9519\u8BEF\u7684 RuntimeInvisibleParameterAnnotations \u5C5E\u6027: {0}" },
{ "compiler.misc.bad.signature", "\u9519\u8BEF\u7684\u7B7E\u540D: {0}" },
{ "compiler.misc.bad.source.file.header", "\u9519\u8BEF\u7684\u6E90\u6587\u4EF6: {0}\n{1}\n\u8BF7\u5220\u9664\u8BE5\u6587\u4EF6\u6216\u786E\u4FDD\u8BE5\u6587\u4EF6\u4F4D\u4E8E\u6B63\u786E\u7684\u6E90\u8DEF\u5F84\u5B50\u76EE\u5F55\u4E2D\u3002" },
{ "compiler.misc.bad.type.annotation.value", "\u9519\u8BEF\u7684\u7C7B\u578B\u6CE8\u91CA\u76EE\u6807\u7C7B\u578B\u503C: {0}" },
{ "compiler.misc.base.membership", "\u60A8\u7684\u6240\u6709\u57FA\u7C7B\u90FD\u5C5E\u4E8E\u6211\u4EEC" },
{ "compiler.misc.cant.access.inner.cls.constr", "\u65E0\u6CD5\u8BBF\u95EE\u6784\u9020\u5668 {0}({1})\n\u4F5C\u7528\u57DF\u4E2D\u6CA1\u6709\u7C7B\u578B\u4E3A{2}\u7684\u5C01\u95ED\u5B9E\u4F8B" },
{ "compiler.misc.cant.apply.diamond.1", "\u65E0\u6CD5\u63A8\u65AD{0}\u7684\u7C7B\u578B\u53C2\u6570\n\u539F\u56E0: {1}" },
{ "compiler.misc.cant.apply.symbol", "\u65E0\u6CD5\u5C06 {4} {5}\u4E2D\u7684 {0} {1}\u5E94\u7528\u5230\u7ED9\u5B9A\u7C7B\u578B\n\u9700\u8981: {2}\n\u627E\u5230: {3}\n\u539F\u56E0: {6}" },
{ "compiler.misc.cant.apply.symbols", "\u5BF9\u4E8E{1}({2}), \u627E\u4E0D\u5230\u5408\u9002\u7684{0}" },
{ "compiler.misc.cant.implement", "{1}\u4E2D\u7684{0}\u65E0\u6CD5\u5B9E\u73B0{3}\u4E2D\u7684{2}" },
{ "compiler.misc.cant.override", "{1}\u4E2D\u7684{0}\u65E0\u6CD5\u8986\u76D6{3}\u4E2D\u7684{2}" },
{ "compiler.misc.cant.resolve.location.args", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} {1}({3})\n\u4F4D\u7F6E: {4}" },
{ "compiler.misc.cant.resolve.location.args.params", "\u627E\u4E0D\u5230\u7B26\u53F7\n\u7B26\u53F7: {0} <{2}>{1}({3})\n\u4F4D\u7F6E: {4}" },
{ "compiler.misc.captured.type", "CAP#{0}" },
{ "compiler.misc.ccf.found.later.version", "\u7C7B\u6587\u4EF6\u7684\u7248\u672C\u9AD8\u4E8E\u9884\u671F: {0}" },
{ "compiler.misc.ccf.unrecognized.attribute", "\u65E0\u6CD5\u8BC6\u522B\u7684\u5C5E\u6027: {0}" },
{ "compiler.misc.clashes.with", "{1}\u4E2D\u7684{0}\u4E0E{3}\u4E2D\u7684{2}\u51B2\u7A81" },
{ "compiler.misc.class.file.not.found", "\u627E\u4E0D\u5230{0}\u7684\u7C7B\u6587\u4EF6" },
{ "compiler.misc.class.file.wrong.class", "\u7C7B\u6587\u4EF6\u5305\u542B\u9519\u8BEF\u7684\u7C7B: {0}" },
{ "compiler.misc.conditional.target.cant.be.void", "\u6761\u4EF6\u8868\u8FBE\u5F0F\u7684\u76EE\u6807\u7C7B\u578B\u4E0D\u80FD\u4E3A\u7A7A" },
{ "compiler.misc.count.error", "{0} \u4E2A\u9519\u8BEF" },
{ "compiler.misc.count.error.plural", "{0} \u4E2A\u9519\u8BEF" },
{ "compiler.misc.count.warn", "{0} \u4E2A\u8B66\u544A" },
{ "compiler.misc.count.warn.plural", "{0} \u4E2A\u8B66\u544A" },
{ "compiler.misc.descriptor", "\u63CF\u8FF0\u7B26: {2} {0}({1})" },
{ "compiler.misc.descriptor.throws", "\u63CF\u8FF0\u7B26: {2} {0}({1}) \u629B\u51FA{3}" },
{ "compiler.misc.diamond", "{0}<>" },
{ "compiler.misc.diamond.and.anon.class", "\u65E0\u6CD5\u5C06 ''<>'' \u4E0E\u533F\u540D\u5185\u90E8\u7C7B\u4E00\u8D77\u4F7F\u7528" },
{ "compiler.misc.diamond.and.explicit.params", "\u4E0D\u80FD\u5C06 ''<>'' \u4E0E\u6784\u9020\u5668\u7684\u663E\u5F0F\u7C7B\u578B\u53C2\u6570\u4E00\u8D77\u4F7F\u7528" },
{ "compiler.misc.diamond.non.generic", "\u65E0\u6CD5\u5C06 ''<>'' \u4E0E\u975E\u6CDB\u578B\u7C7B{0}\u4E00\u8D77\u4F7F\u7528" },
{ "compiler.misc.explicit.param.do.not.conform.to.bounds", "\u663E\u5F0F\u7C7B\u578B\u53C2\u6570{0}\u4E0D\u7B26\u5408\u58F0\u660E\u7684\u8303\u56F4{1}" },
{ "compiler.misc.fatal.err.cant.close", "\u81F4\u547D\u9519\u8BEF: \u65E0\u6CD5\u5173\u95ED\u7F16\u8BD1\u5668\u8D44\u6E90" },
{ "compiler.misc.fatal.err.cant.locate.ctor", "\u81F4\u547D\u9519\u8BEF: \u627E\u4E0D\u5230{0}\u7684\u6784\u9020\u5668" },
{ "compiler.misc.fatal.err.cant.locate.field", "\u81F4\u547D\u9519\u8BEF: \u627E\u4E0D\u5230\u5B57\u6BB5{0}" },
{ "compiler.misc.fatal.err.cant.locate.meth", "\u81F4\u547D\u9519\u8BEF: \u627E\u4E0D\u5230\u65B9\u6CD5{0}" },
{ "compiler.misc.fatal.err.no.java.lang", "\u81F4\u547D\u9519\u8BEF: \u5728\u7C7B\u8DEF\u5F84\u6216\u5F15\u5BFC\u7C7B\u8DEF\u5F84\u4E2D\u627E\u4E0D\u5230\u7A0B\u5E8F\u5305 java.lang" },
{ "compiler.misc.file.does.not.contain.package", "\u6587\u4EF6\u4E0D\u5305\u542B\u7A0B\u5E8F\u5305{0}" },
{ "compiler.misc.file.doesnt.contain.class", "\u6587\u4EF6\u4E0D\u5305\u542B\u7C7B{0}" },
{ "compiler.misc.illegal.start.of.class.file", "\u975E\u6CD5\u7684\u7C7B\u6587\u4EF6\u5F00\u59CB" },
{ "compiler.misc.inaccessible.varargs.type", "\u5F62\u5F0F varargs \u5143\u7D20\u7C7B\u578B{0}\u65E0\u6CD5\u4ECE {1} {2} \u8FDB\u884C\u8BBF\u95EE" },
{ "compiler.misc.inapplicable.method", "{0} {1}.{2}\u4E0D\u9002\u7528\n({3})" },
{ "compiler.misc.incompatible.abstracts", "\u5728 {0} {1} \u4E2D\u627E\u5230\u591A\u4E2A\u975E\u8986\u76D6\u62BD\u8C61\u65B9\u6CD5" },
{ "compiler.misc.incompatible.arg.types.in.lambda", "lambda \u8868\u8FBE\u5F0F\u4E2D\u7684\u53C2\u6570\u7C7B\u578B\u4E0D\u517C\u5BB9" },
{ "compiler.misc.incompatible.arg.types.in.mref", "\u65B9\u6CD5\u5F15\u7528\u4E2D\u7684\u53C2\u6570\u7C7B\u578B\u4E0D\u517C\u5BB9" },
{ "compiler.misc.incompatible.descs.in.functional.intf", "\u5728 {0} {1} \u4E2D\u627E\u5230\u4E0D\u517C\u5BB9\u7684\u51FD\u6570\u63CF\u8FF0\u7B26" },
{ "compiler.misc.incompatible.eq.lower.bounds", "\u63A8\u8BBA\u53D8\u91CF{0}\u5177\u6709\u4E0D\u517C\u5BB9\u7684\u9650\u5236\u8303\u56F4\n\u7B49\u5F0F\u7EA6\u675F\u6761\u4EF6: {1}\n\u4E0B\u9650: {2}" },
{ "compiler.misc.incompatible.eq.upper.bounds", "\u63A8\u8BBA\u53D8\u91CF {0} \u5177\u6709\u4E0D\u517C\u5BB9\u7684\u9650\u5236\u8303\u56F4\n\u7B49\u5F0F\u7EA6\u675F\u6761\u4EF6: {1}\n\u4E0A\u9650: {2}" },
{ "compiler.misc.incompatible.ret.type.in.lambda", "lambda \u8868\u8FBE\u5F0F\u4E2D\u7684\u8FD4\u56DE\u7C7B\u578B\u9519\u8BEF\n{0}" },
{ "compiler.misc.incompatible.ret.type.in.mref", "\u65B9\u6CD5\u5F15\u7528\u4E2D\u7684\u8FD4\u56DE\u7C7B\u578B\u9519\u8BEF\n{0}" },
{ "compiler.misc.incompatible.type.in.conditional", "\u6761\u4EF6\u8868\u8FBE\u5F0F\u4E2D\u7684\u7C7B\u578B\u9519\u8BEF\n{0}" },
{ "compiler.misc.incompatible.upper.bounds", "\u63A8\u8BBA\u53D8\u91CF {0} \u5177\u6709\u4E0D\u517C\u5BB9\u7684\u4E0A\u9650 {1}" },
{ "compiler.misc.inconvertible.types", "{0}\u65E0\u6CD5\u8F6C\u6362\u4E3A{1}" },
{ "compiler.misc.infer.arg.length.mismatch", "\u65E0\u6CD5\u63A8\u65AD\u7C7B\u578B\u53D8\u91CF {0}\n(\u5B9E\u9645\u53C2\u6570\u5217\u8868\u548C\u5F62\u5F0F\u53C2\u6570\u5217\u8868\u957F\u5EA6\u4E0D\u540C)" },
{ "compiler.misc.infer.no.conforming.assignment.exists", "\u65E0\u6CD5\u63A8\u65AD\u7C7B\u578B\u53D8\u91CF {0}\n(\u53C2\u6570\u4E0D\u5339\u914D; {1})" },
{ "compiler.misc.infer.no.conforming.instance.exists", "\u4E0D\u5B58\u5728\u7C7B\u578B\u53D8\u91CF{0}\u7684\u5B9E\u4F8B, \u4EE5\u4F7F{1}\u4E0E{2}\u4E00\u81F4" },
{ "compiler.misc.infer.varargs.argument.mismatch", "\u65E0\u6CD5\u63A8\u65AD\u7C7B\u578B\u53D8\u91CF {0}\n(varargs \u4E0D\u5339\u914D; {1})" },
{ "compiler.misc.inferred.do.not.conform.to.eq.bounds", "\u63A8\u65AD\u7C7B\u578B\u4E0D\u7B26\u5408\u7B49\u5F0F\u7EA6\u675F\u6761\u4EF6\n\u63A8\u65AD: {0}\n\u7B49\u5F0F\u7EA6\u675F\u6761\u4EF6: {1}" },
{ "compiler.misc.inferred.do.not.conform.to.lower.bounds", "\u63A8\u65AD\u7C7B\u578B\u4E0D\u7B26\u5408\u4E0B\u9650\n\u63A8\u65AD: {0}\n\u4E0B\u9650: {1}" },
{ "compiler.misc.inferred.do.not.conform.to.upper.bounds", "\u63A8\u65AD\u7C7B\u578B\u4E0D\u7B26\u5408\u4E0A\u9650\n\u63A8\u65AD: {0}\n\u4E0A\u9650: {1}" },
{ "compiler.misc.inner.cls", "\u5185\u90E8\u7C7B" },
{ "compiler.misc.intersection.type", "INT#{0}" },
{ "compiler.misc.invalid.default.interface", "\u5728 {0}.{1} \u7248\u7C7B\u6587\u4EF6\u4E2D\u627E\u5230\u9ED8\u8BA4\u65B9\u6CD5" },
{ "compiler.misc.invalid.generic.lambda.target", "lambda \u8868\u8FBE\u5F0F\u7684\u51FD\u6570\u63CF\u8FF0\u7B26\u65E0\u6548\n{1} {2} \u4E2D\u7684\u65B9\u6CD5 {0} \u4E3A\u6CDB\u578B\u65B9\u6CD5" },
{ "compiler.misc.invalid.mref", "{0}\u5F15\u7528\u65E0\u6548\n{1}" },
{ "compiler.misc.invalid.static.interface", "\u5728 {0}.{1} \u7248\u7C7B\u6587\u4EF6\u4E2D\u627E\u5230\u9759\u6001\u65B9\u6CD5" },
{ "compiler.misc.kindname.annotation", "@interface" },
{ "compiler.misc.kindname.class", "\u7C7B" },
{ "compiler.misc.kindname.constructor", "\u6784\u9020\u5668" },
{ "compiler.misc.kindname.enum", "\u679A\u4E3E" },
{ "compiler.misc.kindname.instance.init", "\u5B9E\u4F8B\u521D\u59CB\u5316\u7A0B\u5E8F" },
{ "compiler.misc.kindname.interface", "\u63A5\u53E3" },
{ "compiler.misc.kindname.method", "\u65B9\u6CD5" },
{ "compiler.misc.kindname.package", "\u7A0B\u5E8F\u5305" },
{ "compiler.misc.kindname.static", "\u9759\u6001" },
{ "compiler.misc.kindname.static.init", "\u9759\u6001\u521D\u59CB\u5316\u7A0B\u5E8F" },
{ "compiler.misc.kindname.type.variable", "\u7C7B\u578B\u53D8\u91CF" },
{ "compiler.misc.kindname.type.variable.bound", "\u7C7B\u578B\u53D8\u91CF\u7684\u9650\u5236\u8303\u56F4" },
{ "compiler.misc.kindname.value", "\u503C" },
{ "compiler.misc.kindname.variable", "\u53D8\u91CF" },
{ "compiler.misc.lambda", "lambda \u8868\u8FBE\u5F0F" },
{ "compiler.misc.location", "{0} {1}" },
{ "compiler.misc.location.1", "\u7C7B\u578B\u4E3A{2}\u7684{0} {1}" },
{ "compiler.misc.missing.ret.val", "\u7F3A\u5C11\u8FD4\u56DE\u503C" },
{ "compiler.misc.mref.infer.and.explicit.params", "\u4E0D\u80FD\u5C06\u539F\u59CB\u6784\u9020\u5668\u5F15\u7528\u4E0E\u6784\u9020\u5668\u7684\u663E\u5F0F\u7C7B\u578B\u53C2\u6570\u4E00\u8D77\u4F7F\u7528" },
{ "compiler.misc.no.abstracts", "\u5728 {0} {1} \u4E2D\u627E\u4E0D\u5230\u62BD\u8C61\u65B9\u6CD5" },
{ "compiler.misc.no.args", "\u6CA1\u6709\u53C2\u6570" },
{ "compiler.misc.no.conforming.assignment.exists", "\u53C2\u6570\u4E0D\u5339\u914D; {0}" },
{ "compiler.misc.no.suitable.functional.intf.inst", "\u65E0\u6CD5\u63A8\u65AD{0}\u7684\u51FD\u6570\u63A5\u53E3\u63CF\u8FF0\u7B26" },
{ "compiler.misc.no.unique.maximal.instance.exists", "\u5BF9\u4E8E\u4E0A\u9650\u4E3A{1}\u7684\u7C7B\u578B\u53D8\u91CF{0}, \u4E0D\u5B58\u5728\u552F\u4E00\u6700\u5927\u5B9E\u4F8B" },
{ "compiler.misc.no.unique.minimal.instance.exists", "\u5BF9\u4E8E\u4E0B\u9650\u4E3A{1}\u7684\u7C7B\u578B\u53D8\u91CF{0}, \u4E0D\u5B58\u5728\u552F\u4E00\u6700\u5C0F\u5B9E\u4F8B" },
{ "compiler.misc.non-static.cant.be.ref", "\u65E0\u6CD5\u4ECE\u9759\u6001\u4E0A\u4E0B\u6587\u4E2D\u5F15\u7528\u975E\u9759\u6001 {0} {1}" },
{ "compiler.misc.not.a.functional.intf", "{0} \u4E0D\u662F\u51FD\u6570\u63A5\u53E3" },
{ "compiler.misc.not.a.functional.intf.1", "{0} \u4E0D\u662F\u51FD\u6570\u63A5\u53E3\n{1}" },
{ "compiler.misc.not.an.intf.component", "\u7EC4\u4EF6\u7C7B\u578B{0}\u4E0D\u662F\u63A5\u53E3" },
{ "compiler.misc.not.applicable.method.found", "\u627E\u5230\u7B2C {0} \u4E2A\u4E0D\u9002\u7528\u7684\u65B9\u6CD5: {1}\n({2})" },
{ "compiler.misc.not.def.access.class.intf.cant.access", "{1}\u4E2D\u7684{0}\u662F\u5728\u4E0D\u53EF\u8BBF\u95EE\u7684\u7C7B\u6216\u63A5\u53E3\u4E2D\u5B9A\u4E49\u7684" },
{ "compiler.misc.not.def.public.cant.access", "{0}\u5728{1}\u4E2D\u4E0D\u662F\u516C\u5171\u7684; \u65E0\u6CD5\u4ECE\u5916\u90E8\u7A0B\u5E8F\u5305\u4E2D\u5BF9\u5176\u8FDB\u884C\u8BBF\u95EE" },
{ "compiler.misc.overridden.default", "\u8986\u76D6\u4E86{1}\u4E2D\u7684\u65B9\u6CD5 {0}" },
{ "compiler.misc.partial.inst.sig", "\u90E8\u5206\u5B9E\u4F8B\u5316\u4E3A: {0}" },
{ "compiler.misc.possible.loss.of.precision", "\u4ECE{0}\u8F6C\u6362\u5230{1}\u53EF\u80FD\u4F1A\u6709\u635F\u5931" },
{ "compiler.misc.prob.found.req", "\u4E0D\u517C\u5BB9\u7684\u7C7B\u578B: {0}" },
{ "compiler.misc.redundant.supertype", "\u5197\u4F59\u63A5\u53E3 {0} \u5DF2\u7531 {1} \u6269\u5C55" },
{ "compiler.misc.ref.ambiguous", "\u5BF9{0}\u7684\u5F15\u7528\u4E0D\u660E\u786E\n{3} \u4E2D\u7684{1} {2} \u548C {6} \u4E2D\u7684{4} {5} \u90FD\u5339\u914D" },
{ "compiler.misc.report.access", "{0} \u5728 {2} \u4E2D\u662F {1} \u8BBF\u95EE\u63A7\u5236" },
{ "compiler.misc.resume.abort", "\u7EE7\u7EED(R), \u653E\u5F03(A)>" },
{ "compiler.misc.source.unavailable", "(\u6E90\u4E0D\u53EF\u7528)" },
{ "compiler.misc.static.bound.mref", "\u9759\u6001\u9650\u5236\u8303\u56F4\u65B9\u6CD5\u5F15\u7528" },
{ "compiler.misc.static.method.in.unbound.lookup", "\u5728\u672A\u7ED1\u5B9A\u67E5\u627E\u4E2D\u627E\u5230\u9759\u6001{0} {1}" },
{ "compiler.misc.static.mref.with.targs", "\u6709\u5173\u9759\u6001\u65B9\u6CD5\u5F15\u7528\u7684\u53C2\u6570\u5316\u9650\u5B9A\u7B26" },
{ "compiler.misc.token.bad-symbol", "<\u9519\u8BEF\u7B26\u53F7>" },
{ "compiler.misc.token.character", "<\u5B57\u7B26>" },
{ "compiler.misc.token.double", "<\u53CC\u7CBE\u5EA6\u578B>" },
{ "compiler.misc.token.end-of-input", "<\u8F93\u5165\u7ED3\u675F>" },
{ "compiler.misc.token.float", "<\u6D6E\u70B9\u578B>" },
{ "compiler.misc.token.identifier", "<\u6807\u8BC6\u7B26>" },
{ "compiler.misc.token.integer", "<\u6574\u578B>" },
{ "compiler.misc.token.long-integer", "<\u957F\u6574\u578B>" },
{ "compiler.misc.token.string", "<\u5B57\u7B26\u4E32>" },
{ "compiler.misc.try.not.applicable.to.type", "try-with-resources \u4E0D\u9002\u7528\u4E8E\u53D8\u91CF\u7C7B\u578B\n({0})" },
{ "compiler.misc.type.captureof", "capture#{0}, \u5171 {1}" },
{ "compiler.misc.type.captureof.1", "capture#{0}" },
{ "compiler.misc.type.none", "<\u65E0>" },
{ "compiler.misc.type.null", "<\u7A7A\u503C>" },
{ "compiler.misc.type.parameter", "\u7C7B\u578B\u53C2\u6570{0}" },
{ "compiler.misc.type.req.array.or.iterable", "\u6570\u7EC4\u6216 java.lang.Iterable" },
{ "compiler.misc.type.req.class", "\u7C7B" },
{ "compiler.misc.type.req.class.array", "\u7C7B\u6216\u6570\u7EC4" },
{ "compiler.misc.type.req.exact", "\u4E0D\u5E26\u9650\u5236\u8303\u56F4\u7684\u7C7B\u6216\u63A5\u53E3" },
{ "compiler.misc.type.req.ref", "\u5F15\u7528" },
{ "compiler.misc.type.var", "{0}#{1}" },
{ "compiler.misc.unable.to.access.file", "\u65E0\u6CD5\u8BBF\u95EE\u6587\u4EF6: {0}" },
{ "compiler.misc.unchecked.assign", "\u672A\u7ECF\u68C0\u67E5\u7684\u8F6C\u6362" },
{ "compiler.misc.unchecked.cast.to.type", "\u672A\u7ECF\u68C0\u67E5\u7684\u8F6C\u6362" },
{ "compiler.misc.unchecked.clash.with", "{1}\u4E2D\u7684{0}\u8986\u76D6\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.unchecked.implement", "{1}\u4E2D\u7684{0}\u5B9E\u73B0\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.unchecked.override", "{1}\u4E2D\u7684{0}\u8986\u76D6\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.undecl.type.var", "\u672A\u58F0\u660E\u7684\u7C7B\u578B\u53D8\u91CF: {0}" },
{ "compiler.misc.unexpected.ret.val", "\u610F\u5916\u7684\u8FD4\u56DE\u503C" },
{ "compiler.misc.unicode.str.not.supported", "\u4E0D\u652F\u6301\u7C7B\u6587\u4EF6\u4E2D\u7684 Unicode \u5B57\u7B26\u4E32" },
{ "compiler.misc.unnamed.package", "\u672A\u547D\u540D\u7A0B\u5E8F\u5305" },
{ "compiler.misc.varargs.argument.mismatch", "varargs \u4E0D\u5339\u914D; {0}" },
{ "compiler.misc.varargs.clash.with", "{1}\u4E2D\u7684{0}\u8986\u76D6\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.varargs.implement", "{1}\u4E2D\u7684{0}\u5B9E\u73B0\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.varargs.override", "{1}\u4E2D\u7684{0}\u8986\u76D6\u4E86{3}\u4E2D\u7684{2}" },
{ "compiler.misc.varargs.trustme.on.non.varargs.meth", "\u65B9\u6CD5 {0} \u4E0D\u662F varargs \u65B9\u6CD5\u3002" },
{ "compiler.misc.varargs.trustme.on.reifiable.varargs", "Varargs \u5143\u7D20\u7C7B\u578B{0}\u53EF\u5177\u4F53\u5316\u3002" },
{ "compiler.misc.varargs.trustme.on.virtual.varargs", "\u5B9E\u4F8B\u65B9\u6CD5 {0} \u4E0D\u662F\u6700\u7EC8\u7684\u3002" },
{ "compiler.misc.verbose.checking.attribution", "[\u6B63\u5728\u68C0\u67E5{0}]" },
{ "compiler.misc.verbose.classpath", "[\u7C7B\u6587\u4EF6\u7684\u641C\u7D22\u8DEF\u5F84: {0}]" },
{ "compiler.misc.verbose.loading", "[\u6B63\u5728\u52A0\u8F7D{0}]" },
{ "compiler.misc.verbose.parsing.done", "[\u89E3\u6790\u5DF2\u5B8C\u6210, \u7528\u65F6 {0} \u6BEB\u79D2]" },
{ "compiler.misc.verbose.parsing.started", "[\u89E3\u6790\u5F00\u59CB\u65F6\u95F4 {0}]" },
{ "compiler.misc.verbose.retro", "[\u6B63\u5728\u66F4\u65B0{0}]" },
{ "compiler.misc.verbose.retro.with", "\t\u6B63\u5728\u4F7F\u7528{1}\u66F4\u65B0{0}" },
{ "compiler.misc.verbose.retro.with.list", "\t\u6B63\u5728\u4F7F\u7528\u7C7B\u578B\u53C2\u6570{1}, \u8D85\u7C7B\u578B{2}\u548C\u63A5\u53E3{3}\u66F4\u65B0{0}" },
{ "compiler.misc.verbose.sourcepath", "[\u6E90\u6587\u4EF6\u7684\u641C\u7D22\u8DEF\u5F84: {0}]" },
{ "compiler.misc.verbose.total", "[\u5171 {0} \u6BEB\u79D2]" },
{ "compiler.misc.verbose.wrote.file", "[\u5DF2\u5199\u5165{0}]" },
{ "compiler.misc.version.not.available", "(\u7248\u672C\u4FE1\u606F\u4E0D\u53EF\u7528)" },
{ "compiler.misc.where.captured", "{0}\u4ECE{3}\u7684\u6355\u83B7\u6269\u5C55{1} \u8D85 {2}" },
{ "compiler.misc.where.captured.1", "{0}\u4ECE{3}\u7684\u6355\u83B7\u6269\u5C55{1}" },
{ "compiler.misc.where.description.captured", "\u5176\u4E2D, {0}\u662F\u65B0\u7C7B\u578B\u53D8\u91CF:" },
{ "compiler.misc.where.description.captured.1", "\u5176\u4E2D, {0}\u662F\u65B0\u7C7B\u578B\u53D8\u91CF:" },
{ "compiler.misc.where.description.intersection", "\u5176\u4E2D, {0}\u662F\u4EA4\u53C9\u7C7B\u578B:" },
{ "compiler.misc.where.description.intersection.1", "\u5176\u4E2D, {0}\u662F\u4EA4\u53C9\u7C7B\u578B:" },
{ "compiler.misc.where.description.typevar", "\u5176\u4E2D, {0}\u662F\u7C7B\u578B\u53D8\u91CF:" },
{ "compiler.misc.where.description.typevar.1", "\u5176\u4E2D, {0}\u662F\u7C7B\u578B\u53D8\u91CF:" },
{ "compiler.misc.where.fresh.typevar", "{0}\u6269\u5C55{1}" },
{ "compiler.misc.where.intersection", "{0}\u6269\u5C55{1}" },
{ "compiler.misc.where.typevar", "{0}\u6269\u5C55\u5DF2\u5728{2} {3}\u4E2D\u58F0\u660E\u7684{1}" },
{ "compiler.misc.where.typevar.1", "{0}\u5DF2\u5728{2} {3}\u4E2D\u58F0\u660E" },
{ "compiler.misc.wrong.version", "\u7C7B\u6587\u4EF6\u5177\u6709\u9519\u8BEF\u7684\u7248\u672C {0}.{1}, \u5E94\u4E3A {2}.{3}" },
{ "compiler.misc.x.print.processor.info", "\u5904\u7406\u7A0B\u5E8F{0}\u4E0E{1}\u5339\u914D\u5E76\u8FD4\u56DE{2}\u3002" },
{ "compiler.misc.x.print.rounds", "\u5FAA\u73AF {0}:\n\t\u8F93\u5165\u6587\u4EF6: {1}\n\t\u6CE8\u91CA: {2}\n\t\u6700\u540E\u4E00\u4E2A\u5FAA\u73AF: {3}" },
{ "compiler.note.compressed.diags", "\u67D0\u4E9B\u6D88\u606F\u5DF2\u7ECF\u8FC7\u7B80\u5316; \u8BF7\u4F7F\u7528 -Xdiags:verbose \u91CD\u65B0\u7F16\u8BD1\u4EE5\u83B7\u5F97\u5B8C\u6574\u8F93\u51FA" },
{ "compiler.note.deferred.method.inst", "\u65B9\u6CD5 {0} \u7684\u5EF6\u8FDF\u5B9E\u4F8B\u5316\n\u5B9E\u4F8B\u5316\u7B7E\u540D: {1}\n\u76EE\u6807\u7C7B\u578B: {2}" },
{ "compiler.note.deprecated.filename", "{0}\u4F7F\u7528\u6216\u8986\u76D6\u4E86\u5DF2\u8FC7\u65F6\u7684 API\u3002" },
{ "compiler.note.deprecated.filename.additional", "{0}\u8FD8\u4F7F\u7528\u6216\u8986\u76D6\u4E86\u5DF2\u8FC7\u65F6\u7684 API\u3002" },
{ "compiler.note.deprecated.plural", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u4F7F\u7528\u6216\u8986\u76D6\u4E86\u5DF2\u8FC7\u65F6\u7684 API\u3002" },
{ "compiler.note.deprecated.plural.additional", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u8FD8\u4F7F\u7528\u6216\u8986\u76D6\u4E86\u5DF2\u8FC7\u65F6\u7684 API\u3002" },
{ "compiler.note.deprecated.recompile", "\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u4F7F\u7528 -Xlint:deprecation \u91CD\u65B0\u7F16\u8BD1\u3002" },
{ "compiler.note.lambda.stat", "\u8F6C\u6362 lambda \u8868\u8FBE\u5F0F\n\u66FF\u4EE3 metafactory = {0}\n\u5408\u6210\u65B9\u6CD5 = {1}" },
{ "compiler.note.mref.stat", "\u8F6C\u6362\u65B9\u6CD5\u5F15\u7528\n\u66FF\u4EE3 metafactory = {0}\n" },
{ "compiler.note.mref.stat.1", "\u8F6C\u6362\u65B9\u6CD5\u5F15\u7528\n\u66FF\u4EE3 metafactory = {0}\nbridge \u65B9\u6CD5 = {1}" },
{ "compiler.note.note", "\u6CE8: " },
{ "compiler.note.potential.lambda.found", "\u53EF\u5C06\u6B64\u533F\u540D\u5185\u90E8\u7C7B\u521B\u5EFA\u8F6C\u6362\u4E3A lambda \u8868\u8FBE\u5F0F\u3002" },
{ "compiler.note.proc.messager", "{0}" },
{ "compiler.note.sunapi.filename", "{0}\u4F7F\u7528\u4E86\u53EF\u80FD\u4F1A\u5728\u672A\u6765\u53D1\u884C\u7248\u4E2D\u5220\u9664\u7684\u5185\u90E8\u4E13\u7528 API\u3002" },
{ "compiler.note.sunapi.filename.additional", "{0}\u4F7F\u7528\u4E86\u53EF\u80FD\u4F1A\u5728\u672A\u6765\u53D1\u884C\u7248\u4E2D\u5220\u9664\u7684\u5176\u4ED6\u5185\u90E8\u4E13\u7528 API\u3002" },
{ "compiler.note.sunapi.plural", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u4F7F\u7528\u4E86\u53EF\u80FD\u4F1A\u5728\u672A\u6765\u53D1\u884C\u7248\u4E2D\u5220\u9664\u7684\u5185\u90E8\u4E13\u7528 API\u3002" },
{ "compiler.note.sunapi.plural.additional", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u4F7F\u7528\u4E86\u53EF\u80FD\u4F1A\u5728\u672A\u6765\u53D1\u884C\u7248\u4E2D\u5220\u9664\u7684\u5176\u4ED6\u5185\u90E8\u4E13\u7528 API\u3002" },
{ "compiler.note.sunapi.recompile", "\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u4F7F\u7528 -Xlint:sunapi \u91CD\u65B0\u7F16\u8BD1\u3002" },
{ "compiler.note.unchecked.filename", "{0}\u4F7F\u7528\u4E86\u672A\u7ECF\u68C0\u67E5\u6216\u4E0D\u5B89\u5168\u7684\u64CD\u4F5C\u3002" },
{ "compiler.note.unchecked.filename.additional", "{0}\u8FD8\u6709\u672A\u7ECF\u68C0\u67E5\u6216\u4E0D\u5B89\u5168\u7684\u64CD\u4F5C\u3002" },
{ "compiler.note.unchecked.plural", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u4F7F\u7528\u4E86\u672A\u7ECF\u68C0\u67E5\u6216\u4E0D\u5B89\u5168\u7684\u64CD\u4F5C\u3002" },
{ "compiler.note.unchecked.plural.additional", "\u67D0\u4E9B\u8F93\u5165\u6587\u4EF6\u8FD8\u4F7F\u7528\u4E86\u672A\u7ECF\u68C0\u67E5\u6216\u4E0D\u5B89\u5168\u7684\u64CD\u4F5C\u3002" },
{ "compiler.note.unchecked.recompile", "\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u4F7F\u7528 -Xlint:unchecked \u91CD\u65B0\u7F16\u8BD1\u3002" },
{ "compiler.note.verbose.resolve.multi", "\u5C06\u7C7B\u578B {1} \u7684\u65B9\u6CD5 {0} \u89E3\u6790\u4E3A\u5019\u9009\u9879 {2}\n\u9636\u6BB5: {3}\n\u5177\u6709\u5B9E\u9645\u503C: {4}\n\u5177\u6709\u7C7B\u578B\u53C2\u6570: {5}\n\u5019\u9009\u9879:" },
{ "compiler.note.verbose.resolve.multi.1", "\u7C7B\u578B {1} \u7684\u65B9\u6CD5 {0} \u89E3\u6790\u9519\u8BEF\n\u9636\u6BB5: {3}\n\u5177\u6709\u5B9E\u9645\u503C: {4}\n\u5177\u6709\u7C7B\u578B\u53C2\u6570: {5}\n\u5019\u9009\u9879:" },
{ "compiler.warn.access.to.sensitive.member.from.serializable.element", "\u53EF\u4E32\u884C\u5316\u5143\u7D20\u5BF9\u654F\u611F\u6210\u5458 {0} \u7684\u8BBF\u95EE\u53EF\u4EE5\u7531\u4E0D\u53D7\u4FE1\u4EFB\u7684\u4EE3\u7801\u516C\u5F00\u6267\u884C" },
{ "compiler.warn.annotation.method.not.found", "\u65E0\u6CD5\u627E\u5230\u7C7B\u578B ''{0}'' \u7684\u6CE8\u91CA\u65B9\u6CD5 ''{1}()''" },
{ "compiler.warn.annotation.method.not.found.reason", "\u65E0\u6CD5\u627E\u5230\u7C7B\u578B ''{0}'' \u7684\u6CE8\u91CA\u65B9\u6CD5 ''{1}()'': {2}" },
{ "compiler.warn.assert.as.identifier", "\u4ECE\u53D1\u884C\u7248 1.4 \u5F00\u59CB, ''assert'' \u662F\u4E00\u4E2A\u5173\u952E\u5B57, \u4F46\u4E0D\u80FD\u7528\u4F5C\u6807\u8BC6\u7B26\n(\u8BF7\u4F7F\u7528 -source 1.4 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u5C06 ''assert'' \u7528\u4F5C\u5173\u952E\u5B57)" },
{ "compiler.warn.auxiliary.class.accessed.from.outside.of.its.source.file", "{1} \u4E2D\u7684\u8F85\u52A9\u7C7B{0}\u4E0D\u5E94\u4ECE\u5176\u81EA\u8EAB\u7684\u6E90\u6587\u4EF6\u4EE5\u5916\u8BBF\u95EE" },
{ "compiler.warn.big.major.version", "{0}: \u4E3B\u7248\u672C {1} \u6BD4 {2} \u65B0, \u6B64\u7F16\u8BD1\u5668\u652F\u6301\u6700\u65B0\u7684\u4E3B\u7248\u672C\u3002\n\u5EFA\u8BAE\u5347\u7EA7\u6B64\u7F16\u8BD1\u5668\u3002" },
{ "compiler.warn.constant.SVUID", "serialVersionUID \u5728\u7C7B{0}\u4E2D\u5FC5\u987B\u662F\u5E38\u91CF" },
{ "compiler.warn.diamond.redundant.args", "\u65B0\u8868\u8FBE\u5F0F\u4E2D\u5B58\u5728\u5197\u4F59\u7C7B\u578B\u53C2\u6570 (\u6539\u7528 diamond \u8FD0\u7B97\u7B26)\u3002" },
{ "compiler.warn.diamond.redundant.args.1", "\u65B0\u8868\u8FBE\u5F0F\u4E2D\u5B58\u5728\u5197\u4F59\u7C7B\u578B\u53C2\u6570 (\u6539\u7528 diamond \u8FD0\u7B97\u7B26)\u3002\n\u663E\u5F0F: {0}\n\u63A8\u65AD: {1}" },
{ "compiler.warn.dir.path.element.not.found", "\u9519\u8BEF\u7684\u8DEF\u5F84\u5143\u7D20 \"{0}\": \u6CA1\u6709\u8FD9\u79CD\u76EE\u5F55" },
{ "compiler.warn.div.zero", "\u9664\u6570\u4E3A\u96F6" },
{ "compiler.warn.empty.if", "if \u4E4B\u540E\u6CA1\u6709\u8BED\u53E5" },
{ "compiler.warn.enum.as.identifier", "\u4ECE\u53D1\u884C\u7248 5 \u5F00\u59CB, ''enum'' \u4E3A\u5173\u952E\u5B57, \u800C\u4E0D\u7528\u4F5C\u6807\u8BC6\u7B26\n(\u8BF7\u4F7F\u7528 -source 5 \u6216\u66F4\u9AD8\u7248\u672C\u4EE5\u5C06 ''enum'' \u7528\u4F5C\u5173\u952E\u5B57)" },
{ "compiler.warn.finally.cannot.complete", "finally \u5B50\u53E5\u65E0\u6CD5\u6B63\u5E38\u5B8C\u6210" },
{ "compiler.warn.forward.ref", "\u5148\u5F15\u7528\u53D8\u91CF ''{0}'', \u7136\u540E\u518D\u5BF9\u5176\u521D\u59CB\u5316" },
{ "compiler.warn.future.attr", "{1}.{2} \u7248\u7C7B\u6587\u4EF6\u4E2D\u5F15\u5165\u7684 {0} \u5C5E\u6027\u5728 {3}.{4} \u7248\u7C7B\u6587\u4EF6\u4E2D\u88AB\u5FFD\u7565" },
{ "compiler.warn.has.been.deprecated", "{1}\u4E2D\u7684{0}\u5DF2\u8FC7\u65F6" },
{ "compiler.warn.illegal.char.for.encoding", "\u7F16\u7801{0}\u7684\u4E0D\u53EF\u6620\u5C04\u5B57\u7B26" },
{ "compiler.warn.improper.SVUID", "\u5FC5\u987B\u5728\u7C7B{0}\u4E2D\u5C06 serialVersionUID \u58F0\u660E\u4E3A static final" },
{ "compiler.warn.inexact.non-varargs.call", "\u6700\u540E\u4E00\u4E2A\u53C2\u6570\u4F7F\u7528\u4E86\u4E0D\u51C6\u786E\u7684\u53D8\u91CF\u7C7B\u578B\u7684 varargs \u65B9\u6CD5\u7684\u975E varargs \u8C03\u7528; \n\u5BF9\u4E8E varargs \u8C03\u7528, \u5E94\u4F7F\u7528 {0}\n\u5BF9\u4E8E\u975E varargs \u8C03\u7528, \u5E94\u4F7F\u7528 {1}, \u8FD9\u6837\u4E5F\u53EF\u4EE5\u6291\u5236\u6B64\u8B66\u544A" },
{ "compiler.warn.invalid.archive.file", "\u4EE5\u4E0B\u8DEF\u5F84\u4E2D\u5B58\u5728\u610F\u5916\u7684\u6587\u4EF6: {0}" },
{ "compiler.warn.lintOption", "[{0}] " },
{ "compiler.warn.long.SVUID", "serialVersionUID \u5728\u7C7B{0}\u4E2D\u5FC5\u987B\u662F long \u7C7B\u578B" },
{ "compiler.warn.missing.SVUID", "\u53EF\u5E8F\u5217\u5316\u7C7B{0}\u6CA1\u6709 serialVersionUID \u7684\u5B9A\u4E49" },
{ "compiler.warn.missing.deprecated.annotation", "\u672A\u4F7F\u7528 @Deprecated \u5BF9\u5DF2\u8FC7\u65F6\u7684\u9879\u76EE\u8FDB\u884C\u6CE8\u91CA" },
{ "compiler.warn.option.obsolete.source", "\u6E90\u503C{0}\u5DF2\u8FC7\u65F6, \u5C06\u5728\u672A\u6765\u6240\u6709\u53D1\u884C\u7248\u4E2D\u5220\u9664" },
{ "compiler.warn.option.obsolete.suppression", "\u8981\u9690\u85CF\u6709\u5173\u5DF2\u8FC7\u65F6\u9009\u9879\u7684\u8B66\u544A, \u8BF7\u4F7F\u7528 -Xlint:-options\u3002" },
{ "compiler.warn.option.obsolete.target", "\u76EE\u6807\u503C{0}\u5DF2\u8FC7\u65F6, \u5C06\u5728\u672A\u6765\u6240\u6709\u53D1\u884C\u7248\u4E2D\u5220\u9664" },
{ "compiler.warn.override.bridge", "{0}; \u88AB\u8986\u76D6\u7684\u65B9\u6CD5\u4E3A bridge \u65B9\u6CD5" },
{ "compiler.warn.override.equals.but.not.hashcode", "\u7C7B{0}\u8986\u76D6\u4E86 equals, \u4F46\u8BE5\u7C7B\u6216\u4EFB\u4F55\u8D85\u7C7B\u90FD\u672A\u8986\u76D6 hashCode \u65B9\u6CD5" },
{ "compiler.warn.override.unchecked.ret", "{0}\n\u8FD4\u56DE\u7C7B\u578B\u9700\u8981\u4ECE{1}\u5230{2}\u7684\u672A\u7ECF\u68C0\u67E5\u7684\u8F6C\u6362" },
{ "compiler.warn.override.unchecked.thrown", "{0}\n\u88AB\u8986\u76D6\u7684\u65B9\u6CD5\u672A\u629B\u51FA{1}" },
{ "compiler.warn.override.varargs.extra", "{0}; \u8986\u76D6\u7684\u65B9\u6CD5\u7F3A\u5C11 ''...''" },
{ "compiler.warn.override.varargs.missing", "{0}; \u88AB\u8986\u76D6\u7684\u65B9\u6CD5\u6CA1\u6709 ''...''" },
{ "compiler.warn.path.element.not.found", "\u9519\u8BEF\u7684\u8DEF\u5F84\u5143\u7D20 \"{0}\": \u6CA1\u6709\u8FD9\u79CD\u6587\u4EF6\u6216\u76EE\u5F55" },
{ "compiler.warn.pkg-info.already.seen", "\u5DF2\u627E\u5230\u7A0B\u5E8F\u5305{0}\u7684 package-info.java \u6587\u4EF6" },
{ "compiler.warn.position.overflow", "\u884C {0} \u5904\u7684\u4F4D\u7F6E\u7F16\u7801\u6EA2\u51FA" },
{ "compiler.warn.possible.fall-through.into.case", "\u53EF\u80FD\u65E0\u6CD5\u5B9E\u73B0 case" },
{ "compiler.warn.potentially.ambiguous.overload", "{1} \u4E2D\u7684 {0} \u53EF\u80FD\u4E0E {3} \u4E2D\u7684 {2} \u6DF7\u6DC6" },
{ "compiler.warn.prob.found.req", "{0}\n\u9700\u8981: {2}\n\u627E\u5230: {1}" },
{ "compiler.warn.proc.annotations.without.processors", "\u6CA1\u6709\u5904\u7406\u7A0B\u5E8F\u8981\u4F7F\u7528\u4EE5\u4E0B\u4EFB\u4F55\u6CE8\u91CA: {0}" },
{ "compiler.warn.proc.file.create.last.round", "\u5C06\u4E0D\u5BF9\u5728\u6700\u540E\u4E00\u4E2A\u5FAA\u73AF\u4E2D\u521B\u5EFA\u7684\u7C7B\u578B\u4E3A ''{0}'' \u7684\u6587\u4EF6\u8FDB\u884C\u6CE8\u91CA\u5904\u7406\u3002" },
{ "compiler.warn.proc.file.reopening", "\u5C1D\u8BD5\u591A\u6B21\u4E3A ''{0}'' \u521B\u5EFA\u6587\u4EF6" },
{ "compiler.warn.proc.illegal.file.name", "\u65E0\u6CD5\u521B\u5EFA\u5E26\u6709\u975E\u6CD5\u540D\u79F0 ''{0}'' \u7684\u6587\u4EF6\u3002" },
{ "compiler.warn.proc.malformed.supported.string", "\u5904\u7406\u7A0B\u5E8F ''{1}'' \u4E3A\u652F\u6301\u7684\u6CE8\u91CA\u7C7B\u578B\u8FD4\u56DE\u683C\u5F0F\u9519\u8BEF\u7684\u5B57\u7B26\u4E32 ''{0}''" },
{ "compiler.warn.proc.messager", "{0}" },
{ "compiler.warn.proc.package.does.not.exist", "\u7A0B\u5E8F\u5305{0}\u4E0D\u5B58\u5728" },
{ "compiler.warn.proc.proc-only.requested.no.procs", "\u5728\u672A\u8BF7\u6C42\u7F16\u8BD1\u7684\u60C5\u51B5\u4E0B\u8FDB\u884C\u6CE8\u91CA\u5904\u7406, \u4F46\u627E\u4E0D\u5230\u5904\u7406\u7A0B\u5E8F\u3002" },
{ "compiler.warn.proc.processor.incompatible.source.version", "\u6765\u81EA\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F ''{1}'' \u7684\u53D7\u652F\u6301 source \u7248\u672C ''{0}'' \u4F4E\u4E8E -source ''{2}''" },
{ "compiler.warn.proc.suspicious.class.name", "\u6B63\u5728\u4E3A\u540D\u79F0\u4EE5{1}\u7ED3\u5C3E\u7684\u7C7B\u578B\u521B\u5EFA\u6587\u4EF6: ''{0}''" },
{ "compiler.warn.proc.type.already.exists", "\u7C7B\u578B ''{0}'' \u7684\u6587\u4EF6\u5DF2\u7ECF\u5B58\u5728\u4E8E\u6E90\u8DEF\u5F84\u6216\u7C7B\u8DEF\u5F84\u4E2D" },
{ "compiler.warn.proc.type.recreate", "\u5C1D\u8BD5\u591A\u6B21\u521B\u5EFA\u7C7B\u578B ''{0}'' \u7684\u6587\u4EF6" },
{ "compiler.warn.proc.unclosed.type.files", "\u7C7B\u578B ''{0}'' \u7684\u6587\u4EF6\u672A\u5173\u95ED; \u5C06\u4E0D\u9488\u5BF9\u8FD9\u4E9B\u7C7B\u578B\u8FDB\u884C\u6CE8\u91CA\u5904\u7406" },
{ "compiler.warn.proc.unmatched.processor.options", "\u4EE5\u4E0B\u9009\u9879\u672A\u88AB\u4EFB\u4F55\u5904\u7406\u7A0B\u5E8F\u8BC6\u522B: ''{0}''" },
{ "compiler.warn.proc.use.implicit", "\u6CE8\u91CA\u5904\u7406\u4E0D\u9002\u7528\u4E8E\u9690\u5F0F\u7F16\u8BD1\u7684\u6587\u4EF6\u3002\n\u4F7F\u7528 -implicit \u6307\u5B9A\u7528\u4E8E\u9690\u5F0F\u7F16\u8BD1\u7684\u7B56\u7565\u3002" },
{ "compiler.warn.proc.use.proc.or.implicit", "\u6CE8\u91CA\u5904\u7406\u4E0D\u9002\u7528\u4E8E\u9690\u5F0F\u7F16\u8BD1\u7684\u6587\u4EF6\u3002\n\u4F7F\u7528 -proc:none \u7981\u7528\u6CE8\u91CA\u5904\u7406\u6216\u4F7F\u7528 -implicit \u6307\u5B9A\u7528\u4E8E\u9690\u5F0F\u7F16\u8BD1\u7684\u7B56\u7565\u3002" },
{ "compiler.warn.raw.class.use", "\u627E\u5230\u539F\u59CB\u7C7B\u578B: {0}\n\u7F3A\u5C11\u6CDB\u578B\u7C7B{1}\u7684\u7C7B\u578B\u53C2\u6570" },
{ "compiler.warn.redundant.cast", "\u51FA\u73B0\u5197\u4F59\u7684\u5230{0}\u7684\u8F6C\u6362" },
{ "compiler.warn.self.ref", "\u53D8\u91CF ''{0}'' \u7684\u521D\u59CB\u5316\u7A0B\u5E8F\u4E2D\u5B58\u5728\u81EA\u5F15\u7528" },
{ "compiler.warn.source.no.bootclasspath", "\u672A\u4E0E -source {0} \u4E00\u8D77\u8BBE\u7F6E\u5F15\u5BFC\u7C7B\u8DEF\u5F84" },
{ "compiler.warn.static.not.qualified.by.type", "static {0}\u5E94\u7531\u7C7B\u578B\u540D\u79F0{1}\u800C\u4E0D\u662F\u8868\u8FBE\u5F0F\u9650\u5B9A" },
{ "compiler.warn.sun.proprietary", "{0}\u662F\u5185\u90E8\u4E13\u7528 API, \u53EF\u80FD\u4F1A\u5728\u672A\u6765\u53D1\u884C\u7248\u4E2D\u5220\u9664" },
{ "compiler.warn.synthetic.name.conflict", "\u7B26\u53F7{0}\u4E0E{1}\u4E2D\u7684 compiler-synthesized \u7B26\u53F7\u51B2\u7A81" },
{ "compiler.warn.try.explicit.close.call", "\u5728\u53EF\u81EA\u52A8\u7ED3\u675F\u7684\u8D44\u6E90\u4E0A\u663E\u5F0F\u8C03\u7528 close()" },
{ "compiler.warn.try.resource.not.referenced", "\u4E0D\u80FD\u5728\u76F8\u5E94\u7684 try \u8BED\u53E5\u7684\u6B63\u6587\u4E2D\u5F15\u7528\u53EF\u81EA\u52A8\u7ED3\u675F\u7684\u8D44\u6E90{0}" },
{ "compiler.warn.try.resource.throws.interrupted.exc", "\u53EF\u81EA\u52A8\u5173\u95ED\u7684\u8D44\u6E90{0}\u5305\u542B\u7684\u6210\u5458\u65B9\u6CD5 close() \u53EF\u80FD\u629B\u51FA InterruptedException" },
{ "compiler.warn.unchecked.assign", "\u672A\u7ECF\u68C0\u67E5\u7684\u5206\u914D: \u5C06{0}\u5206\u914D\u7ED9{1}" },
{ "compiler.warn.unchecked.assign.to.var", "\u5BF9\u4F5C\u4E3A\u539F\u59CB\u7C7B\u578B{1}\u7684\u6210\u5458\u7684\u53D8\u91CF{0}\u7684\u5206\u914D\u672A\u7ECF\u8FC7\u68C0\u67E5" },
{ "compiler.warn.unchecked.call.mbr.of.raw.type", "\u5BF9\u4F5C\u4E3A\u539F\u59CB\u7C7B\u578B{1}\u7684\u6210\u5458\u7684{0}\u7684\u8C03\u7528\u672A\u7ECF\u8FC7\u68C0\u67E5" },
{ "compiler.warn.unchecked.cast.to.type", "\u5411\u7C7B\u578B{0}\u7684\u8F6C\u6362\u672A\u7ECF\u8FC7\u68C0\u67E5" },
{ "compiler.warn.unchecked.generic.array.creation", "\u5BF9\u4E8E\u7C7B\u578B\u4E3A{0}\u7684 varargs \u53C2\u6570, \u6CDB\u578B\u6570\u7EC4\u521B\u5EFA\u672A\u7ECF\u8FC7\u68C0\u67E5" },
{ "compiler.warn.unchecked.meth.invocation.applied", "\u65B9\u6CD5\u8C03\u7528\u672A\u7ECF\u8FC7\u68C0\u67E5: \u5C06{4} {5}\u4E2D\u7684{0} {1}\u5E94\u7528\u5230\u7ED9\u5B9A\u7684\u7C7B\u578B\n\u9700\u8981: {2}\n\u627E\u5230: {3}" },
{ "compiler.warn.unchecked.varargs.non.reifiable.type", "\u53C2\u6570\u5316 vararg \u7C7B\u578B{0}\u7684\u5806\u53EF\u80FD\u5DF2\u53D7\u6C61\u67D3" },
{ "compiler.warn.underscore.as.identifier", "''_'' \u7528\u4F5C\u6807\u8BC6\u7B26\n(Java SE 8 \u4E4B\u540E\u7684\u53D1\u884C\u7248\u4E2D\u53EF\u80FD\u4E0D\u652F\u6301\u4F7F\u7528 ''_'' \u4F5C\u4E3A\u6807\u8BC6\u7B26)" },
{ "compiler.warn.unexpected.archive.file", "\u4EE5\u4E0B\u6863\u6848\u6587\u4EF6\u5B58\u5728\u610F\u5916\u7684\u6269\u5C55\u540D: {0}" },
{ "compiler.warn.unknown.enum.constant", "\u672A\u77E5\u7684\u679A\u4E3E\u5E38\u91CF {1}.{2}" },
{ "compiler.warn.unknown.enum.constant.reason", "\u672A\u77E5\u7684\u679A\u4E3E\u5E38\u91CF {1}.{2}\n\u539F\u56E0: {3}" },
{ "compiler.warn.unreachable.catch", "catch \u5B50\u53E5\u65E0\u6CD5\u8BBF\u95EE\n\u5DF2\u6355\u83B7\u5230\u629B\u51FA\u7684\u7C7B\u578B{0}" },
{ "compiler.warn.unreachable.catch.1", "catch \u5B50\u53E5\u65E0\u6CD5\u8BBF\u95EE\n\u5DF2\u6355\u83B7\u5230\u629B\u51FA\u7684\u7C7B\u578B{0}" },
{ "compiler.warn.varargs.redundant.trustme.anno", "\u5197\u4F59\u7684 {0} \u6CE8\u91CA\u3002{1}" },
{ "compiler.warn.varargs.unsafe.use.varargs.param", "Varargs \u65B9\u6CD5\u53EF\u80FD\u5BFC\u81F4\u6765\u81EA\u4E0D\u53EF\u5177\u4F53\u5316 varargs \u53C2\u6570 {0} \u7684\u5806\u6C61\u67D3" },
{ "compiler.warn.warning", "\u8B66\u544A: " },
};
}
}

108
jdkSrc/jdk8/com/sun/tools/javac/resources/javac.java Normal file
View File

@@ -0,0 +1,108 @@
package com.sun.tools.javac.resources;
public final class javac extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "javac.err.dir.not.found", "directory not found: {0}" },
{ "javac.err.empty.A.argument", "-A requires an argument; use ''-Akey'' or ''-Akey=value''" },
{ "javac.err.error.writing.file", "error writing {0}; {1}" },
{ "javac.err.file.not.directory", "not a directory: {0}" },
{ "javac.err.file.not.file", "not a file: {0}" },
{ "javac.err.file.not.found", "file not found: {0}" },
{ "javac.err.invalid.A.key", "key in annotation processor option ''{0}'' is not a dot-separated sequence of identifiers" },
{ "javac.err.invalid.arg", "invalid argument: {0}" },
{ "javac.err.invalid.flag", "invalid flag: {0}" },
{ "javac.err.invalid.profile", "invalid profile: {0}" },
{ "javac.err.invalid.source", "invalid source release: {0}" },
{ "javac.err.invalid.target", "invalid target release: {0}" },
{ "javac.err.no.source.files", "no source files" },
{ "javac.err.no.source.files.classes", "no source files or class names" },
{ "javac.err.profile.bootclasspath.conflict", "profile and bootclasspath options cannot be used together" },
{ "javac.err.req.arg", "{0} requires an argument" },
{ "javac.fullVersion", "{0} full version \"{1}\"" },
{ "javac.msg.bug", "An exception has occurred in the compiler ({0}). Please file a bug against the Java compiler via the Java bug reporting page (http://bugreport.java.com) after checking the Bug Database (http://bugs.java.com) for duplicates. Include your program and the following diagnostic in your report. Thank you." },
{ "javac.msg.io", "\n\nAn input/output error occurred.\nConsult the following stack trace for details.\n" },
{ "javac.msg.plugin.not.found", "plug-in not found: {0}" },
{ "javac.msg.plugin.uncaught.exception", "\n\nA plugin threw an uncaught exception.\nConsult the following stack trace for details.\n" },
{ "javac.msg.proc.annotation.uncaught.exception", "\n\nAn annotation processor threw an uncaught exception.\nConsult the following stack trace for details.\n" },
{ "javac.msg.resource", "\n\nThe system is out of resources.\nConsult the following stack trace for details.\n" },
{ "javac.msg.usage", "Usage: {0} <options> <source files>\nuse -help for a list of possible options" },
{ "javac.msg.usage.header", "Usage: {0} <options> <source files>\nwhere possible options include:" },
{ "javac.msg.usage.nonstandard.footer", "These options are non-standard and subject to change without notice." },
{ "javac.opt.A", "Options to pass to annotation processors" },
{ "javac.opt.AT", "Read options and filenames from file" },
{ "javac.opt.J", "Pass <flag> directly to the runtime system" },
{ "javac.opt.Werror", "Terminate compilation if warnings occur" },
{ "javac.opt.X", "Print a synopsis of nonstandard options" },
{ "javac.opt.Xbootclasspath.a", "Append to the bootstrap class path" },
{ "javac.opt.Xbootclasspath.p", "Prepend to the bootstrap class path" },
{ "javac.opt.Xdoclint", "Enable recommended checks for problems in javadoc comments" },
{ "javac.opt.Xdoclint.custom", "\n Enable or disable specific checks for problems in javadoc comments,\n where <group> is one of accessibility, html, missing, reference, or syntax,\n and <access> is one of public, protected, package, or private." },
{ "javac.opt.Xdoclint.subopts", "(all|none|[-]<group>)[/<access>]" },
{ "javac.opt.Xlint", "Enable recommended warnings" },
{ "javac.opt.Xlint.suboptlist", "Enable or disable specific warnings" },
{ "javac.opt.Xstdout", "Redirect standard output" },
{ "javac.opt.arg.class", "<class>" },
{ "javac.opt.arg.class.list", "<class1>[,<class2>,<class3>...]" },
{ "javac.opt.arg.directory", "<directory>" },
{ "javac.opt.arg.dirs", "<dirs>" },
{ "javac.opt.arg.encoding", "<encoding>" },
{ "javac.opt.arg.file", "<filename>" },
{ "javac.opt.arg.flag", "<flag>" },
{ "javac.opt.arg.key.equals.value", "key[=value]" },
{ "javac.opt.arg.number", "<number>" },
{ "javac.opt.arg.path", "<path>" },
{ "javac.opt.arg.pathname", "<pathname>" },
{ "javac.opt.arg.plugin", "\"name args\"" },
{ "javac.opt.arg.profile", "<profile>" },
{ "javac.opt.arg.release", "<release>" },
{ "javac.opt.bootclasspath", "Override location of bootstrap class files" },
{ "javac.opt.classpath", "Specify where to find user class files and annotation processors" },
{ "javac.opt.d", "Specify where to place generated class files" },
{ "javac.opt.deprecation", "Output source locations where deprecated APIs are used" },
{ "javac.opt.diags", "Select a diagnostic mode" },
{ "javac.opt.encoding", "Specify character encoding used by source files" },
{ "javac.opt.endorseddirs", "Override location of endorsed standards path" },
{ "javac.opt.extdirs", "Override location of installed extensions" },
{ "javac.opt.g", "Generate all debugging info" },
{ "javac.opt.g.lines.vars.source", "Generate only some debugging info" },
{ "javac.opt.g.none", "Generate no debugging info" },
{ "javac.opt.headerDest", "Specify where to place generated native header files" },
{ "javac.opt.help", "Print a synopsis of standard options" },
{ "javac.opt.implicit", "Specify whether or not to generate class files for implicitly referenced files" },
{ "javac.opt.maxerrs", "Set the maximum number of errors to print" },
{ "javac.opt.maxwarns", "Set the maximum number of warnings to print" },
{ "javac.opt.moreinfo", "Print extended information for type variables" },
{ "javac.opt.nogj", "Don't accept generics in the language" },
{ "javac.opt.nowarn", "Generate no warnings" },
{ "javac.opt.parameters", "Generate metadata for reflection on method parameters" },
{ "javac.opt.pkginfo", "Specify handling of package-info files" },
{ "javac.opt.plugin", "Name and optional arguments for a plug-in to be run" },
{ "javac.opt.prefer", "Specify which file to read when both a source file and class file are found for an implicitly compiled class" },
{ "javac.opt.print", "Print out a textual representation of specified types" },
{ "javac.opt.printProcessorInfo", "Print information about which annotations a processor is asked to process" },
{ "javac.opt.printRounds", "Print information about rounds of annotation processing" },
{ "javac.opt.printflat", "Print abstract syntax tree after inner class conversion" },
{ "javac.opt.printsearch", "Print information where classfiles are searched" },
{ "javac.opt.proc.none.only", "Control whether annotation processing and/or compilation is done." },
{ "javac.opt.processor", "Names of the annotation processors to run; bypasses default discovery process" },
{ "javac.opt.processorpath", "Specify where to find annotation processors" },
{ "javac.opt.profile", "Check that API used is available in the specified profile" },
{ "javac.opt.prompt", "Stop after each error" },
{ "javac.opt.retrofit", "Retrofit existing classfiles with generic types" },
{ "javac.opt.s", "Emit java sources instead of classfiles" },
{ "javac.opt.scramble", "Scramble private identifiers in bytecode" },
{ "javac.opt.scrambleall", "Scramble package visible identifiers in bytecode" },
{ "javac.opt.source", "Provide source compatibility with specified release" },
{ "javac.opt.sourceDest", "Specify where to place generated source files" },
{ "javac.opt.sourcepath", "Specify where to find input source files" },
{ "javac.opt.target", "Generate class files for specific VM version" },
{ "javac.opt.verbose", "Output messages about what the compiler is doing" },
{ "javac.opt.version", "Version information" },
{ "javac.version", "{0} {1}" },
{ "javac.warn.profile.target.conflict", "profile {0} is not valid for target release {1}" },
{ "javac.warn.source.target.conflict", "source release {0} requires target release {1}" },
{ "javac.warn.target.default.source.conflict", "target release {0} conflicts with default source release {1}" },
};
}
}

108
jdkSrc/jdk8/com/sun/tools/javac/resources/javac_ja.java Normal file
View File

@@ -0,0 +1,108 @@
package com.sun.tools.javac.resources;
public final class javac_ja extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "javac.err.dir.not.found", "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u304C\u3042\u308A\u307E\u305B\u3093: {0}" },
{ "javac.err.empty.A.argument", "-A\u306B\u306F\u5F15\u6570\u304C\u5FC5\u8981\u3067\u3059\u3002''-Akey''\u307E\u305F\u306F''-Akey=value''\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044" },
{ "javac.err.error.writing.file", "{0}\u306E\u66F8\u8FBC\u307F\u30A8\u30E9\u30FC\u3067\u3059\u3002{1}" },
{ "javac.err.file.not.directory", "\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u3067\u306F\u3042\u308A\u307E\u305B\u3093: {0}" },
{ "javac.err.file.not.file", "\u30D5\u30A1\u30A4\u30EB\u3067\u306F\u3042\u308A\u307E\u305B\u3093: {0}" },
{ "javac.err.file.not.found", "\u30D5\u30A1\u30A4\u30EB\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: {0}" },
{ "javac.err.invalid.A.key", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u30FB\u30AA\u30D7\u30B7\u30E7\u30F3''{0}''\u306E\u30AD\u30FC\u306B\u6307\u5B9A\u3055\u308C\u3066\u3044\u308B\u4E00\u9023\u306E\u8B58\u5225\u5B50\u304C\u3001\u30C9\u30C3\u30C8\u3067\u533A\u5207\u3089\u308C\u3066\u3044\u307E\u305B\u3093" },
{ "javac.err.invalid.arg", "{0}\u306F\u7121\u52B9\u306A\u5F15\u6570\u3067\u3059" },
{ "javac.err.invalid.flag", "{0}\u306F\u7121\u52B9\u306A\u30D5\u30E9\u30B0\u3067\u3059" },
{ "javac.err.invalid.profile", "\u7121\u52B9\u306A\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB: {0}" },
{ "javac.err.invalid.source", "{0}\u306F\u7121\u52B9\u306A\u30BD\u30FC\u30B9\u30FB\u30EA\u30EA\u30FC\u30B9\u3067\u3059" },
{ "javac.err.invalid.target", "{0}\u306F\u7121\u52B9\u306A\u30BF\u30FC\u30B2\u30C3\u30C8\u30FB\u30EA\u30EA\u30FC\u30B9\u3067\u3059" },
{ "javac.err.no.source.files", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "javac.err.no.source.files.classes", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u307E\u305F\u306F\u30AF\u30E9\u30B9\u540D\u304C\u3042\u308A\u307E\u305B\u3093" },
{ "javac.err.profile.bootclasspath.conflict", "profile\u3068bootclasspath\u30AA\u30D7\u30B7\u30E7\u30F3\u306F\u540C\u6642\u306B\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" },
{ "javac.err.req.arg", "{0}\u306B\u306F\u5F15\u6570\u304C\u5FC5\u8981\u3067\u3059" },
{ "javac.fullVersion", "{0}\u30D5\u30EB\u30FB\u30D0\u30FC\u30B8\u30E7\u30F3\"{1}\"" },
{ "javac.msg.bug", "\u30B3\u30F3\u30D1\u30A4\u30E9\u3067\u4F8B\u5916\u304C\u767A\u751F\u3057\u307E\u3057\u305F({0})\u3002Bug Database (http://bugs.java.com)\u3067\u91CD\u8907\u304C\u306A\u3044\u304B\u3092\u3054\u78BA\u8A8D\u306E\u3046\u3048\u3001Java bug\u30EC\u30DD\u30FC\u30C8\u30FB\u30DA\u30FC\u30B8(http://bugreport.java.com)\u3067Java\u30B3\u30F3\u30D1\u30A4\u30E9\u306B\u5BFE\u3059\u308Bbug\u306E\u767B\u9332\u3092\u304A\u9858\u3044\u3044\u305F\u3057\u307E\u3059\u3002\u30EC\u30DD\u30FC\u30C8\u306B\u306F\u3001\u305D\u306E\u30D7\u30ED\u30B0\u30E9\u30E0\u3068\u4E0B\u8A18\u306E\u8A3A\u65AD\u5185\u5BB9\u3092\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u3054\u5354\u529B\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002" },
{ "javac.msg.io", "\n\n\u5165\u51FA\u529B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F\u3002\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n" },
{ "javac.msg.plugin.not.found", "\u30D7\u30E9\u30B0\u30A4\u30F3\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: {0}" },
{ "javac.msg.plugin.uncaught.exception", "\n\n\u30D7\u30E9\u30B0\u30A4\u30F3\u3067\u6355\u6349\u3055\u308C\u306A\u3044\u4F8B\u5916\u304C\u30B9\u30ED\u30FC\u3055\u308C\u307E\u3057\u305F\u3002\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n" },
{ "javac.msg.proc.annotation.uncaught.exception", "\n\n\u6CE8\u91C8\u51E6\u7406\u3067\u6355\u6349\u3055\u308C\u306A\u3044\u4F8B\u5916\u304C\u30B9\u30ED\u30FC\u3055\u308C\u307E\u3057\u305F\u3002\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n" },
{ "javac.msg.resource", "\n\n\u30B7\u30B9\u30C6\u30E0\u30FB\u30EA\u30BD\u30FC\u30B9\u304C\u4E0D\u8DB3\u3057\u3066\u3044\u307E\u3059\u3002\n\u8A73\u7D30\u306F\u6B21\u306E\u30B9\u30BF\u30C3\u30AF\u30FB\u30C8\u30EC\u30FC\u30B9\u3067\u8ABF\u67FB\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n" },
{ "javac.msg.usage", "\u4F7F\u7528\u65B9\u6CD5: {0} <options> <source files>\n\u4F7F\u7528\u53EF\u80FD\u306A\u30AA\u30D7\u30B7\u30E7\u30F3\u306E\u30EA\u30B9\u30C8\u306B\u3064\u3044\u3066\u306F\u3001-help\u3092\u4F7F\u7528\u3057\u307E\u3059" },
{ "javac.msg.usage.header", "\u4F7F\u7528\u65B9\u6CD5: {0} <options> <source files>\n\u4F7F\u7528\u53EF\u80FD\u306A\u30AA\u30D7\u30B7\u30E7\u30F3\u306B\u306F\u6B21\u306E\u3082\u306E\u304C\u3042\u308A\u307E\u3059\u3002" },
{ "javac.msg.usage.nonstandard.footer", "\u3053\u308C\u3089\u306F\u975E\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u3067\u3042\u308A\u4E88\u544A\u306A\u3057\u306B\u5909\u66F4\u3055\u308C\u308B\u3053\u3068\u304C\u3042\u308A\u307E\u3059\u3002" },
{ "javac.opt.A", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u306B\u6E21\u3055\u308C\u308B\u30AA\u30D7\u30B7\u30E7\u30F3" },
{ "javac.opt.AT", "\u30D5\u30A1\u30A4\u30EB\u304B\u3089\u306E\u8AAD\u53D6\u308A\u30AA\u30D7\u30B7\u30E7\u30F3\u304A\u3088\u3073\u30D5\u30A1\u30A4\u30EB\u540D" },
{ "javac.opt.J", "<flag>\u3092\u5B9F\u884C\u30B7\u30B9\u30C6\u30E0\u306B\u76F4\u63A5\u6E21\u3059" },
{ "javac.opt.Werror", "\u8B66\u544A\u304C\u767A\u751F\u3057\u305F\u5834\u5408\u306B\u30B3\u30F3\u30D1\u30A4\u30EB\u3092\u7D42\u4E86\u3059\u308B" },
{ "javac.opt.X", "\u975E\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u306E\u6982\u8981\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.Xbootclasspath.a", "\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306B\u8FFD\u52A0\u3059\u308B" },
{ "javac.opt.Xbootclasspath.p", "\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306E\u5148\u982D\u306B\u4ED8\u52A0\u3059\u308B" },
{ "javac.opt.Xdoclint", "javadoc\u30B3\u30E1\u30F3\u30C8\u306E\u554F\u984C\u306B\u95A2\u3059\u308B\u63A8\u5968\u30C1\u30A7\u30C3\u30AF\u3092\u6709\u52B9\u306B\u3059\u308B" },
{ "javac.opt.Xdoclint.custom", "\n javadoc\u30B3\u30E1\u30F3\u30C8\u306E\u554F\u984C\u306B\u95A2\u3059\u308B\u7279\u5B9A\u306E\u30C1\u30A7\u30C3\u30AF\u3092\u6709\u52B9\u307E\u305F\u306F\u7121\u52B9\u306B\u3057\u307E\u3059\u3002\n \u3053\u3053\u3067\u3001<group>\u306Faccessibility\u3001html\u3001missing\u3001reference\u307E\u305F\u306Fsyntax\u306E\u3044\u305A\u308C\u304B\u3067\u3001\n <access>\u306Fpublic\u3001protected\u3001package\u307E\u305F\u306Fprivate\u306E\u3044\u305A\u308C\u304B\u3067\u3059\u3002" },
{ "javac.opt.Xdoclint.subopts", "(all|none|[-]<group>)[/<access>]" },
{ "javac.opt.Xlint", "\u63A8\u5968\u306E\u8B66\u544A\u3092\u6709\u52B9\u306B\u3059\u308B" },
{ "javac.opt.Xlint.suboptlist", "\u7279\u5B9A\u306E\u8B66\u544A\u3092\u6709\u52B9\u307E\u305F\u306F\u7121\u52B9\u306B\u3059\u308B" },
{ "javac.opt.Xstdout", "\u6A19\u6E96\u51FA\u529B\u3092\u30EA\u30C0\u30A4\u30EC\u30AF\u30C8\u3059\u308B" },
{ "javac.opt.arg.class", "<class>" },
{ "javac.opt.arg.class.list", "<class1>[,<class2>,<class3>...]" },
{ "javac.opt.arg.directory", "<directory>" },
{ "javac.opt.arg.dirs", "<dirs>" },
{ "javac.opt.arg.encoding", "<encoding>" },
{ "javac.opt.arg.file", "<filename>" },
{ "javac.opt.arg.flag", "<flag>" },
{ "javac.opt.arg.key.equals.value", "key[=value]" },
{ "javac.opt.arg.number", "<number>" },
{ "javac.opt.arg.path", "<path>" },
{ "javac.opt.arg.pathname", "<pathname>" },
{ "javac.opt.arg.plugin", "\"name args\"" },
{ "javac.opt.arg.profile", "<profile>" },
{ "javac.opt.arg.release", "<release>" },
{ "javac.opt.bootclasspath", "\u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30D1\u30B9\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B" },
{ "javac.opt.classpath", "\u30E6\u30FC\u30B6\u30FC\u30FB\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304A\u3088\u3073\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.d", "\u751F\u6210\u3055\u308C\u305F\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u683C\u7D0D\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.deprecation", "\u975E\u63A8\u5968\u306EAPI\u304C\u4F7F\u7528\u3055\u308C\u3066\u3044\u308B\u30BD\u30FC\u30B9\u306E\u5834\u6240\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.diags", "\u8A3A\u65AD\u30E2\u30FC\u30C9\u306E\u9078\u629E" },
{ "javac.opt.encoding", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304C\u4F7F\u7528\u3059\u308B\u6587\u5B57\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.endorseddirs", "\u63A8\u5968\u898F\u683C\u30D1\u30B9\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B" },
{ "javac.opt.extdirs", "\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u6E08\u62E1\u5F35\u6A5F\u80FD\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B" },
{ "javac.opt.g", "\u3059\u3079\u3066\u306E\u30C7\u30D0\u30C3\u30B0\u60C5\u5831\u3092\u751F\u6210\u3059\u308B" },
{ "javac.opt.g.lines.vars.source", "\u3044\u304F\u3064\u304B\u306E\u30C7\u30D0\u30C3\u30B0\u60C5\u5831\u306E\u307F\u3092\u751F\u6210\u3059\u308B" },
{ "javac.opt.g.none", "\u30C7\u30D0\u30C3\u30B0\u60C5\u5831\u3092\u751F\u6210\u3057\u306A\u3044" },
{ "javac.opt.headerDest", "\u751F\u6210\u3055\u308C\u305F\u30CD\u30A4\u30C6\u30A3\u30D6\u30FB\u30D8\u30C3\u30C0\u30FC\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u683C\u7D0D\u3059\u308B\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.help", "\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u306E\u6982\u8981\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.implicit", "\u6697\u9ED9\u7684\u306B\u53C2\u7167\u3055\u308C\u308B\u30D5\u30A1\u30A4\u30EB\u306B\u3064\u3044\u3066\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u751F\u6210\u3059\u308B\u304B\u3069\u3046\u304B\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.maxerrs", "\u51FA\u529B\u3059\u308B\u30A8\u30E9\u30FC\u306E\u6700\u5927\u6570\u3092\u8A2D\u5B9A\u3059\u308B" },
{ "javac.opt.maxwarns", "\u51FA\u529B\u3059\u308B\u8B66\u544A\u306E\u6700\u5927\u6570\u3092\u8A2D\u5B9A\u3059\u308B" },
{ "javac.opt.moreinfo", "\u578B\u5909\u6570\u306E\u62E1\u5F35\u60C5\u5831\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.nogj", "\u8A00\u8A9E\u306E\u6C4E\u7528\u6027\u3092\u53D7\u3051\u4ED8\u3051\u306A\u3044" },
{ "javac.opt.nowarn", "\u8B66\u544A\u3092\u767A\u751F\u3055\u305B\u306A\u3044" },
{ "javac.opt.parameters", "\u30E1\u30BD\u30C3\u30C9\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF\u306B\u30EA\u30D5\u30EC\u30AF\u30B7\u30E7\u30F3\u7528\u306E\u30E1\u30BF\u30C7\u30FC\u30BF\u3092\u751F\u6210\u3057\u307E\u3059" },
{ "javac.opt.pkginfo", "package-info\u30D5\u30A1\u30A4\u30EB\u306E\u51E6\u7406\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.plugin", "\u5B9F\u884C\u3055\u308C\u308B\u30D7\u30E9\u30B0\u30A4\u30F3\u306E\u540D\u524D\u3068\u30AA\u30D7\u30B7\u30E7\u30F3\u5F15\u6570" },
{ "javac.opt.prefer", "\u6697\u9ED9\u7684\u306B\u30B3\u30F3\u30D1\u30A4\u30EB\u3055\u308C\u308B\u30AF\u30E9\u30B9\u306B\u3064\u3044\u3066\u3001\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3068\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u4E21\u65B9\u304C\u898B\u3064\u304B\u3063\u305F\u969B\u3069\u3061\u3089\u3092\u8AAD\u307F\u8FBC\u3080\u304B\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.print", "\u6307\u5B9A\u3057\u305F\u578B\u306E\u30C6\u30AD\u30B9\u30C8\u8868\u793A\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.printProcessorInfo", "\u30D7\u30ED\u30BB\u30C3\u30B5\u304C\u51E6\u7406\u3092\u4F9D\u983C\u3055\u308C\u308B\u6CE8\u91C8\u306B\u3064\u3044\u3066\u306E\u60C5\u5831\u3092\u5370\u5237\u3059\u308B" },
{ "javac.opt.printRounds", "\u6CE8\u91C8\u51E6\u7406\u306E\u5F80\u5FA9\u306B\u3064\u3044\u3066\u306E\u60C5\u5831\u3092\u5370\u5237\u3059\u308B" },
{ "javac.opt.printflat", "\u5185\u90E8\u30AF\u30E9\u30B9\u306E\u5909\u63DB\u5F8C\u306B\u62BD\u8C61\u69CB\u6587\u30C4\u30EA\u30FC\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.printsearch", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u691C\u7D22\u4F4D\u7F6E\u60C5\u5831\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.proc.none.only", "\u6CE8\u91C8\u51E6\u7406\u3084\u30B3\u30F3\u30D1\u30A4\u30EB\u3092\u5B9F\u884C\u3059\u308B\u304B\u3069\u3046\u304B\u3092\u5236\u5FA1\u3057\u307E\u3059\u3002" },
{ "javac.opt.processor", "\u5B9F\u884C\u3059\u308B\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u306E\u540D\u524D\u3002\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u691C\u51FA\u51E6\u7406\u3092\u30D0\u30A4\u30D1\u30B9" },
{ "javac.opt.processorpath", "\u6CE8\u91C8\u30D7\u30ED\u30BB\u30C3\u30B5\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.profile", "\u4F7F\u7528\u3055\u308C\u3066\u3044\u308BAPI\u304C\u6307\u5B9A\u3057\u305F\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB\u3067\u4F7F\u7528\u53EF\u80FD\u304B\u3069\u3046\u304B\u3092\u78BA\u8A8D\u3057\u307E\u3059" },
{ "javac.opt.prompt", "\u5404\u30A8\u30E9\u30FC\u3067\u505C\u6B62\u3059\u308B" },
{ "javac.opt.retrofit", "\u65E2\u5B58\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u6C4E\u7528\u578B\u3067\u7D44\u307F\u66FF\u3048\u308B" },
{ "javac.opt.s", "\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u304B\u308F\u308A\u306Bjava\u30BD\u30FC\u30B9\u3092\u767A\u884C\u3059\u308B" },
{ "javac.opt.scramble", "\u30D0\u30A4\u30C8\u30B3\u30FC\u30C9\u306Eprivate\u8B58\u5225\u5B50\u306B\u30B9\u30AF\u30E9\u30F3\u30D6\u30EB\u3092\u304B\u3051\u308B" },
{ "javac.opt.scrambleall", "\u30D0\u30A4\u30C8\u30B3\u30FC\u30C9\u306Epackage\u53EF\u8996\u8B58\u5225\u5B50\u306B\u30B9\u30AF\u30E9\u30F3\u30D6\u30EB\u3092\u304B\u3051\u308B" },
{ "javac.opt.source", "\u6307\u5B9A\u3055\u308C\u305F\u30EA\u30EA\u30FC\u30B9\u3068\u30BD\u30FC\u30B9\u306E\u4E92\u63DB\u6027\u3092\u4FDD\u3064" },
{ "javac.opt.sourceDest", "\u751F\u6210\u3055\u308C\u305F\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u683C\u7D0D\u3059\u308B\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.sourcepath", "\u5165\u529B\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u691C\u7D22\u3059\u308B\u4F4D\u7F6E\u3092\u6307\u5B9A\u3059\u308B" },
{ "javac.opt.target", "\u7279\u5B9A\u306EVM\u30D0\u30FC\u30B8\u30E7\u30F3\u7528\u306E\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u751F\u6210\u3059\u308B" },
{ "javac.opt.verbose", "\u30B3\u30F3\u30D1\u30A4\u30E9\u306E\u52D5\u4F5C\u306B\u3064\u3044\u3066\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u51FA\u529B\u3059\u308B" },
{ "javac.opt.version", "\u30D0\u30FC\u30B8\u30E7\u30F3\u60C5\u5831" },
{ "javac.version", "{0} {1}" },
{ "javac.warn.profile.target.conflict", "\u30D7\u30ED\u30D5\u30A1\u30A4\u30EB{0}\u306F\u30BF\u30FC\u30B2\u30C3\u30C8\u30FB\u30EA\u30EA\u30FC\u30B9{1}\u306B\u5BFE\u3057\u3066\u6709\u52B9\u3067\u306F\u3042\u308A\u307E\u305B\u3093" },
{ "javac.warn.source.target.conflict", "\u30BD\u30FC\u30B9\u30FB\u30EA\u30EA\u30FC\u30B9{0}\u306B\u306F\u30BF\u30FC\u30B2\u30C3\u30C8\u30FB\u30EA\u30EA\u30FC\u30B9{1}\u304C\u5FC5\u8981\u3067\u3059" },
{ "javac.warn.target.default.source.conflict", "\u30BF\u30FC\u30B2\u30C3\u30C8\u30FB\u30EA\u30EA\u30FC\u30B9{0}\u304C\u30C7\u30D5\u30A9\u30EB\u30C8\u306E\u30BD\u30FC\u30B9\u30FB\u30EA\u30EA\u30FC\u30B9{1}\u3068\u7AF6\u5408\u3057\u3066\u3044\u307E\u3059" },
};
}
}

108
jdkSrc/jdk8/com/sun/tools/javac/resources/javac_zh_CN.java Normal file
View File

@@ -0,0 +1,108 @@
package com.sun.tools.javac.resources;
public final class javac_zh_CN extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "javac.err.dir.not.found", "\u627E\u4E0D\u5230\u76EE\u5F55: {0}" },
{ "javac.err.empty.A.argument", "-A \u9700\u8981\u4E00\u4E2A\u53C2\u6570; \u4F7F\u7528 ''-Akey'' \u6216 ''-Akey=value''" },
{ "javac.err.error.writing.file", "\u5199\u5165{0}\u65F6\u51FA\u9519; {1}" },
{ "javac.err.file.not.directory", "\u4E0D\u662F\u76EE\u5F55: {0}" },
{ "javac.err.file.not.file", "\u4E0D\u662F\u6587\u4EF6: {0}" },
{ "javac.err.file.not.found", "\u627E\u4E0D\u5230\u6587\u4EF6: {0}" },
{ "javac.err.invalid.A.key", "\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u9009\u9879 ''{0}'' \u4E2D\u7684\u5173\u952E\u5B57\u4E0D\u662F\u4EE5\u70B9\u5206\u9694\u7684\u6807\u8BC6\u7B26\u5E8F\u5217" },
{ "javac.err.invalid.arg", "\u65E0\u6548\u7684\u53C2\u6570: {0}" },
{ "javac.err.invalid.flag", "\u65E0\u6548\u7684\u6807\u8BB0: {0}" },
{ "javac.err.invalid.profile", "\u914D\u7F6E\u6587\u4EF6\u65E0\u6548: {0}" },
{ "javac.err.invalid.source", "\u65E0\u6548\u7684\u6E90\u53D1\u884C\u7248: {0}" },
{ "javac.err.invalid.target", "\u65E0\u6548\u7684\u76EE\u6807\u53D1\u884C\u7248: {0}" },
{ "javac.err.no.source.files", "\u65E0\u6E90\u6587\u4EF6" },
{ "javac.err.no.source.files.classes", "\u65E0\u6E90\u6587\u4EF6\u6216\u7C7B\u540D" },
{ "javac.err.profile.bootclasspath.conflict", "\u6982\u8981\u4FE1\u606F\u548C\u5F15\u5BFC\u7C7B\u8DEF\u5F84\u9009\u9879\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528" },
{ "javac.err.req.arg", "{0}\u9700\u8981\u53C2\u6570" },
{ "javac.fullVersion", "{0}\u5B8C\u6574\u7248\u672C \"{1}\"" },
{ "javac.msg.bug", "\u7F16\u8BD1\u5668 ({0}) \u4E2D\u51FA\u73B0\u5F02\u5E38\u9519\u8BEF\u3002\u5982\u679C\u5728 Bug Database (http://bugs.java.com) \u4E2D\u6CA1\u6709\u627E\u5230\u8BE5\u9519\u8BEF, \u8BF7\u901A\u8FC7 Java Bug \u62A5\u544A\u9875 (http://bugreport.java.com) \u5EFA\u7ACB\u8BE5 Java \u7F16\u8BD1\u5668 Bug\u3002\u8BF7\u5728\u62A5\u544A\u4E2D\u9644\u4E0A\u60A8\u7684\u7A0B\u5E8F\u548C\u4EE5\u4E0B\u8BCA\u65AD\u4FE1\u606F\u3002\u8C22\u8C22\u3002" },
{ "javac.msg.io", "\n\n\u53D1\u751F\u8F93\u5165/\u8F93\u51FA\u9519\u8BEF\u3002\n\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u53C2\u9605\u4EE5\u4E0B\u5806\u6808\u8DDF\u8E2A\u3002\n" },
{ "javac.msg.plugin.not.found", "\u627E\u4E0D\u5230\u63D2\u4EF6: {0}" },
{ "javac.msg.plugin.uncaught.exception", "\n\n\u63D2\u4EF6\u629B\u51FA\u672A\u6355\u83B7\u7684\u5F02\u5E38\u9519\u8BEF\u3002\n\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u53C2\u9605\u4EE5\u4E0B\u5806\u6808\u8DDF\u8E2A\u3002\n" },
{ "javac.msg.proc.annotation.uncaught.exception", "\n\n\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u629B\u51FA\u672A\u6355\u83B7\u7684\u5F02\u5E38\u9519\u8BEF\u3002\n\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u53C2\u9605\u4EE5\u4E0B\u5806\u6808\u8DDF\u8E2A\u3002\n" },
{ "javac.msg.resource", "\n\n\u7CFB\u7EDF\u8D44\u6E90\u4E0D\u8DB3\u3002\n\u6709\u5173\u8BE6\u7EC6\u4FE1\u606F, \u8BF7\u53C2\u9605\u4EE5\u4E0B\u5806\u6808\u8DDF\u8E2A\u3002\n" },
{ "javac.msg.usage", "\u7528\u6CD5: {0} <options> <source files>\n-help \u7528\u4E8E\u5217\u51FA\u53EF\u80FD\u7684\u9009\u9879" },
{ "javac.msg.usage.header", "\u7528\u6CD5: {0} <options> <source files>\n\u5176\u4E2D, \u53EF\u80FD\u7684\u9009\u9879\u5305\u62EC:" },
{ "javac.msg.usage.nonstandard.footer", "\u8FD9\u4E9B\u9009\u9879\u90FD\u662F\u975E\u6807\u51C6\u9009\u9879, \u5982\u6709\u66F4\u6539, \u6055\u4E0D\u53E6\u884C\u901A\u77E5\u3002" },
{ "javac.opt.A", "\u4F20\u9012\u7ED9\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u7684\u9009\u9879" },
{ "javac.opt.AT", "\u4ECE\u6587\u4EF6\u8BFB\u53D6\u9009\u9879\u548C\u6587\u4EF6\u540D" },
{ "javac.opt.J", "\u76F4\u63A5\u5C06 <\u6807\u8BB0> \u4F20\u9012\u7ED9\u8FD0\u884C\u65F6\u7CFB\u7EDF" },
{ "javac.opt.Werror", "\u51FA\u73B0\u8B66\u544A\u65F6\u7EC8\u6B62\u7F16\u8BD1" },
{ "javac.opt.X", "\u8F93\u51FA\u975E\u6807\u51C6\u9009\u9879\u7684\u63D0\u8981" },
{ "javac.opt.Xbootclasspath.a", "\u7F6E\u4E8E\u5F15\u5BFC\u7C7B\u8DEF\u5F84\u4E4B\u540E" },
{ "javac.opt.Xbootclasspath.p", "\u7F6E\u4E8E\u5F15\u5BFC\u7C7B\u8DEF\u5F84\u4E4B\u524D" },
{ "javac.opt.Xdoclint", "\u4E3A javadoc \u6CE8\u91CA\u4E2D\u7684\u95EE\u9898\u542F\u7528\u5EFA\u8BAE\u7684\u68C0\u67E5" },
{ "javac.opt.Xdoclint.custom", "\n \u4E3A javadoc \u6CE8\u91CA\u4E2D\u7684\u95EE\u9898\u542F\u7528\u6216\u7981\u7528\u7279\u5B9A\u68C0\u67E5,\n \u5176\u4E2D <group> \u4E3A accessibility, html, missing, reference \u6216 syntax \u4E4B\u4E00\u3002\n <access> \u4E3A public, protected, package \u6216 private \u4E4B\u4E00\u3002" },
{ "javac.opt.Xdoclint.subopts", "(all|none|[-]<group>)[/<access>]" },
{ "javac.opt.Xlint", "\u542F\u7528\u5EFA\u8BAE\u7684\u8B66\u544A" },
{ "javac.opt.Xlint.suboptlist", "\u542F\u7528\u6216\u7981\u7528\u7279\u5B9A\u7684\u8B66\u544A" },
{ "javac.opt.Xstdout", "\u91CD\u5B9A\u5411\u6807\u51C6\u8F93\u51FA" },
{ "javac.opt.arg.class", "<\u7C7B>" },
{ "javac.opt.arg.class.list", "<class1>[,<class2>,<class3>...]" },
{ "javac.opt.arg.directory", "<\u76EE\u5F55>" },
{ "javac.opt.arg.dirs", "<\u76EE\u5F55>" },
{ "javac.opt.arg.encoding", "<\u7F16\u7801>" },
{ "javac.opt.arg.file", "<\u6587\u4EF6\u540D>" },
{ "javac.opt.arg.flag", "<\u6807\u8BB0>" },
{ "javac.opt.arg.key.equals.value", "\u5173\u952E\u5B57[=\u503C]" },
{ "javac.opt.arg.number", "<\u7F16\u53F7>" },
{ "javac.opt.arg.path", "<\u8DEF\u5F84>" },
{ "javac.opt.arg.pathname", "<\u8DEF\u5F84\u540D>" },
{ "javac.opt.arg.plugin", "\"\u540D\u79F0\u53C2\u6570\"" },
{ "javac.opt.arg.profile", "<\u914D\u7F6E\u6587\u4EF6>" },
{ "javac.opt.arg.release", "<\u53D1\u884C\u7248>" },
{ "javac.opt.bootclasspath", "\u8986\u76D6\u5F15\u5BFC\u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E" },
{ "javac.opt.classpath", "\u6307\u5B9A\u67E5\u627E\u7528\u6237\u7C7B\u6587\u4EF6\u548C\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u7684\u4F4D\u7F6E" },
{ "javac.opt.d", "\u6307\u5B9A\u653E\u7F6E\u751F\u6210\u7684\u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E" },
{ "javac.opt.deprecation", "\u8F93\u51FA\u4F7F\u7528\u5DF2\u8FC7\u65F6\u7684 API \u7684\u6E90\u4F4D\u7F6E" },
{ "javac.opt.diags", "\u9009\u62E9\u8BCA\u65AD\u6A21\u5F0F" },
{ "javac.opt.encoding", "\u6307\u5B9A\u6E90\u6587\u4EF6\u4F7F\u7528\u7684\u5B57\u7B26\u7F16\u7801" },
{ "javac.opt.endorseddirs", "\u8986\u76D6\u7B7E\u540D\u7684\u6807\u51C6\u8DEF\u5F84\u7684\u4F4D\u7F6E" },
{ "javac.opt.extdirs", "\u8986\u76D6\u6240\u5B89\u88C5\u6269\u5C55\u7684\u4F4D\u7F6E" },
{ "javac.opt.g", "\u751F\u6210\u6240\u6709\u8C03\u8BD5\u4FE1\u606F" },
{ "javac.opt.g.lines.vars.source", "\u53EA\u751F\u6210\u67D0\u4E9B\u8C03\u8BD5\u4FE1\u606F" },
{ "javac.opt.g.none", "\u4E0D\u751F\u6210\u4EFB\u4F55\u8C03\u8BD5\u4FE1\u606F" },
{ "javac.opt.headerDest", "\u6307\u5B9A\u653E\u7F6E\u751F\u6210\u7684\u672C\u673A\u6807\u5934\u6587\u4EF6\u7684\u4F4D\u7F6E" },
{ "javac.opt.help", "\u8F93\u51FA\u6807\u51C6\u9009\u9879\u7684\u63D0\u8981" },
{ "javac.opt.implicit", "\u6307\u5B9A\u662F\u5426\u4E3A\u9690\u5F0F\u5F15\u7528\u6587\u4EF6\u751F\u6210\u7C7B\u6587\u4EF6" },
{ "javac.opt.maxerrs", "\u8BBE\u7F6E\u8981\u8F93\u51FA\u7684\u9519\u8BEF\u7684\u6700\u5927\u6570\u76EE" },
{ "javac.opt.maxwarns", "\u8BBE\u7F6E\u8981\u8F93\u51FA\u7684\u8B66\u544A\u7684\u6700\u5927\u6570\u76EE" },
{ "javac.opt.moreinfo", "\u8F93\u51FA\u7C7B\u578B\u53D8\u91CF\u7684\u6269\u5C55\u4FE1\u606F" },
{ "javac.opt.nogj", "\u8BED\u8A00\u4E2D\u4E0D\u63A5\u53D7\u6CDB\u578B" },
{ "javac.opt.nowarn", "\u4E0D\u751F\u6210\u4EFB\u4F55\u8B66\u544A" },
{ "javac.opt.parameters", "\u751F\u6210\u5143\u6570\u636E\u4EE5\u7528\u4E8E\u65B9\u6CD5\u53C2\u6570\u7684\u53CD\u5C04" },
{ "javac.opt.pkginfo", "\u6307\u5B9A package-info \u6587\u4EF6\u7684\u5904\u7406" },
{ "javac.opt.plugin", "\u8981\u8FD0\u884C\u7684\u63D2\u4EF6\u7684\u540D\u79F0\u548C\u53EF\u9009\u53C2\u6570" },
{ "javac.opt.prefer", "\u6307\u5B9A\u8BFB\u53D6\u6587\u4EF6, \u5F53\u540C\u65F6\u627E\u5230\u9690\u5F0F\u7F16\u8BD1\u7C7B\u7684\u6E90\u6587\u4EF6\u548C\u7C7B\u6587\u4EF6\u65F6" },
{ "javac.opt.print", "\u8F93\u51FA\u6307\u5B9A\u7C7B\u578B\u7684\u6587\u672C\u8868\u793A" },
{ "javac.opt.printProcessorInfo", "\u8F93\u51FA\u6709\u5173\u8BF7\u6C42\u5904\u7406\u7A0B\u5E8F\u5904\u7406\u54EA\u4E9B\u6CE8\u91CA\u7684\u4FE1\u606F" },
{ "javac.opt.printRounds", "\u8F93\u51FA\u6709\u5173\u6CE8\u91CA\u5904\u7406\u5FAA\u73AF\u7684\u4FE1\u606F" },
{ "javac.opt.printflat", "\u5728\u5185\u90E8\u7C7B\u8F6C\u6362\u4E4B\u540E\u8F93\u51FA\u62BD\u8C61\u8BED\u6CD5\u6811" },
{ "javac.opt.printsearch", "\u8F93\u51FA\u6709\u5173\u641C\u7D22\u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E\u7684\u4FE1\u606F" },
{ "javac.opt.proc.none.only", "\u63A7\u5236\u662F\u5426\u6267\u884C\u6CE8\u91CA\u5904\u7406\u548C/\u6216\u7F16\u8BD1\u3002" },
{ "javac.opt.processor", "\u8981\u8FD0\u884C\u7684\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u7684\u540D\u79F0; \u7ED5\u8FC7\u9ED8\u8BA4\u7684\u641C\u7D22\u8FDB\u7A0B" },
{ "javac.opt.processorpath", "\u6307\u5B9A\u67E5\u627E\u6CE8\u91CA\u5904\u7406\u7A0B\u5E8F\u7684\u4F4D\u7F6E" },
{ "javac.opt.profile", "\u8BF7\u786E\u4FDD\u4F7F\u7528\u7684 API \u5728\u6307\u5B9A\u7684\u914D\u7F6E\u6587\u4EF6\u4E2D\u53EF\u7528" },
{ "javac.opt.prompt", "\u5728\u6BCF\u6B21\u51FA\u9519\u540E\u505C\u6B62" },
{ "javac.opt.retrofit", "\u66F4\u65B0\u4F7F\u7528\u6CDB\u578B\u7684\u73B0\u6709\u7C7B\u6587\u4EF6" },
{ "javac.opt.s", "\u53D1\u51FA java \u6E90\u800C\u4E0D\u662F\u7C7B\u6587\u4EF6" },
{ "javac.opt.scramble", "\u5728\u5B57\u8282\u7801\u4E2D\u6DF7\u6DC6\u4E13\u7528\u6807\u8BC6\u7B26" },
{ "javac.opt.scrambleall", "\u5728\u5B57\u8282\u7801\u4E2D\u6DF7\u6DC6\u7A0B\u5E8F\u5305\u53EF\u89C1\u6807\u8BC6\u7B26" },
{ "javac.opt.source", "\u63D0\u4F9B\u4E0E\u6307\u5B9A\u53D1\u884C\u7248\u7684\u6E90\u517C\u5BB9\u6027" },
{ "javac.opt.sourceDest", "\u6307\u5B9A\u653E\u7F6E\u751F\u6210\u7684\u6E90\u6587\u4EF6\u7684\u4F4D\u7F6E" },
{ "javac.opt.sourcepath", "\u6307\u5B9A\u67E5\u627E\u8F93\u5165\u6E90\u6587\u4EF6\u7684\u4F4D\u7F6E" },
{ "javac.opt.target", "\u751F\u6210\u7279\u5B9A VM \u7248\u672C\u7684\u7C7B\u6587\u4EF6" },
{ "javac.opt.verbose", "\u8F93\u51FA\u6709\u5173\u7F16\u8BD1\u5668\u6B63\u5728\u6267\u884C\u7684\u64CD\u4F5C\u7684\u6D88\u606F" },
{ "javac.opt.version", "\u7248\u672C\u4FE1\u606F" },
{ "javac.version", "{0} {1}" },
{ "javac.warn.profile.target.conflict", "\u914D\u7F6E\u6587\u4EF6{0}\u5BF9\u4E8E\u76EE\u6807\u53D1\u884C\u7248 {1} \u65E0\u6548" },
{ "javac.warn.source.target.conflict", "\u6E90\u53D1\u884C\u7248 {0} \u9700\u8981\u76EE\u6807\u53D1\u884C\u7248 {1}" },
{ "javac.warn.target.default.source.conflict", "\u76EE\u6807\u53D1\u884C\u7248 {0} \u4E0E\u9ED8\u8BA4\u7684\u6E90\u53D1\u884C\u7248 {1} \u51B2\u7A81" },
};
}
}

557
jdkSrc/jdk8/com/sun/tools/javac/resources/legacy.java Normal file
View File

@@ -0,0 +1,557 @@
package com.sun.tools.javac.resources;
public final class legacy extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "com.sun.accessibility.internal.resources", "tiger legacy" },
{ "com.sun.awt", "tiger legacy" },
{ "com.sun.beans", "tiger legacy" },
{ "com.sun.corba.se.impl.activation", "tiger legacy" },
{ "com.sun.corba.se.impl.copyobject", "tiger legacy" },
{ "com.sun.corba.se.impl.corba", "tiger legacy" },
{ "com.sun.corba.se.impl.dynamicany", "tiger legacy" },
{ "com.sun.corba.se.impl.encoding", "tiger legacy" },
{ "com.sun.corba.se.impl.interceptors", "tiger legacy" },
{ "com.sun.corba.se.impl.io", "tiger legacy" },
{ "com.sun.corba.se.impl.ior", "tiger legacy" },
{ "com.sun.corba.se.impl.ior.iiop", "tiger legacy" },
{ "com.sun.corba.se.impl.javax.rmi", "tiger legacy" },
{ "com.sun.corba.se.impl.javax.rmi.CORBA", "tiger legacy" },
{ "com.sun.corba.se.impl.legacy.connection", "tiger legacy" },
{ "com.sun.corba.se.impl.logging", "tiger legacy" },
{ "com.sun.corba.se.impl.monitoring", "tiger legacy" },
{ "com.sun.corba.se.impl.naming.cosnaming", "tiger legacy" },
{ "com.sun.corba.se.impl.naming.namingutil", "tiger legacy" },
{ "com.sun.corba.se.impl.naming.pcosnaming", "tiger legacy" },
{ "com.sun.corba.se.impl.oa", "tiger legacy" },
{ "com.sun.corba.se.impl.oa.poa", "tiger legacy" },
{ "com.sun.corba.se.impl.oa.toa", "tiger legacy" },
{ "com.sun.corba.se.impl.orb", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.closure", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.concurrent", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.fsm", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.graph", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.resources", "tiger legacy" },
{ "com.sun.corba.se.impl.orbutil.threadpool", "tiger legacy" },
{ "com.sun.corba.se.impl.presentation.rmi", "tiger legacy" },
{ "com.sun.corba.se.impl.protocol", "tiger legacy" },
{ "com.sun.corba.se.impl.protocol.giopmsgheaders", "tiger legacy" },
{ "com.sun.corba.se.impl.resolver", "tiger legacy" },
{ "com.sun.corba.se.impl.transport", "tiger legacy" },
{ "com.sun.corba.se.impl.util", "tiger legacy" },
{ "com.sun.corba.se.internal.CosNaming", "tiger legacy" },
{ "com.sun.corba.se.internal.Interceptors", "tiger legacy" },
{ "com.sun.corba.se.internal.POA", "tiger legacy" },
{ "com.sun.corba.se.internal.corba", "tiger legacy" },
{ "com.sun.corba.se.internal.iiop", "tiger legacy" },
{ "com.sun.corba.se.org.omg.CORBA", "tiger legacy" },
{ "com.sun.corba.se.pept.broker", "tiger legacy" },
{ "com.sun.corba.se.pept.encoding", "tiger legacy" },
{ "com.sun.corba.se.pept.protocol", "tiger legacy" },
{ "com.sun.corba.se.pept.transport", "tiger legacy" },
{ "com.sun.corba.se.spi.activation", "tiger legacy" },
{ "com.sun.corba.se.spi.activation.InitialNameServicePackage", "tiger legacy" },
{ "com.sun.corba.se.spi.activation.LocatorPackage", "tiger legacy" },
{ "com.sun.corba.se.spi.activation.RepositoryPackage", "tiger legacy" },
{ "com.sun.corba.se.spi.copyobject", "tiger legacy" },
{ "com.sun.corba.se.spi.encoding", "tiger legacy" },
{ "com.sun.corba.se.spi.extension", "tiger legacy" },
{ "com.sun.corba.se.spi.ior", "tiger legacy" },
{ "com.sun.corba.se.spi.ior.iiop", "tiger legacy" },
{ "com.sun.corba.se.spi.legacy.connection", "tiger legacy" },
{ "com.sun.corba.se.spi.legacy.interceptor", "tiger legacy" },
{ "com.sun.corba.se.spi.logging", "tiger legacy" },
{ "com.sun.corba.se.spi.monitoring", "tiger legacy" },
{ "com.sun.corba.se.spi.oa", "tiger legacy" },
{ "com.sun.corba.se.spi.orb", "tiger legacy" },
{ "com.sun.corba.se.spi.orbutil.closure", "tiger legacy" },
{ "com.sun.corba.se.spi.orbutil.fsm", "tiger legacy" },
{ "com.sun.corba.se.spi.orbutil.proxy", "tiger legacy" },
{ "com.sun.corba.se.spi.orbutil.threadpool", "tiger legacy" },
{ "com.sun.corba.se.spi.presentation.rmi", "tiger legacy" },
{ "com.sun.corba.se.spi.protocol", "tiger legacy" },
{ "com.sun.corba.se.spi.resolver", "tiger legacy" },
{ "com.sun.corba.se.spi.servicecontext", "tiger legacy" },
{ "com.sun.corba.se.spi.transport", "tiger legacy" },
{ "com.sun.imageio.metadata", "tiger legacy" },
{ "com.sun.imageio.plugins.bmp", "tiger legacy" },
{ "com.sun.imageio.plugins.common", "tiger legacy" },
{ "com.sun.imageio.plugins.gif", "tiger legacy" },
{ "com.sun.imageio.plugins.jpeg", "tiger legacy" },
{ "com.sun.imageio.plugins.png", "tiger legacy" },
{ "com.sun.imageio.plugins.wbmp", "tiger legacy" },
{ "com.sun.imageio.spi", "tiger legacy" },
{ "com.sun.java.browser.dom", "tiger legacy" },
{ "com.sun.java.browser.net", "tiger legacy" },
{ "com.sun.java.swing", "tiger legacy" },
{ "com.sun.java.swing.plaf.gtk", "tiger legacy" },
{ "com.sun.java.swing.plaf.gtk.icons", "tiger legacy" },
{ "com.sun.java.swing.plaf.gtk.resources", "tiger legacy" },
{ "com.sun.java.swing.plaf.gtk.resources.metacity.SwingFallbackTheme.metacity-1", "tiger legacy" },
{ "com.sun.java.swing.plaf.motif", "tiger legacy" },
{ "com.sun.java.swing.plaf.motif.icons", "tiger legacy" },
{ "com.sun.java.swing.plaf.motif.resources", "tiger legacy" },
{ "com.sun.java.swing.plaf.nimbus", "tiger legacy" },
{ "com.sun.java.swing.plaf.windows", "tiger legacy" },
{ "com.sun.java.swing.plaf.windows.icons", "tiger legacy" },
{ "com.sun.java.swing.plaf.windows.resources", "tiger legacy" },
{ "com.sun.java.util.jar.pack", "tiger legacy" },
{ "com.sun.java_cup.internal", "tiger legacy" },
{ "com.sun.java_cup.internal.runtime", "tiger legacy" },
{ "com.sun.jlex.internal", "tiger legacy" },
{ "com.sun.jmx.defaults", "tiger legacy" },
{ "com.sun.jmx.interceptor", "tiger legacy" },
{ "com.sun.jmx.mbeanserver", "tiger legacy" },
{ "com.sun.jmx.remote.internal", "tiger legacy" },
{ "com.sun.jmx.remote.protocol.iiop", "tiger legacy" },
{ "com.sun.jmx.remote.protocol.rmi", "tiger legacy" },
{ "com.sun.jmx.remote.security", "tiger legacy" },
{ "com.sun.jmx.remote.util", "tiger legacy" },
{ "com.sun.jmx.snmp", "tiger legacy" },
{ "com.sun.jmx.snmp.IPAcl", "tiger legacy" },
{ "com.sun.jmx.snmp.agent", "tiger legacy" },
{ "com.sun.jmx.snmp.daemon", "tiger legacy" },
{ "com.sun.jmx.snmp.defaults", "tiger legacy" },
{ "com.sun.jmx.snmp.internal", "tiger legacy" },
{ "com.sun.jmx.snmp.mpm", "tiger legacy" },
{ "com.sun.jmx.snmp.tasks", "tiger legacy" },
{ "com.sun.jmx.trace", "tiger legacy" },
{ "com.sun.jndi.cosnaming", "tiger legacy" },
{ "com.sun.jndi.dns", "tiger legacy" },
{ "com.sun.jndi.ldap", "tiger legacy" },
{ "com.sun.jndi.ldap.ext", "tiger legacy" },
{ "com.sun.jndi.ldap.pool", "tiger legacy" },
{ "com.sun.jndi.ldap.sasl", "tiger legacy" },
{ "com.sun.jndi.ldap.spi", "tiger legacy" },
{ "com.sun.jndi.rmi.registry", "tiger legacy" },
{ "com.sun.jndi.toolkit.corba", "tiger legacy" },
{ "com.sun.jndi.toolkit.ctx", "tiger legacy" },
{ "com.sun.jndi.toolkit.dir", "tiger legacy" },
{ "com.sun.jndi.toolkit.url", "tiger legacy" },
{ "com.sun.jndi.url.corbaname", "tiger legacy" },
{ "com.sun.jndi.url.dns", "tiger legacy" },
{ "com.sun.jndi.url.iiop", "tiger legacy" },
{ "com.sun.jndi.url.iiopname", "tiger legacy" },
{ "com.sun.jndi.url.ldap", "tiger legacy" },
{ "com.sun.jndi.url.ldaps", "tiger legacy" },
{ "com.sun.jndi.url.rmi", "tiger legacy" },
{ "com.sun.management", "tiger legacy" },
{ "com.sun.management.jmx", "tiger legacy" },
{ "com.sun.media.sound", "tiger legacy" },
{ "com.sun.naming.internal", "tiger legacy" },
{ "com.sun.net.ssl", "tiger legacy" },
{ "com.sun.net.ssl.internal.ssl", "tiger legacy" },
{ "com.sun.net.ssl.internal.www.protocol.https", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.classfile", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.generic", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.util", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.verifier", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.verifier.exc", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.verifier.statics", "tiger legacy" },
{ "com.sun.org.apache.bcel.internal.verifier.structurals", "tiger legacy" },
{ "com.sun.org.apache.html.internal.dom", "tiger legacy" },
{ "com.sun.org.apache.regexp.internal", "tiger legacy" },
{ "com.sun.org.apache.wml.internal", "tiger legacy" },
{ "com.sun.org.apache.wml.internal.dom", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.client", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.extensions", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.lib", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.res", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.templates", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xslt", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.cmdline", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.cmdline.getopt", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.compiler", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.compiler.util", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.dom", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.runtime", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.runtime.output", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.trax", "tiger legacy" },
{ "com.sun.org.apache.xalan.internal.xsltc.util", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.dom", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.dom.events", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.dom3.as", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dtd", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dtd.models", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dv", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dv.dtd", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dv.util", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.dv.xs", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.io", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.msg", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.validation", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xpath", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xpath.regex", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.dom", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.identity", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.models", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.opti", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.traversers", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.impl.xs.util", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.jaxp", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.jaxp.datatype", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.jaxp.validation", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.jaxp.validation.xs", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.parsers", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.util", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.xinclude", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.xni", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.xni.grammars", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.xni.parser", "tiger legacy" },
{ "com.sun.org.apache.xerces.internal.xs", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.dtm", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.dtm.ref", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.dtm.ref.dom2dtm", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.dtm.ref.sax2dtm", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.res", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.serialize", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.serializer", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.utils", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.utils.res", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.utils.synthetic", "tiger legacy" },
{ "com.sun.org.apache.xml.internal.utils.synthetic.reflection", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.axes", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.compiler", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.functions", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.jaxp", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.objects", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.operations", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.patterns", "tiger legacy" },
{ "com.sun.org.apache.xpath.internal.res", "tiger legacy" },
{ "com.sun.org.omg.CORBA", "tiger legacy" },
{ "com.sun.org.omg.CORBA.ValueDefPackage", "tiger legacy" },
{ "com.sun.org.omg.CORBA.portable", "tiger legacy" },
{ "com.sun.org.omg.SendingContext", "tiger legacy" },
{ "com.sun.org.omg.SendingContext.CodeBasePackage", "tiger legacy" },
{ "com.sun.rmi.rmid", "tiger legacy" },
{ "com.sun.rowset", "tiger legacy" },
{ "com.sun.rowset.internal", "tiger legacy" },
{ "com.sun.rowset.providers", "tiger legacy" },
{ "com.sun.security.auth", "tiger legacy" },
{ "com.sun.security.auth.callback", "tiger legacy" },
{ "com.sun.security.auth.login", "tiger legacy" },
{ "com.sun.security.auth.module", "tiger legacy" },
{ "com.sun.security.cert.internal.x509", "tiger legacy" },
{ "com.sun.security.jgss", "tiger legacy" },
{ "com.sun.security.sasl", "tiger legacy" },
{ "com.sun.security.sasl.digest", "tiger legacy" },
{ "com.sun.security.sasl.gsskerb", "tiger legacy" },
{ "com.sun.security.sasl.util", "tiger legacy" },
{ "com.sun.swing.internal.plaf.basic.resources", "tiger legacy" },
{ "com.sun.swing.internal.plaf.metal.resources", "tiger legacy" },
{ "com.sun.swing.internal.plaf.synth.resources", "tiger legacy" },
{ "com.sun.tracing", "tiger legacy" },
{ "com.sun.tracing.dtrace", "tiger legacy" },
{ "java.applet", "tiger legacy" },
{ "java.awt", "tiger legacy" },
{ "java.awt.color", "tiger legacy" },
{ "java.awt.datatransfer", "tiger legacy" },
{ "java.awt.dnd", "tiger legacy" },
{ "java.awt.dnd.peer", "tiger legacy" },
{ "java.awt.event", "tiger legacy" },
{ "java.awt.font", "tiger legacy" },
{ "java.awt.geom", "tiger legacy" },
{ "java.awt.im", "tiger legacy" },
{ "java.awt.im.spi", "tiger legacy" },
{ "java.awt.image", "tiger legacy" },
{ "java.awt.image.renderable", "tiger legacy" },
{ "java.awt.peer", "tiger legacy" },
{ "java.awt.print", "tiger legacy" },
{ "java.beans", "tiger legacy" },
{ "java.beans.beancontext", "tiger legacy" },
{ "java.io", "tiger legacy" },
{ "java.lang", "tiger legacy" },
{ "java.lang.annotation", "tiger legacy" },
{ "java.lang.instrument", "tiger legacy" },
{ "java.lang.management", "tiger legacy" },
{ "java.lang.ref", "tiger legacy" },
{ "java.lang.reflect", "tiger legacy" },
{ "java.math", "tiger legacy" },
{ "java.net", "tiger legacy" },
{ "java.nio", "tiger legacy" },
{ "java.nio.channels", "tiger legacy" },
{ "java.nio.channels.spi", "tiger legacy" },
{ "java.nio.charset", "tiger legacy" },
{ "java.nio.charset.spi", "tiger legacy" },
{ "java.rmi", "tiger legacy" },
{ "java.rmi.activation", "tiger legacy" },
{ "java.rmi.dgc", "tiger legacy" },
{ "java.rmi.registry", "tiger legacy" },
{ "java.rmi.server", "tiger legacy" },
{ "java.security", "tiger legacy" },
{ "java.security.acl", "tiger legacy" },
{ "java.security.cert", "tiger legacy" },
{ "java.security.interfaces", "tiger legacy" },
{ "java.security.spec", "tiger legacy" },
{ "java.sql", "tiger legacy" },
{ "java.text", "tiger legacy" },
{ "java.util", "tiger legacy" },
{ "java.util.concurrent", "tiger legacy" },
{ "java.util.concurrent.atomic", "tiger legacy" },
{ "java.util.concurrent.locks", "tiger legacy" },
{ "java.util.jar", "tiger legacy" },
{ "java.util.logging", "tiger legacy" },
{ "java.util.prefs", "tiger legacy" },
{ "java.util.regex", "tiger legacy" },
{ "java.util.zip", "tiger legacy" },
{ "javax.accessibility", "tiger legacy" },
{ "javax.activity", "tiger legacy" },
{ "javax.imageio", "tiger legacy" },
{ "javax.imageio.event", "tiger legacy" },
{ "javax.imageio.metadata", "tiger legacy" },
{ "javax.imageio.plugins.bmp", "tiger legacy" },
{ "javax.imageio.plugins.jpeg", "tiger legacy" },
{ "javax.imageio.spi", "tiger legacy" },
{ "javax.imageio.stream", "tiger legacy" },
{ "javax.management", "tiger legacy" },
{ "javax.management.loading", "tiger legacy" },
{ "javax.management.modelmbean", "tiger legacy" },
{ "javax.management.monitor", "tiger legacy" },
{ "javax.management.openmbean", "tiger legacy" },
{ "javax.management.relation", "tiger legacy" },
{ "javax.management.remote", "tiger legacy" },
{ "javax.management.remote.rmi", "tiger legacy" },
{ "javax.management.timer", "tiger legacy" },
{ "javax.naming", "tiger legacy" },
{ "javax.naming.directory", "tiger legacy" },
{ "javax.naming.event", "tiger legacy" },
{ "javax.naming.ldap", "tiger legacy" },
{ "javax.naming.spi", "tiger legacy" },
{ "javax.net", "tiger legacy" },
{ "javax.net.ssl", "tiger legacy" },
{ "javax.print", "tiger legacy" },
{ "javax.print.attribute", "tiger legacy" },
{ "javax.print.attribute.standard", "tiger legacy" },
{ "javax.print.event", "tiger legacy" },
{ "javax.rmi", "tiger legacy" },
{ "javax.rmi.CORBA", "tiger legacy" },
{ "javax.rmi.ssl", "tiger legacy" },
{ "javax.security.auth", "tiger legacy" },
{ "javax.security.auth.callback", "tiger legacy" },
{ "javax.security.auth.kerberos", "tiger legacy" },
{ "javax.security.auth.login", "tiger legacy" },
{ "javax.security.auth.spi", "tiger legacy" },
{ "javax.security.auth.x500", "tiger legacy" },
{ "javax.security.cert", "tiger legacy" },
{ "javax.security.sasl", "tiger legacy" },
{ "javax.sound.midi", "tiger legacy" },
{ "javax.sound.midi.spi", "tiger legacy" },
{ "javax.sound.sampled", "tiger legacy" },
{ "javax.sound.sampled.spi", "tiger legacy" },
{ "javax.sql", "tiger legacy" },
{ "javax.sql.rowset", "tiger legacy" },
{ "javax.sql.rowset.serial", "tiger legacy" },
{ "javax.sql.rowset.spi", "tiger legacy" },
{ "javax.swing", "tiger legacy" },
{ "javax.swing.border", "tiger legacy" },
{ "javax.swing.colorchooser", "tiger legacy" },
{ "javax.swing.event", "tiger legacy" },
{ "javax.swing.filechooser", "tiger legacy" },
{ "javax.swing.plaf", "tiger legacy" },
{ "javax.swing.plaf.basic", "tiger legacy" },
{ "javax.swing.plaf.basic.icons", "tiger legacy" },
{ "javax.swing.plaf.metal", "tiger legacy" },
{ "javax.swing.plaf.metal.icons", "tiger legacy" },
{ "javax.swing.plaf.metal.icons.ocean", "tiger legacy" },
{ "javax.swing.plaf.metal.sounds", "tiger legacy" },
{ "javax.swing.plaf.multi", "tiger legacy" },
{ "javax.swing.plaf.nimbus", "tiger legacy" },
{ "javax.swing.plaf.synth", "tiger legacy" },
{ "javax.swing.table", "tiger legacy" },
{ "javax.swing.text", "tiger legacy" },
{ "javax.swing.text.html", "tiger legacy" },
{ "javax.swing.text.html.icons", "tiger legacy" },
{ "javax.swing.text.html.parser", "tiger legacy" },
{ "javax.swing.text.rtf", "tiger legacy" },
{ "javax.swing.text.rtf.charsets", "tiger legacy" },
{ "javax.swing.tree", "tiger legacy" },
{ "javax.swing.undo", "tiger legacy" },
{ "javax.transaction", "tiger legacy" },
{ "javax.transaction.xa", "tiger legacy" },
{ "javax.xml", "tiger legacy" },
{ "javax.xml.datatype", "tiger legacy" },
{ "javax.xml.namespace", "tiger legacy" },
{ "javax.xml.parsers", "tiger legacy" },
{ "javax.xml.transform", "tiger legacy" },
{ "javax.xml.transform.dom", "tiger legacy" },
{ "javax.xml.transform.sax", "tiger legacy" },
{ "javax.xml.transform.stream", "tiger legacy" },
{ "javax.xml.validation", "tiger legacy" },
{ "javax.xml.xpath", "tiger legacy" },
{ "org.ietf.jgss", "tiger legacy" },
{ "org.omg.CORBA", "tiger legacy" },
{ "org.omg.CORBA.DynAnyPackage", "tiger legacy" },
{ "org.omg.CORBA.ORBPackage", "tiger legacy" },
{ "org.omg.CORBA.TypeCodePackage", "tiger legacy" },
{ "org.omg.CORBA.portable", "tiger legacy" },
{ "org.omg.CORBA_2_3", "tiger legacy" },
{ "org.omg.CORBA_2_3.portable", "tiger legacy" },
{ "org.omg.CosNaming", "tiger legacy" },
{ "org.omg.CosNaming.NamingContextExtPackage", "tiger legacy" },
{ "org.omg.CosNaming.NamingContextPackage", "tiger legacy" },
{ "org.omg.Dynamic", "tiger legacy" },
{ "org.omg.DynamicAny", "tiger legacy" },
{ "org.omg.DynamicAny.DynAnyFactoryPackage", "tiger legacy" },
{ "org.omg.DynamicAny.DynAnyPackage", "tiger legacy" },
{ "org.omg.IOP", "tiger legacy" },
{ "org.omg.IOP.CodecFactoryPackage", "tiger legacy" },
{ "org.omg.IOP.CodecPackage", "tiger legacy" },
{ "org.omg.Messaging", "tiger legacy" },
{ "org.omg.PortableInterceptor", "tiger legacy" },
{ "org.omg.PortableInterceptor.ORBInitInfoPackage", "tiger legacy" },
{ "org.omg.PortableServer", "tiger legacy" },
{ "org.omg.PortableServer.CurrentPackage", "tiger legacy" },
{ "org.omg.PortableServer.POAManagerPackage", "tiger legacy" },
{ "org.omg.PortableServer.POAPackage", "tiger legacy" },
{ "org.omg.PortableServer.ServantLocatorPackage", "tiger legacy" },
{ "org.omg.PortableServer.portable", "tiger legacy" },
{ "org.omg.SendingContext", "tiger legacy" },
{ "org.omg.stub.java.rmi", "tiger legacy" },
{ "org.omg.stub.javax.management.remote.rmi", "tiger legacy" },
{ "org.w3c.dom", "tiger legacy" },
{ "org.w3c.dom.bootstrap", "tiger legacy" },
{ "org.w3c.dom.css", "tiger legacy" },
{ "org.w3c.dom.events", "tiger legacy" },
{ "org.w3c.dom.html", "tiger legacy" },
{ "org.w3c.dom.ls", "tiger legacy" },
{ "org.w3c.dom.ranges", "tiger legacy" },
{ "org.w3c.dom.stylesheets", "tiger legacy" },
{ "org.w3c.dom.traversal", "tiger legacy" },
{ "org.w3c.dom.views", "tiger legacy" },
{ "org.xml.sax", "tiger legacy" },
{ "org.xml.sax.ext", "tiger legacy" },
{ "org.xml.sax.helpers", "tiger legacy" },
{ "sun.applet", "tiger legacy" },
{ "sun.applet.resources", "tiger legacy" },
{ "sun.audio", "tiger legacy" },
{ "sun.awt", "tiger legacy" },
{ "sun.awt.X11", "tiger legacy" },
{ "sun.awt.color", "tiger legacy" },
{ "sun.awt.datatransfer", "tiger legacy" },
{ "sun.awt.dnd", "tiger legacy" },
{ "sun.awt.geom", "tiger legacy" },
{ "sun.awt.im", "tiger legacy" },
{ "sun.awt.image", "tiger legacy" },
{ "sun.awt.image.codec", "tiger legacy" },
{ "sun.awt.motif", "tiger legacy" },
{ "sun.awt.resources", "tiger legacy" },
{ "sun.awt.shell", "tiger legacy" },
{ "sun.awt.windows", "tiger legacy" },
{ "sun.beans.editors", "tiger legacy" },
{ "sun.beans.infos", "tiger legacy" },
{ "sun.corba", "tiger legacy" },
{ "sun.dc.path", "tiger legacy" },
{ "sun.dc.pr", "tiger legacy" },
{ "sun.font", "tiger legacy" },
{ "sun.instrument", "tiger legacy" },
{ "sun.io", "tiger legacy" },
{ "sun.java2d", "tiger legacy" },
{ "sun.java2d.loops", "tiger legacy" },
{ "sun.java2d.opengl", "tiger legacy" },
{ "sun.java2d.pipe", "tiger legacy" },
{ "sun.jdbc.odbc", "tiger legacy" },
{ "sun.jdbc.odbc.ee", "tiger legacy" },
{ "sun.management", "tiger legacy" },
{ "sun.management.counter", "tiger legacy" },
{ "sun.management.counter.perf", "tiger legacy" },
{ "sun.management.jmxremote", "tiger legacy" },
{ "sun.management.resources", "tiger legacy" },
{ "sun.management.snmp", "tiger legacy" },
{ "sun.management.snmp.jvminstr", "tiger legacy" },
{ "sun.management.snmp.jvmmib", "tiger legacy" },
{ "sun.management.snmp.util", "tiger legacy" },
{ "sun.misc", "tiger legacy" },
{ "sun.misc.resources", "tiger legacy" },
{ "sun.net", "tiger legacy" },
{ "sun.net.dns", "tiger legacy" },
{ "sun.net.ftp", "tiger legacy" },
{ "sun.net.smtp", "tiger legacy" },
{ "sun.net.spi", "tiger legacy" },
{ "sun.net.spi.nameservice", "tiger legacy" },
{ "sun.net.util", "tiger legacy" },
{ "sun.net.www", "tiger legacy" },
{ "sun.net.www.content.audio", "tiger legacy" },
{ "sun.net.www.content.image", "tiger legacy" },
{ "sun.net.www.content.text", "tiger legacy" },
{ "sun.net.www.http", "tiger legacy" },
{ "sun.net.www.protocol.doc", "tiger legacy" },
{ "sun.net.www.protocol.file", "tiger legacy" },
{ "sun.net.www.protocol.ftp", "tiger legacy" },
{ "sun.net.www.protocol.gopher", "tiger legacy" },
{ "sun.net.www.protocol.http", "tiger legacy" },
{ "sun.net.www.protocol.https", "tiger legacy" },
{ "sun.net.www.protocol.jar", "tiger legacy" },
{ "sun.net.www.protocol.mailto", "tiger legacy" },
{ "sun.net.www.protocol.netdoc", "tiger legacy" },
{ "sun.net.www.protocol.systemresource", "tiger legacy" },
{ "sun.net.www.protocol.verbatim", "tiger legacy" },
{ "sun.nio", "tiger legacy" },
{ "sun.nio.ch", "tiger legacy" },
{ "sun.nio.cs", "tiger legacy" },
{ "sun.print", "tiger legacy" },
{ "sun.print.resources", "tiger legacy" },
{ "sun.reflect", "tiger legacy" },
{ "sun.reflect.annotation", "tiger legacy" },
{ "sun.reflect.generics.factory", "tiger legacy" },
{ "sun.reflect.generics.parser", "tiger legacy" },
{ "sun.reflect.generics.reflectiveObjects", "tiger legacy" },
{ "sun.reflect.generics.repository", "tiger legacy" },
{ "sun.reflect.generics.scope", "tiger legacy" },
{ "sun.reflect.generics.tree", "tiger legacy" },
{ "sun.reflect.generics.visitor", "tiger legacy" },
{ "sun.rmi.log", "tiger legacy" },
{ "sun.rmi.registry", "tiger legacy" },
{ "sun.rmi.registry.resources", "tiger legacy" },
{ "sun.rmi.rmid.resources", "tiger legacy" },
{ "sun.rmi.runtime", "tiger legacy" },
{ "sun.rmi.server", "tiger legacy" },
{ "sun.rmi.transport", "tiger legacy" },
{ "sun.rmi.transport.proxy", "tiger legacy" },
{ "sun.rmi.transport.tcp", "tiger legacy" },
{ "sun.security.acl", "tiger legacy" },
{ "sun.security.action", "tiger legacy" },
{ "sun.security.jca", "tiger legacy" },
{ "sun.security.jgss", "tiger legacy" },
{ "sun.security.jgss.krb5", "tiger legacy" },
{ "sun.security.jgss.spi", "tiger legacy" },
{ "sun.security.krb5", "tiger legacy" },
{ "sun.security.krb5.internal", "tiger legacy" },
{ "sun.security.krb5.internal.ccache", "tiger legacy" },
{ "sun.security.krb5.internal.crypto", "tiger legacy" },
{ "sun.security.krb5.internal.crypto.dk", "tiger legacy" },
{ "sun.security.krb5.internal.ktab", "tiger legacy" },
{ "sun.security.krb5.internal.rcache", "tiger legacy" },
{ "sun.security.krb5.internal.tools", "tiger legacy" },
{ "sun.security.krb5.internal.util", "tiger legacy" },
{ "sun.security.pkcs", "tiger legacy" },
{ "sun.security.provider", "tiger legacy" },
{ "sun.security.provider.certpath", "tiger legacy" },
{ "sun.security.rsa", "tiger legacy" },
{ "sun.security.timestamp", "tiger legacy" },
{ "sun.security.tools", "tiger legacy" },
{ "sun.security.util", "tiger legacy" },
{ "sun.security.validator", "tiger legacy" },
{ "sun.security.x509", "tiger legacy" },
{ "sun.swing", "tiger legacy" },
{ "sun.swing.plaf.synth", "tiger legacy" },
{ "sun.text", "tiger legacy" },
{ "sun.text.resources", "tiger legacy" },
{ "sun.tools.hprof", "tiger legacy" },
{ "sun.tools.jar", "tiger legacy" },
{ "sun.tools.jar.resources", "tiger legacy" },
{ "sun.util", "tiger legacy" },
{ "sun.util.calendar", "tiger legacy" },
{ "sun.util.locale", "tiger legacy" },
{ "sun.util.logging.resources", "tiger legacy" },
{ "sunw.io", "tiger legacy" },
{ "sunw.util", "tiger legacy" },
};
}
}

11
jdkSrc/jdk8/com/sun/tools/javac/resources/version.java Normal file
View File

@@ -0,0 +1,11 @@
package com.sun.tools.javac.resources;
public final class version extends java.util.ListResourceBundle {
protected final Object[][] getContents() {
return new Object[][] {
{ "full", "1.8.0_462-b08" },
{ "jdk", "1.8.0_462" },
{ "release", "1.8.0_462" },
};
}
}