compiler.properties

是一个用jsp做前台

compiler.err.type.doesnt.take.params=type {0} does not take parameters
compiler.misc.token.identifier=<identifier>
compiler.misc.verbose.retro.with=\tretrofitting {0} with {1}
compiler.err.orphaned=orphaned {0}
compiler.err.abstract.cant.be.accessed.directly=abstract {0} {1} cannot be accessed directly
compiler.warn.warning=warning\: 
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.err.no.intf.expected.here=no interface expected here
compiler.misc.kindname.interface=interface
compiler.err.else.without.if=''else'' without ''if''
compiler.err.not.within.bounds.explain=type parameter {0} is not within its bound; {1}
compiler.err.report.access={0} has {1} access in {2}
compiler.misc.token.bad-symbol=<bad symbol>
compiler.misc.kindname.package=package
compiler.misc.bad.class.signature=bad class signature\: {0}
compiler.err.class.public.should.be.in.file=class {0} is public, should be declared in a file named {0}.java
compiler.err.not.within.bounds=type parameter {0} is not within its bound
compiler.err.already.defined.this.unit={0} is already defined in this compilation unit
compiler.err.try.without.catch.or.finally=''try'' without ''catch'' or ''finally''
compiler.err.cont.outside.loop=continue outside of loop
compiler.err.mod.not.allowed.here=modifier {0} not allowed here
compiler.note.unchecked.filename={0} uses unchecked operations.
compiler.err.repeated.interface=repeated interface
compiler.note.note=Note\: 
compiler.err.expected={0} expected
compiler.err.duplicate.default.label=duplicate default label
compiler.misc.ccf.unrecognized.attribute=unrecognized attribute\: {0}
compiler.misc.anonymous.class=<anonymous {0}>
compiler.misc.base.membership=all your base class are belong to us
compiler.err.anon.class.impl.intf.no.qual.for.new=anonymous class implements interface; cannot have qualifier for new
compiler.err.left-paren.or.left-square-bracket.expected=''('' or ''['' expected
compiler.note.deprecated.filename={0} uses or overrides a deprecated API.
compiler.warn.has.been.deprecated={0} in {1} has been deprecated
compiler.err.duplicate.case.label=duplicate case label
compiler.err.assert.as.identifier=as of release 1.4, 'assert' is a keyword, and may not be used as an identifier
compiler.err.qualified.new.of.static.class=qualified new of static class
compiler.err.not.def.public.class.intf.cant.access={0} in {1} is not defined in a public class or interface; cannot be accessed from outside package
compiler.err.illegal.start.of.expr=illegal start of expression
compiler.err.intf.expected.here=interface expected here
compiler.err.abstract.meth.cant.have.body=abstract methods cannot have a body
compiler.warn.unchecked.generic.array.creation=unchecked generic array creation
compiler.err.void.not.allowed.here=''void'' type not allowed here
compiler.misc.token.long-integer=<long integer>
compiler.err.error=error\: 
compiler.note.deprecated.recompile=Recompile with -deprecation for details.
compiler.err.cant.access=cannot access {0}\n{1}
compiler.err.cant.deref={0} cannot be dereferenced
compiler.err.dot.class.expected=''.class'' expected
compiler.misc.bad.signature=bad signature\: {0}
compiler.err.case.default.or.right-brace.expected=''case'', ''default'' or ''}'' expected
compiler.misc.token.character=<character>
compiler.warn.unchecked.cast.to.type=unchecked cast to type {0}
compiler.err.should.be.abstract.doesnt.def={0} should be declared abstract; it does not define {1} in {2}
compiler.err.illegal.line.end.in.char.lit=illegal line end in character literal
compiler.err.illegal.initializer.for.type=illegal initializer for {0}
compiler.err.cant.resolve.location=cannot resolve symbol\nsymbol  \: {0} {1} {2}\nlocation\: {3} {4}
compiler.err.intf.incompatible.diff.ret=interfaces {0} and {1} are incompatible; both define {2}, but with different return type
compiler.err.type.var.cant.be.deref=type variables cannot be dereferenced
compiler.misc.kindname.type.variable=bound of type variable
compiler.err.call.must.be.first.stmt.in.ctor=call to {0} must be first statement in constructor
compiler.misc.undecl.type.var=undeclared type variable\: {0}
compiler.err.override.static={0}; {1} and {2} are static
compiler.misc.verbose.checking.attribution=[checking {0}]
compiler.err.missing.ret.val=missing return value
compiler.warn.unchecked.assign=unchecked assignment\: {0} to {1}
compiler.err.illegal.esc.char=illegal escape character
compiler.err.duplicate.class=duplicate class\: {0}
compiler.err.illegal.qual.not.icls=illegal qualifier; {0} is not an inner class
compiler.misc.resume.abort=R)esume, A)bort>
compiler.misc.count.error={0} error
compiler.err.pkg.clashes.with.class.of.same.name=package {0} clashes with class of same name
compiler.misc.kindname.method=method
compiler.err.not.stmt=not a statement
compiler.err.cant.inherit.diff.arg={0} cannot be inherited with different arguments\: <{1}> and <{2}>
compiler.err.non-static.cant.be.ref=non-static {0} {1} cannot be referenced from a static context
compiler.err.signature.doesnt.match.intf=signature does not match {0}; incompatible interfaces
compiler.note.unchecked.recompile=Recompile with -warnunchecked for details.
compiler.misc.token.integer=<integer>
compiler.err.unsupported.encoding=unsupported encoding\: {0}
compiler.err.cant.read.file=cannot read\: {0}
compiler.misc.type.req.class.array=class or array
compiler.err.unclosed.str.lit=unclosed string literal
compiler.err.cant.assign.val.to.final.var=cannot assign a value to final variable {0}
compiler.err.array.req.but.found=array required, but {0} found
compiler.err.name.clash.same.erasure=name clash\: {0} and {1} have the same erasure
compiler.err.recursive.ctor.invocation=recursive constructor invocation
compiler.err.cyclic.inheritance=cyclic inheritance involving {0}
compiler.err.abstract.cant.be.instantiated={0} is abstract; cannot be instantiated
compiler.warn.assert.as.identifier=as of release 1.4, 'assert' is a keyword, and may not be used as an identifier
compiler.note.deprecated.plural=Some input files use or override a deprecated API.
compiler.err.undef.label=undefined label\: {0}
compiler.misc.override.incompatible.ret={0}; attempting to use incompatible return type
compiler.err.type.found.req=unexpected type\nfound   \: {0}\nrequired\: {1}
compiler.err.malformed.fp.lit=malformed floating point literal
compiler.err.anon.class.impl.intf.no.args=anonymous class implements interface; cannot have arguments
compiler.err.override.meth.doesnt.throw={0}; overridden method does not throw {1}
compiler.err.signature.doesnt.match.supertype=signature does not match {0}; incompatible supertype
compiler.misc.kindname.class=class
compiler.err.unreported.exception.need.to.catch.or.throw=unreported exception {0}; must be caught or declared to be thrown
compiler.err.error.reading.file=error reading {0}; {1}
compiler.err.improperly.formed.type.param.missing=improperly formed type, some parameters are missing
compiler.misc.fatal.err.cant.locate.meth=Fatal Error\: Unable to locate method {0}
compiler.misc.count.warn.plural={0} warnings
compiler.err.fp.number.too.small=floating point number too small
compiler.misc.file.doesnt.contain.class=file does not contain class {0}
compiler.err.const.expr.req=constant expression required
compiler.err.source.cant.overwrite.input.file=error writing source; cannot overwrite input file {0}
compiler.err.unexpected.type=unexpected type\nrequired\: {0}\nfound   \: {1}
compiler.misc.ccf.found.later.version=class file has later version than expected\: {0}
compiler.err.icls.cant.have.static.decl=inner classes cannot have static declarations
compiler.warn.unchecked.call.mbr.of.raw.type=unchecked call to {0} as a member of the raw type {1}
compiler.err.undetermined.type=type parameters of {0} cannot be determined
compiler.err.no.match.entry={0} has no match in entry in {1}; required {2}
compiler.err.already.defined.single.import={0} is already defined in a single-type import
compiler.err.name.reserved.for.internal.use={0} is reserved for internal use
compiler.err.class.cant.write=error while writing {0}\: {1}
compiler.misc.fatal.err.no.java.lang=Fatal Error\: Unable to locate package java.lang in classpath or bootclasspath
compiler.misc.incompatible.types=incompatible types
compiler.err.not.encl.class=not an enclosing class\: {0}
compiler.err.missing.ret.stmt=missing return statement
compiler.err.io.exception=error reading source file\: {0}
compiler.err.cant.ret.val.from.meth.decl.void=cannot return a value from method whose result type is void
compiler.misc.type.req.class=class
compiler.misc.unicode.str.not.supported=unicode string in class file not supported
compiler.err.catch.without.try=''catch'' without ''try''
compiler.err.clash.with.pkg.of.same.name={0} clashes with package of same name
compiler.err.wrong.number.type.args=wrong number of type arguments; required {0}
compiler.err.var.might.not.have.been.initialized=variable {0} might not have been initialized
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.cant.inherit.from.final=cannot inherit from final {0}
compiler.err.illegal.forward.ref=illegal forward reference
compiler.err.operator.cant.be.applied=operator {0} cannot be applied to {1}
compiler.misc.clashes.with={0} in {1} clashes with {2} in {3}
compiler.misc.wrong.version=class file has wrong version {0}.{1}, should be {2}.{3}
compiler.err.except.already.caught=exception {0} has already been caught
compiler.misc.verbose.wrote.file=[wrote {0}]
compiler.err.unclosed.comment=unclosed comment
compiler.err.synthetic.name.conflict=the symbol {0} conflicts with a compiler-synthesized symbol in {1}
compiler.note.unchecked.plural=Some input files use unchecked operations.
compiler.misc.bad.const.pool.tag=bad constant pool tag\: {0}
compiler.err.fp.number.too.large=floating point number too large
compiler.err.ref.ambiguous=reference to {0} is ambiguous, both {1} {2} in {3} and {4} {5} in {6} match
compiler.misc.verbose.parsing.done=[parsing completed {0}ms]
compiler.err.var.might.be.assigned.in.loop=variable {0} might be assigned in loop
compiler.warn.unchecked.assign.to.var=unchecked assignment to variable {0} of raw type class {1}
compiler.err.initializer.must.be.able.to.complete.normally=initializer must be able to complete normally
compiler.err.type.var.more.than.once=type variable {0} occurs more than once in result type of {1}; cannot be left uninstantiated
compiler.misc.token.string=<string>
compiler.misc.token.double=<double>
compiler.err.override.weaker.access={0}; attempting to assign weaker access privileges; was {1}
compiler.err.doesnt.exist=package {0} does not exist
compiler.err.var.might.already.be.assigned=variable {0} might already have been assigned to
compiler.err.except.never.thrown.in.try=exception {0} is never thrown in body of corresponding try statement
compiler.err.cant.resolve=cannot resolve symbol\nsymbol\: {0} {1} {2}
compiler.err.already.defined={0} is already defined in {1}
compiler.misc.kindname.default=identifier({0})
compiler.err.unclosed.char.lit=unclosed character literal
compiler.misc.count.error.plural={0} errors
compiler.misc.kindname.variable=variable
compiler.err.missing.meth.body.or.decl.abstract=missing method body, or declare abstract
compiler.err.empty.char.lit=empty character literal
compiler.err.incomparable.types=incomparable types\: {0} and {1}
compiler.err.name.clash.same.erasure.no.override=name clash\: {0} in {1} and {2} in {3} have the same erasure, yet none overrides the other
compiler.err.repeated.modifier=repeated modifier
compiler.err.ret.outside.meth=return outside method
compiler.err.cant.ref.before.ctor.called=cannot reference {0} before supertype constructor has been called
compiler.err.int.number.too.large=integer number too large\: {0}
compiler.misc.cant.implement={0} in {1} cannot implement {2} in {3}
compiler.err.internal.error.cant.instantiate=internal error; cannot instantiate {0} at {1} to ({2})
compiler.err.illegal.char=illegal character\: \\{0}
compiler.misc.verbose.loading=[loading {0}]
compiler.misc.kindname.constructor=constructor
compiler.err.not.loop.label=not a loop label\: {0}
compiler.misc.token.end-of-input=<end of input>
compiler.err.cant.apply.symbol={0} in {1} cannot be applied to ({2})
compiler.misc.bad.const.pool.tag.at=bad constant pool tag\: {0} at {1}
compiler.misc.type.req.ref=reference
compiler.misc.too.many.constants=too many constants
compiler.err.not.def.public.cant.access={0} is not public in {1}; cannot be accessed from outside package
compiler.err.invalid.hex.number=hexadecimal numbers must contain at least one hexadecimal digit
compiler.err.unreachable.stmt=unreachable statement
compiler.misc.verbose.total=[total {0}ms]
compiler.err.no.encl.instance.of.type.in.scope=no enclosing instance of type {0} is in scope
compiler.err.illegal.combination.of.modifiers=illegal combination of modifiers\: {0} and {1}
compiler.err.invalid.meth.decl.ret.type.req=invalid method declaration; return type required
compiler.misc.possible.loss.of.precision=possible loss of precision
compiler.misc.dot.class.not.found=file {0}.class not found
compiler.misc.verbose.retro=[retrofitting {0}]
compiler.misc.illegal.start.of.class.file=illegal start of class file
compiler.err.finally.without.try=''finally'' without ''try''
compiler.misc.class.file.wrong.class=class file contains wrong class\: {0}
compiler.err.prob.found.req={0}\nfound   \: {1}\nrequired\: {2}
compiler.err.native.meth.cant.have.body=native methods cannot have a body
compiler.err.class.or.intf.expected=''class'' or ''interface'' expected
compiler.misc.token.float=<float>
compiler.err.label.already.in.use=label {0} already in use
compiler.err.intf.meth.cant.have.body=interface methods cannot have body
compiler.misc.count.warn={0} warning
compiler.warn.possible.fall-through.into.case=possible fall-through into case
compiler.err.local.var.accessed.from.icls.needs.final=local variable {0} is accessed from within inner class; needs to be declared final
compiler.warn.unchecked.meth.invocation.applied=unchecked method invocation\: {0} in {1} is applied to ({2})
compiler.misc.source.unavailable=(source unavailable)
compiler.err.illegal.unicode.esc=illegal unicode escape
compiler.misc.verbose.parsing.started=[parsing started {0}]
compiler.err.illegal.start.of.type=illegal start of type
compiler.err.code.too.large.for.try.stmt=code too large for try statement
compiler.misc.cant.override={0} in {1} cannot override {2} in {3}
compiler.err.override.meth={0}; overridden method is {1}
compiler.err.cant.select.static.class.from.param.type=cannot select a static class from a parameterized type
compiler.misc.kindname.value=value
compiler.err.break.outside.switch.loop=break outside switch or loop
compiler.misc.verbose.retro.with.list=\tretrofitting {0} with type parameters {1}, supertype {2}, interfaces {3}
compiler.misc.unable.to.access.file=unable to access file\: {0}
compiler.misc.inconvertible.types=inconvertible types