#
# Copyright (c) 1994-1997 by Sun Microsystems Inc.
#
# @(#)javac.properties	1.15 97/03/10
#

javac.err.internal=\
	Error interno.  
javac.err.eof.in.comment=\
	Comentario no terminado al final de la entrada.
javac.err.eof.in.string=\
	Cadena no terminada al final de la entrada. 
javac.err.newline.in.string=\
	Cadena no terminada al final de la línea.
javac.err.invalid.char.constant=\
	Constante de carácter no válida.
javac.err.unbalanced.paren=\
	Paréntesis desequilibrado.
javac.err.invalid.escape.char=\
	Carácter de escape no válido.
javac.err.invalid.octal.number=\
	Carácter no valido en el número octal.
javac.err.invalid.number=\
	Carácter no válido en el número.
javac.err.funny.char=\
	Carácter no válido en la entrada.
javac.err.float.format=\
	Formato de coma flotante no válido.
javac.err.overflow=\
	Desbordamiento numérico.
javac.err.underflow=\
	Desbordamiento numérico inferior.
javac.err.token.expected=\
	Se espera ''{0}''.
javac.err.statement.expected=\
	Se espera una instrucción.
javac.err.type.expected=\
	Se espera un tipo.
javac.err.identifier.expected=\
	Se espera un identificador.
javac.err.class.expected=\
	Se espera la palabra clave ''class'' o ''interface''.
javac.err.toplevel.expected=\
	Se espera una declaración de clase o interfaz.
javac.err.missing.term=\
	Falta término.
javac.err.else.without.if=\
	''else'' sin ''if''.
javac.err.catch.without.try=\
	''catch'' sin ''try''.
javac.err.finally.without.try=\
	''finally'' sin ''try''.
javac.err.try.without.catch.finally=\
	''try'' sin ''catch'' o ''finally''.
javac.err.case.without.switch=\
	''case'' fuera de la instrucción de conmutación.
javac.err.default.without.switch=\
	''default'' fuera de la instrucción de conmutación.
javac.err.io.exception=\
	Error de E/S en {0}.
javac.err.array.index.required=\
	Se requiere un índice de matriz.
javac.err.not.array=\
	[] sólo se aplica a matrices. No puede aplicarse a {0}.
javac.err.array.dim.in.decl=\
	No es posible especificar una dimensión de matriz en una declaración.
javac.err.array.dim.in.type=\
	No es posible especificar una dimensión de matriz en una expresión de tipo.
javac.err.invalid.array.expr=\
	Las constantes de matriz sólo pueden utilizarse en inicializadores.
javac.err.invalid.array.init=\
	Inicializador no válido para el tipo {0}.
javac.err.invalid.lhs.assignment=\
	Asignación no válida en el lado izquierdo.
javac.err.invalid.args=\
	Argumentos no válidos para {0}.
javac.err.invalid.cast=\
	Conversión no válida de {0} a {1}.
javac.err.invalid.instanceof=\
	{0} no puede ser un caso de {1}.
javac.err.invalid.type.expr=\
	Expresión de tipo no válida.
javac.err.anonymous.extends=\
	Sólo las clases nombradas puede tener cláusulas ''extends'' o ''implements''.
javac.err.invalid.field.reference=\
	Intento de hacer referencia al campo {0} en un {1}.
javac.err.no.such.field=\
	No se ha definido ninguna variable {0} en {1}.
javac.err.no.field.access=\
	No se puede tener acceso a la variable {0} de {1} desde {2}.
javac.err.no.type.access=\
	No se puede tener acceso al tipo interno {0} de {1} desde {2}.
javac.err.no.static.field.access=\
	No es posible hacer una referencia estática a una variable no estática {0} en {1}.
javac.err.inner.static.ref=\
	No es posible hacer una referencia estática a una clase interna {0}.
javac.err.ambig.field=\
	La referencia a {0} es ambigua. Está definida en {1} y {2}.
javac.err.invalid.field=\
	Intento de hacer referencia al método {0} de {1} como una variable de caso.
javac.err.assign.to.final=\
	No es posible asignar un valor a una variable final: {0}
javac.err.assign.to.blank.final=\
	No es posible asignar un segundo valor a una variable final en blanco: {0}
javac.err.assign.to.blank.final.in.loop=\
	Intento de asignar una variable {0} final en blanco en un bucle. La inicialización sólo debe producirse una vez.
javac.err.assign.to.uplevel=\
	Intento de asignar una variable {0} con un método distinto. En los bloques que se cierran, sólo están disponibles las variables locales finales.
javac.err.invalid.uplevel=\
	Intento de utilizar una variable {0} que no es final en un método distinto. En los bloques que se cierran, sólo están disponibles las variables locales finales.
javac.err.uplevel.private=\
	El acceso a través de los ámbitos al miembro privado {0} de {1} no está implementado. La referencia será satisfactoria si se le otorga ámbito de paquetes al miembro.
javac.err.undef.var=\
	Variable no definida: {0}
javac.err.undef.var.super=\
	Variable no definida: {0}. La palabra clave "super" sólo puede utilizarse para el acceso de los miembros y la invocación de los constructores.
javac.err.undef.var.or.package=\
	Variable o nombre de paquete no definidos: {0}
javac.err.undef.var.class.or.package=\
	Variable, clase o nombre de paquete no definidos: {0}
javac.err.undef.var.or.class=\
	Variable o nombre de clase no definidos: {0}
javac.err.var.not.initialized=\
	La variable {0} no se ha inicializado.
javac.err.final.var.not.initialized=\
	La variable final en blanco ''{0}'' no se ha inicializado. Debe asignársele un valor en un inicializador o en cada uno de los constructores.
javac.err.access.inst.before.super=\
	No se puede hacer referencia a {0} antes de llamar al constructor de la superclase.
javac.err.ambig.class=\
	Clase ambigua: {0} y {1}
javac.err.invalid.arg=\
	Argumento no válido para {0}.
javac.err.invalid.arg.type=\
	Tipo de argumento {0} no válido para {1}.
javac.err.invalid.length=\
	''length'' aplicado a {0}, que no es una matriz.
javac.err.invalid.constr.invoke=\
	Sólo los constructores pueden invocar a otros constructores.
javac.err.constr.invoke.not.first=\
	La invocación de los constructores debe ser el primer paso en un método.
javac.err.invalid.method.invoke=\
	No es posible invocar un método en un {0}.
javac.err.undef.meth=\
	El método {0} no se ha encontrado en {1}.
javac.err.no.meth.access=\
	No se puede acceder al método {0} de {1} desde {2}.
#warning:
javac.err.no.override.access=\
	Nota: el método {0} de {1} no ignora el método correspondiente de {2}, que es privado para un paquete distinto.
javac.err.no.static.meth.access=\
	No es posible hacer una referencia estática al método {0} de {1}.
javac.err.invalid.protected.method.use=\
	No es posible tener acceso al método protegido {0} de {1}. {2} no es una subclase de la clase actual.
javac.err.invalid.protected.field.use=\
	No es posible tener acceso al campo protegido {0} de {1}. {2} no es una subclase de la clase actual.
javac.err.invalid.protected.type.use=\
	No es posible tener acceso al tipo interno protegido {0} de {1}. {2} no es una subclase de la clase actual.
javac.err.invalid.method=\
	Haga referencia a la variable {0} de {1} como si se tratara de un método.
javac.err.invalid.var=\
	Haga referencia al método {0} de {1} como si se tratara de una variable.
#all deprecation-related messages are warnings:
javac.err.class.is.deprecated=\
	Nota: {0} se ha desestimado.
javac.err.meth.is.deprecated=\
	Nota: el método {0} de {1} se ha desestimado.
javac.err.override.is.deprecated=\
	Nota: el método {0} de {1} se ha desestimado y {2} (que no se ha desestimado) lo ignora.
javac.err.constr.is.deprecated=\
	Nota: el constructor {0} se ha desestimado.
javac.err.field.is.deprecated=\
	Nota: la variable {0} de {1} se ha desestimado.
javac.err.note.deprecations=\
	Not: {0} archivos utilizan las API desestimadas. Consulte la documentación para obtener una mejor alternativa para cada caso.
javac.err.note.1deprecation=\
	Nota: {0} utiliza una API desestimada. Consulte la documentación para obtener una mejor alternativa.
javac.err.note.deprecations.silent=\
	Nota: {0} archivos utilizan las API desestimadas. Recompile con "-deprecation" para obtener información detallada.
javac.err.note.1deprecation.silent=\
	Nota: {0} utiliza una API desestimada. Recompile con "-deprecation" para obtener información detallada.
javac.err.invalid.array.dim=\
	Dimensión de matriz no válida.
javac.err.ambig.constr=\
	El constructor es ambiguo: {0}, {1}
javac.err.explicit.cast.needed=\
	Tipo incompatible para {0}. Se requiere una conversión explícita para convertir {1} en {2}.
javac.err.incompatible.type=\
	Tipo incompatible para {0}. No es posible convertir {1} en {2}.
javac.err.invalid.term=\
	Término no válido.
javac.err.private.intf.method=\
	{0} debe ignorar {1} con un método público para implementar {2}.
javac.err.abstract.class=\
	{0} debe declararse abstracto. No define {1} de {2}.
javac.err.abstract.class.not.final=\
	{0} debe declararse abstracto y no final. No define {1} de {2}.
javac.err.new.intf=\
	{0} es una interfaz. No puede convertirse a caso.
javac.err.invoke.abstract=\
	No es posible invocar directamente el método abstracto {0} de {1}.
javac.err.unmatched.meth=\
	No se ha encontrado ningún método que coincida con {0} en {1}.
javac.err.unmatched.constr=\
	No se ha encontrado ningún constructor que coincida con {0} en {1}.
javac.err.wrong.number.args=\
	Número erróneo de argumentos en {0}.
javac.err.wrong.number.args=\
	Número erróneo de argumentos en {0}.
javac.err.forward.ref=\
	No es posible hacer más referencia a {0} de {1}.
javac.err.array.dim.missing=\
	Falta la dimensión de la matriz.
javac.err.new.abstract=\
	{0} es una clase abstracta. No puede convertirse a caso.
javac.err.label.not.found=\
	No se ha encontrado ninguna definición de etiqueta para {0}.
javac.err.invalid.break=\
	''break'' debe encontrarse en un bucle o en un conmutador.
javac.err.invalid.continue=\
	''continue'' debe encontrarse en un bucle.
javac.err.branch.to.uplevel=\
	las palabras clave ''break'' o ''continue'' deben transferir el control dentro de un mismo método.
javac.err.invalid.decl=\
	Declaración no válida.
javac.err.return.with.value=\
	''return'' con valor de {0}.
javac.err.return.without.value=\
	''return'' sin valor de {0}.
javac.err.return.inside.static.initializer=\
	''return'' dentro de un inicializador estático.
javac.err.invalid.label=\
	Etiqueta no válida.
javac.err.return.required.at.end=\
	Se requiere un retorno al final de {0}.
javac.err.duplicate.label=\
	Etiqueta de caso duplicada: {0}
javac.err.switch.overflow=\
	Etiqueta de caso {0} demasiado grande para ''switch'' de {1}
javac.err.const.expr.required=\
	Se requiere una expresión de constante.
javac.err.duplicate.default=\
	Etiqueta ''default'' duplicada.
javac.err.not.supported=\
	No se da soporte a ''{0}''.
javac.err.return.with.value.constr=\
	''return'' con valor de constructor: {0}
javac.err.package.repeated=\
	Sólo se permite una declaración de paquetes.
javac.err.class.multidef=\
	La clase {0} ya está definida en {1}.
javac.err.class.multidef.import=\
	El nombre de clase {0} entra en conflicto con la clase importada {1}.
javac.err.final.meth.override=\
	Los métodos finales no pueden ignorarse. El método {0} es final en {1}.
javac.err.redef.return.type=\
	El método se ha redefinido con un tipo de retorno diferente: {0} era {1}
javac.err.override.static.meth=\
	Los métodos estáticos no pueden ignorarse. El método {0} es estático en {1}.
javac.err.override.instance.method.static=\
        Un método estático no puede ignorar un método de clase.\nEl método {0} es un método de clase en {1}.
javac.err.override.public=\
	No se pueden ignorar los métodos para que sean más privados. El método {0} es público en {1}.
javac.err.override.protected=\
	No se pueden ignorar los métodos para que sean más privados. El método {0} está protegido en {1}.
javac.err.override.private=\
	No se pueden ignorar los métodos para que sean más privados. El método {0} no es privado en {1}.
javac.err.intf.constructor=\
	Las interfaces no pueden tener constructores.
javac.err.constr.modifier=\
	Los constructores no pueden ser nativos, abstractos, estáticos, sincronizados ni finales: {0}
javac.err.intf.initializer=\
	Las interfaces no pueden tener inicializadores estáticos.
javac.err.intf.modifier.method=\
	Los métodos de interfaz no pueden ser nativos, estáticos, sincronizados, finales, privados ni protegidos: {0}
javac.err.intf.modifier.field=\
	Los campos de interfaz no pueden ser privados ni protegidos: {0}
javac.err.transient.meth=\
	El método {0} no puede ser temporal. Sólo las variables pueden ser temporales.
javac.err.volatile.meth=\
	El método {0} no puede ser volátil. Sólo las variables pueden ser volátiles.
javac.err.static.modifier=\
	Los métodos estáticos no pueden ser abstractos: {0}
javac.err.invalid.meth.body=\
	Los métodos abstractos y nativos no pueden tener un cuerpo: {0}
javac.err.var.modifier=\
	Las variables no pueden ser sincronizadas, abstractas ni nativas: {0}
javac.err.inner.modifier=\
	Las clases internas no pueden ser volátiles, temporales, nativas ni sincronizadas: {0}
javac.err.transient.modifier=\
	Las variables temporales no pueden ser miembros de interfaces: {0}
javac.err.volatile.modifier=\
	Las variables volátiles no pueden ser finales ni miembros de interfaces: {0}
javac.err.initializer.needed=\
	Esta variable final debe inicializarse: {0}
javac.err.meth.multidef=\
	Declaración de método duplicada: {0}
javac.err.meth.redef.rettype=\
	Los métodos no pueden redefinirse con otro tipo de retorno: {0} era {1}
javac.err.var.multidef=\
	Declaración de variable duplicada: {0} era {1}
javac.err.inner.class.multidef=\
	Declaración de clase interna duplicada: {0} ya está definida en este ámbito.
javac.err.intf.super.class=\
	La superclase de {0} no puede ser una interfaz: {1}
javac.err.cant.access.class=\
	No es posible tener acceso a {0}. Sólo se puede tener acceso a las clases públicas y las interfaces de otros paquetes.
javac.err.repeated.modifier=\
	Modificador repetido.
javac.err.inconsistent.modifier=\
	Declaración de miembro no coherente. Sólo puede especificarse uno público, privado o protegido como máximo.
javac.err.super.is.final=\
	Las clases finales no pueden dividirse en subclases: {0}
javac.err.super.is.intf=\
	Las interfaces no pueden dividirse en subclases: {0}
javac.err.cyclic.super=\
	Herencia de clase cíclica.
javac.err.super.is.inner=\
	Herencia de clase cíclica: un subclase no puede incluir una superclase.
javac.err.cyclic.intf=\
	Herencia de interfaz cíclica.
javac.err.cyclic.scoping=\
	Ámbito o herencia de clase cíclica.
javac.err.not.intf=\
	{0} debe ser una interfaz.
javac.err.final.intf=\
	Las interfaces no pueden ser finales: {0}
javac.err.intf.impl.intf=\
	Una interfaz no puede implementar nada; sólo puede ampliar otras interfaces.
javac.err.multiple.inherit=\
	No se da soporte a la herencia múltiple.
javac.err.intf.repeated=\
	Interfaz {0} repetida.
javac.err.class.format=\
	Formato de archivo de clase no válido: {0}, {1}
javac.err.no.meth.body=\
	El método {0} requiere un cuerpo de método. De lo contrario, declárelo abstracto.
javac.err.no.constructor.body=\
	El constructor {0} requiere un cuerpo de método.
javac.err.void.inst.var=\
	Las variables de caso no pueden ser invalidadas: {0}
javac.err.invalid.method.decl=\
	Declaración de método no válida; se requiere un tipo de retorno.
javac.err.invalid.method.decl.name=\
	Declaración de método no válida; se requiere un nombre de método.
javac.err.invalid.method.decl.qual=\
	Nombre de constructor calificado no válido.
javac.err.super.not.found=\
	No se ha encontrado la superclase {0} de {1}.
javac.err.intf.not.found=\
	No se ha encontrado la interfaz {0} de {1}.
javac.err.final.abstract=\
        La clase {0} no puede declararse abstracta y final al mismo tiempo.
javac.err.void.argument=\
	El argumento no puede tener el tipo invalidado: {0}
javac.err.invalid.expr=\
	Instrucción de expresión no válida.
javac.err.catch.not.reached=\
	captura no alcanzada.
javac.err.stat.not.reached=\
	Instrucción no alcanzada.
javac.err.arithmetic.exception=\
	Excepción aritmética.
javac.err.generic=\
	{0}
javac.err.public.class.file=\
	{0} pública debe definirse en un archivo llamado "{1}".
javac.err.package.class.file=\
	{0} está definida en {1}. Puesto que se utiliza fuera del archivo origen, debe definirse en un archivo llamado "{2}".
javac.err.lose.precision=\
	Posible pérdida de precisión. Utilice una conversión explícita para convertir {0} en {1}.
javac.err.duplicate.argument=\
	La variable ''{0}'' se utiliza dos veces en la lista de argumentos de este método.
javac.err.local.redefined=\
	La variable ''{0}'' ya está definida en este método.
javac.err.local.class.redefined=\
	La clase local ''{0}'' ya está definida en este método.
javac.err.inner.redefined=\
	El nombre de clase ''{0}'' ya está definido en este ámbito. Es posible que una clase interna no tenga el mismo nombre simple que cualquiera de las clases que incluya.
javac.err.inherited.hides.field=\
	La variable ''{0}'' está heredada en {1} y oculta una variable con el mismo nombre en {2}. Debe utilizarse un calificador ''this'' explícito para seleccionar el caso que desee.
javac.err.inherited.hides.local=\
	La variable ''{0}'' está heredada en {1} y oculta una variable local con el mismo nombre. Debe utilizarse un calificador ''this'' explícito para seleccionar la variable o la variable debe renombrarse.
javac.err.inherited.hides.method=\
	El método ''{0}'' está heredado en {1} y oculta un método con el mismo nombre en {2}. Debe utilizarse un calificador ''this'' explícito para seleccionar el caso que desee.
javac.err.inherited.hides.type=\
	El tipo ''{0}'' está heredado en {1} y oculta un tipo con el mismo nombre en un ámbito de inclusión. Debe utilizarse un prefijo de calificador explícito para denominar este tipo.
javac.err.private.class=\
	El tipo {0} no puede ser privado. Los miembros del paquete siempre están accesibles dentro del paquete actual.
javac.err.static.class=\
	El tipo {0} no puede declararse estático. Ya se trata de un tipo de nivel superior, puesto que es un miembro de un paquete.
javac.err.protected.class=\
	El tipo {0} no puede convertirse en protegido. Los miembros del paquete pueden ser públicos o locales para el paquete actual.
javac.err.recursive.constr=\
	Invocación de contructor recursiva: {0}.
javac.err.wrong.class=\
	El archivo {0} no incluye {1} como se esperaba, sino {2}. Elimine el archivo o compruebe si aparece en el subdirectorio correcto de la ruta de acceso de la clase.
javac.err.wrong.source=\
	El archivo {0} no incluye {1} como se esperaba. Ajuste la ruta de acceso de la clase para que el archivo no aparezca en {2}.
javac.err.class.not.found=\
	La clase {0} no se ha encontrado en {1}.
javac.err.package.not.found=\
	El paquete {0} no se ha encontrado en {1}.
javac.err.illegal.mangled.name=\
	Nombre no válido {0} para {1}.
javac.err.class.and.package=\
	Nombre ambiguo: {0} es una clase y un paquete al mismo tiempo.
javac.err.invalid.throws=\
	Excepción {0} no válida en cláusula de generación. La excepción debe ser una subclase de una excepción generada por {1} desde {2}.
javac.err.throws.not.throwable=\
	{0} en una cláusula de generación debe ser una subclase de la clase java.lang.Throwable.
javac.err.throw.not.throwable=\
	No es posible generar {0}; debe ser una subclase de la clase java.lang.Throwable.
javac.err.catch.not.throwable=\
	No es posible interferir {0}; debe ser una subclase de la clase java.lang.Throwable.
javac.err.initializer.exception=\
	La excepción {0} no puede generarse en el inicializador.
javac.err.cant.read=\
	No es posible leer: {0}
javac.err.cant.write=\
	No es posible escribir: {0}
javac.err.fatal.error=\
	Se ha producido un error en el compilador; envíe un archivo de informe de errores (http://java.sun.com/cgi-bin/bugreport.cgi).
javac.err.fatal.exception=\
	Se ha producido una excepción en el compilador; envíe un archivo de informe de errores (http://java.sun.com/cgi-bin/bugreport.cgi).
javac.err.no.inner.classes=\
	Se ha inhabilitado el soporte para las clases internas.
javac.err.uncaught.exception=\
	La excepción {0} debe interferirse o bien debe declararse en la cláusula de generación de este método.
javac.err.catch.not.thrown=\
	La excepción {0} nunca se genera en el cuerpo de la instrucción try correspondiente.
#warning:
javac.err.array.clone.supported=\
	Nota: La clonación de una matriz no genera excepciones comprobadas y, por lo tanto, no requiere ninguna cláusula catch. Elimine las cláusulas catch que no se utilicen o, si desea mantener la compatibilidad con compiladores de versiones anteriores, inserte una generación artificial como se describe a continuación:  si (false) genere una nueva CloneNotSupportedException();
javac.err.no.outer.arg=\
	No hay ningún caso de inclusión de {0} en el ámbito; \
	debe proporcionarse uno explícito al crear {1}, \
	como en "outer. new Inner()" o "outer. super()".
javac.err.no.default.outer.arg=\
	No hay ningún caso de inclusión de {0} en el ámbito; \
	no es posible crear un constructor predeterminado para {1}.
javac.err.no.outer.base=\
	No hay ningún caso de inclusión de {0} en el ámbito; \
	debe proporcionarse uno explícito al tener acceso a {1}, \
	como en "outer.member".
javac.err.static.inner.class=\
	El tipo {0} no puede ser estático. Los miembros estáticos sólo pueden aparecer en interfaces y clases de nivel superior.
javac.err.static.inner.field=\
	La variable {0} no puede ser estática en {1}. Sólo los miembros de las interfaces y de las clases de nivel superior pueden ser estáticos.
javac.err.static.inner.method=\
	El método {0} no puede ser estático en {1}. Sólo los miembros de las interfaces y de las clases de nivel superior pueden ser estáticos.
javac.err.too.many.errors=\
	Demasiados errores. (El límite de errores que pueden comunicarse es {0}.)
#
benv.parsed_in=[parsed {0} in {1} ms]
benv.loaded_in=[loaded {0} in {1} ms]
benv.failed_to_close_class_path=no se ha podido cerrar la ruta de acceso de la clase: {0}
main.usage=use: {0} [-g][-O][-debug][-depend][-nowarn][-verbose][-classpath path][-nowrite][-deprecation][-d dir][-J<runtime flag>] file.java...
main.wrote=[wrote {0}]
main.errors={0} errores
main.1error=1 error
main.warnings={0} avisos
main.1warning=1 aviso
main.done_in=[done in {0} ms]
javac.err.invalid.encoding.char=\
	El archivo origen de codificación puede ser diferente con esta codificación de plataforma. Utilice la opción -encoding para ajustar la codificación del archivo o aplique la utilidad native2ascii para convertir a ASCII la codificación del archivo origen.
