You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2022/03/29 22:45:44 UTC
[tomcat] 02/06: Back-port remaining updates to jakarta.el translations
This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch 10.0.x
in repository https://gitbox.apache.org/repos/asf/tomcat.git
commit b7d390d0b11298aa0cf01d982044117c35dd7cdb
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Tue Mar 29 23:42:12 2022 +0100
Back-port remaining updates to jakarta.el translations
---
java/jakarta/el/LocalStrings_cs.properties | 38 ++++++++++++++++--
java/jakarta/el/LocalStrings_de.properties | 38 +++++++++++++++---
java/jakarta/el/LocalStrings_es.properties | 44 +++++++++++++++-----
java/jakarta/el/LocalStrings_ko.properties | 58 +++++++++++++--------------
java/jakarta/el/LocalStrings_pt_BR.properties | 37 +++++++++++++++--
java/jakarta/el/LocalStrings_ru.properties | 50 +++++++++++++++++++++++
6 files changed, 212 insertions(+), 53 deletions(-)
diff --git a/java/jakarta/el/LocalStrings_cs.properties b/java/jakarta/el/LocalStrings_cs.properties
index 1d4eed0..5a0e651 100644
--- a/java/jakarta/el/LocalStrings_cs.properties
+++ b/java/jakarta/el/LocalStrings_cs.properties
@@ -13,8 +13,38 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-elProcessor.defineFunctionInvalidMethod=Metoda [{0}] třídy [{1}] není public static metoda
+beanNameELResolver.beanReadOnly=Název objektu typu bean [{0}] jen pro čtení
-importHandler.ambiguousStaticImport=Statický import [{0}] nelze zpracovat, neboť koliduje s [{1}] (který byl již naimportován)
-importHandler.classNotFound=Třídu [{0}] nelze naimportovat, neboť nebyla nalezena
-importHandler.invalidClassNameForStatic=Třída [{0}] uvedená pro statický import [{1}] není platná
+elProcessor.defineFunctionInvalidClass=Třída [{0}] není veřejná
+elProcessor.defineFunctionInvalidMethod=Metoda [{0}] na třídě [{1}] není veřejnou statickou metodou
+elProcessor.defineFunctionInvalidParameterList=Seznam parametrů [{0}] pro metodu [{1}] na třídě [{2}] není platný
+elProcessor.defineFunctionInvalidParameterTypeName=Typ parametru [{0}] pro metodu [{1}] na třídě [{2}] není platný
+elProcessor.defineFunctionNoMethod=Veřejnou statickou metodu [{0}] pro třídu [{1}] nelze nalézt
+elProcessor.defineFunctionNullParams=Nejméně jeden ze vstupních parametrů byl null
+
+expressionFactory.cannotCreate=Nelze vytvořit ExpressionFactory typu [{0}]
+expressionFactory.cannotFind=Nelze najít ExpressionFactory typu [{0}]
+expressionFactory.readFailed=Nezdařilo se přečíst [{0}]
+
+importHandler.ambiguousImport=Třídu [{0}] nelze importovat, protože je v konfliktu s [{1}], který již byl importován
+importHandler.ambiguousStaticImport=Statický import [{0}] nelze zpracovat, protože je v konfliktu s [{1}], který již byl importován
+importHandler.classNotFound=Třídu [{0}] nelze importovat, protože ji nelze nalézt
+importHandler.invalidClassName=Název třídy pro import [{0}] musí obsahovat balík
+importHandler.invalidClassNameForStatic=Třída [{0}] určená pro statický import [{1}] není platná
+importHandler.invalidStaticName=Název statické metody nebo pole pro import [{0}] musí obsahovat třídu
+importHandler.staticNotFound=Statický import [{0}] nebyl nalezen ve třídě [{1}] pro import [{2}]
+
+lambdaExpression.tooFewArgs=Pouze [{0}] argumentů bylo poskytnuto pro výraz lambda, který vyžaduje alespoň [{1}]
+
+objectNotAssignable=Nelze přidat objekt typu [{0}] do pole objektů typu [{1}].
+propertyNotFound=Vlastnost [{1}] nebyla nalezena u typu [{0}]
+propertyNotReadable=Vlastnost [{1}] není čitelná u typu [{0}]
+propertyNotWritable=Vlastnost [{1}] není zapisovatelná u typu [{0}]
+propertyReadError=Chyba při čtení [{1}] u typu [{0}]
+propertyWriteError=Chyba pri zápisu [{1}] u typu [{0}]
+
+staticFieldELResolver.methodNotFound=Nebyla nalezena žádná odpovídající veřejná statická metoda s názvem [{0}] ve třídě [{1}]
+staticFieldELResolver.notWritable=Zápis do statických polí (v tomto případě pole [{0}] pro třídu [{1}]) není povolen
+
+util.method.ambiguous=Nelze najít jednoznačnou metodu: {0}.{1}({2})
+util.method.notfound=Metoda nebyla nalezena: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_de.properties b/java/jakarta/el/LocalStrings_de.properties
index 402e9b5..16fe8c0 100644
--- a/java/jakarta/el/LocalStrings_de.properties
+++ b/java/jakarta/el/LocalStrings_de.properties
@@ -13,10 +13,38 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-elProcessor.defineFunctionInvalidClass=Die Klasse [{0}] ist nicht öffentlich
-elProcessor.defineFunctionInvalidMethod=Die Methode [{0}] der Klasse [{1}] ist nicht public static
+beanNameELResolver.beanReadOnly=Der Beanname [{0}] ist schreibgeschützt.
-expressionFactory.cannotFind=Kann die ExpressionFactory mit dem Typ [{0}] nicht finden
+elProcessor.defineFunctionInvalidClass=Die Klasse [{0}] ist nicht öffentlich.
+elProcessor.defineFunctionInvalidMethod=Die Methode [{0}] in der Klasse [{1}] ist keine öffentliche statische Methode.
+elProcessor.defineFunctionInvalidParameterList=Die Parameterliste [{0}] für die Methode [{1}] in der Klasse [{2}] ist nicht gültig.
+elProcessor.defineFunctionInvalidParameterTypeName=Der Parametertyp [{0}] für die Methode [{1}] in der Klasse [{2}] ist nicht gültig.
+elProcessor.defineFunctionNoMethod=Es wurde keine öffentliche statische Methode [{0}] in der Klasse [{1}] gefunden.
+elProcessor.defineFunctionNullParams=Mindestens einer der Eingabeparameter ist null.
-importHandler.classNotFound=Die Klasse [{0}] konnte nicht importiert werden, da sie nicht gefunden werden konnte
-importHandler.invalidClassNameForStatic=Ungültige Klasse [{0}] für angegebenen static import [{1}]
+expressionFactory.cannotCreate=Die Ausdruckfactory vom Typ [{0}] konnte nicht erstellt werden.
+expressionFactory.cannotFind=Die Ausdruckfactory vom Typ [{0}] konnte nicht gefunden werden.
+expressionFactory.readFailed=Fehler beim Lesen von [{0}]
+
+importHandler.ambiguousImport=Die Klasse {0}] konnte nicht importiert werden, weil sie mit dem bereits durchgeführten Import von [{1}] in Konflikt steht.
+importHandler.ambiguousStaticImport=Der statische Import [{0}] konnte nicht verarbeitet werden, weil er mit dem bereits durchgeführten Import von [{1}] in Konflikt steht.
+importHandler.classNotFound=Die Klasse [{0}] konnte nicht importiert werden, weil sie nicht gefunden wurde.
+importHandler.invalidClassName=Der Name der zu importierenden Klasse [{0}] muss ein Paket enthalten.
+importHandler.invalidClassNameForStatic=Die Klasse [{0}], die für den statischen Import [{1}] angegeben wurde, ist nicht gültig.
+importHandler.invalidStaticName=Der Name der zu importierenden statischen Methode bzw. des zu importierenden Felds [{0}] muss eine Klasse enthalten.
+importHandler.staticNotFound=Der statische Import [{0}] wurde nicht in der Klasse [{1}] für den Import [{2}] gefunden.
+
+lambdaExpression.tooFewArgs=Es wurden nur [{0}] Argumente für einen Lambdaausdruck angegeben, der mindestens [{1}] Argumente erfordert.
+
+objectNotAssignable=Ein Objekt des Typs [{0}] kann keinem Array von Objekten des Typs [{1}] hinzugefügt werden.
+propertyNotFound=Die Eigenschaft [{1}] wurde für den Typ [{0}] nicht gefunden
+propertyNotReadable=Die Eigenschaft [{1}] ist für den Typ [{0}] nicht lesbar
+propertyNotWritable=Die Eigenschaft [{1}] kann nicht für den Typ [{0}] beschrieben werden
+propertyReadError=Fehler beim Lesen von [{1}] für den Typ [{0}]
+propertyWriteError=Fehler beim Schreiben von [{1}] für den Typ [{0}]
+
+staticFieldELResolver.methodNotFound=Es wurde keine öffentliche statische Methode mit dem Namen [{0}] in der Klasse [{1}] gefunden.
+staticFieldELResolver.notWritable=Das Schreiben in statische Felder (in diesem Fall Feld [{0}] in Klasse [{1}]) ist nicht zulässig.
+
+util.method.ambiguous=Es wurde keine eindeutige Methode gefunden: {0}.{1}({2})
+util.method.notfound=Methode nicht gefunden: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_es.properties b/java/jakarta/el/LocalStrings_es.properties
index bbcebf8..8d2bd1f 100644
--- a/java/jakarta/el/LocalStrings_es.properties
+++ b/java/jakarta/el/LocalStrings_es.properties
@@ -13,16 +13,38 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+beanNameELResolver.beanReadOnly=El nombre de bean [{0}] es de sólo lectura
+
+elProcessor.defineFunctionInvalidClass=La clase [{0}] no es pública
elProcessor.defineFunctionInvalidMethod=El método [{0}] en la clase [{1}] no es un método estático público
+elProcessor.defineFunctionInvalidParameterList=La lista de parámetros [{0}] para el método [{1}] en la clase [{2}] no es válida
+elProcessor.defineFunctionInvalidParameterTypeName=El tipo de parámetro [{0}] para el método [{1}] en la clase [{2}] no es válido
+elProcessor.defineFunctionNoMethod=No se ha podido encontrar un método estático público [{0}] en la clase [{1}]
+elProcessor.defineFunctionNullParams=Uno o varios de los parámetros de entrada era nulo
+
+expressionFactory.cannotCreate=No se ha podido crear un ExpressionFactory de tipo [{0}]
+expressionFactory.cannotFind=No se ha podido encontrar un ExpressionFactory de tipo [{0}]
+expressionFactory.readFailed=No se ha podido leer [{0}]
+
+importHandler.ambiguousImport=La clase [{0}] no se ha podido importar ya que está en conflicto con [{1}], que ya se ha importado
+importHandler.ambiguousStaticImport=No se ha podido procesar la importación estática [{0}] ya que está en conflicto con [{1}] que ya se ha importado
+importHandler.classNotFound=No se ha podido importar la clase [{0}], ya que no se ha podido importar
+importHandler.invalidClassName=El nombre de la clase para importar [{0}] debe incluir un paquete
+importHandler.invalidClassNameForStatic=La clase [{0}] especificada para la importación estática [{1}] no es válida
+importHandler.invalidStaticName=El nombre del campo o método estático para importar [{0}] debe incluir una clase
+importHandler.staticNotFound=No se ha podido encontrar la importación estática [{0}] en la clase [{1}] para la importación [{2}]
+
+lambdaExpression.tooFewArgs=Sólo se han proporcionado [{0}] argumentos para una expresión lambda que requiere al menos [{1}]
+
+objectNotAssignable=No se puede añadir un objeto de tipo [{0}] a una matriz de objetos de tipo [{1}]
+propertyNotFound=No se ha encontrado la propiedad [{1}] en el tipo [{0}]
+propertyNotReadable=La propiedad [{1}] no se puede leer en el tipo [{0}]
+propertyNotWritable=La propiedad [{1}] no se puede escribir en el tipo [{0}]
+propertyReadError=Error al leer [{1}] en el tipo [{0}]
+propertyWriteError=Error al escribir [{1}] en el tipo [{0}]
+
+staticFieldELResolver.methodNotFound=No se ha encontrado ningún método estático público coincidente denominado [{0}] en la clase [{1}]
+staticFieldELResolver.notWritable=No se permite escribir en campos estáticos (en este caso, el campo [{0}] en la clase [{1}])
-importHandler.ambiguousStaticImport=La importación estática [{0}] no puede ser procesada pues entra en conflicto con [{1}] la cual ya ha sido importada
-importHandler.classNotFound=La clase [{0}] no puede ser importada debido a que no fué encontrada
-importHandler.invalidClassNameForStatic=La clase [{0}] especificada para importación estática [{1}] no es valida
-importHandler.staticNotFound=La importación estática [{0}] no se pudo encontrar en la clase [{1}] para importar [{2}]
-
-objectNotAssignable=No puedo añadir un objeto del tipo [{0}] a un arreglo de objetos del tipo [{1}]
-propertyNotFound=Propiedad [{1}] no hallada en el tipo [{0}]
-propertyNotReadable=Propiedad [{1}] no legible para el tipo [{0}]
-propertyNotWritable=Propiedad [{1}] no grabable para el tipo [{0}]
-propertyReadError=Error reading [{1}] en el tipo [{0}]
-propertyWriteError=Error writing [{1}] en el tipo [{0}]
+util.method.ambiguous=No se ha podido encontrar el método no ambiguo: {0}.{1}({2})
+util.method.notfound=No se ha encontrado el método: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_ko.properties b/java/jakarta/el/LocalStrings_ko.properties
index d3d3dc5..627d129 100644
--- a/java/jakarta/el/LocalStrings_ko.properties
+++ b/java/jakarta/el/LocalStrings_ko.properties
@@ -15,38 +15,38 @@
beanNameELResolver.beanReadOnly=Bean 이름 [{0}]은(는) 읽기 전용입니다.
-elProcessor.defineFunctionInvalidClass=클래스 [{0}]은(는) public 클래스가 아닙니다.
-elProcessor.defineFunctionInvalidMethod=클래스 [{1}]의 메소드 [{0}]은(는) public static 메소드가 아닙니다.
-elProcessor.defineFunctionInvalidParameterList=클래스 [{2}]의 메소드 [{1}]을(를) 위한 파라미터 목록 [{0}]이(가) 유효하지 않습니다.
-elProcessor.defineFunctionInvalidParameterTypeName=클래스 [{2}]의 메소드 [{1}]을(를) 위한 파라미터 타입 [{0}]은(는) 유효하지 않습니다.
-elProcessor.defineFunctionNoMethod=클래스 [{1}]에서 public static 메소드 [{0}]을(를) 찾을 수 없었습니다.
-elProcessor.defineFunctionNullParams=하나 이상의 입력 파라미터들이 널이었습니다.
-
-expressionFactory.cannotCreate=타입 [{0}]의 ExpressionFactory를 생성할 수 없습니다.
-expressionFactory.cannotFind=타입 [{0}]의 ExpressionFactory를 찾을 수 없습니다.
-expressionFactory.readFailed=[{0}]을(를) 읽지 못했습니다.
-
-importHandler.ambiguousImport=이미 임포트된 [{1}]와(과) 충돌하기에, 클래스 [{0}]은(는) 임포트될 수 없었습니다.
-importHandler.ambiguousStaticImport=정적 임포트 [{0}]은(는), 이미 임포트된 [{1}]와(과) 충돌하기 때문에 처리될 수 없었습니다.
-importHandler.classNotFound=클래스 [{0}]을(를) 찾을 수 없어서 임포트될 수 없습니다.
+elProcessor.defineFunctionInvalidClass=클래스 [{0}]이(가) 공용이 아닙니다.
+elProcessor.defineFunctionInvalidMethod=클래스 [{1}]의 메소드 [{0}]이(가) 공용 정적 메소드가 아닙니다.
+elProcessor.defineFunctionInvalidParameterList=클래스 [{2}]의 메소드 [{1}]에 대한 매개변수 목록 [{0}]이(가) 유효하지 않습니다.
+elProcessor.defineFunctionInvalidParameterTypeName=클래스 [{2}]의 메소드 [{1}]에 대한 매개변수 유형 [{0}]이(가) 유효하지 않습니다.
+elProcessor.defineFunctionNoMethod=클래스 [{1}]의 공용 정적 메소드 [{0}]을(를) 찾을 수 없습니다.
+elProcessor.defineFunctionNullParams=하나 이상의 입력 매개변수가 널입니다.
+
+expressionFactory.cannotCreate=[{0}] 유형의 ExpressionFactory를 작성할 수 없음
+expressionFactory.cannotFind=[{0}] 유형의 ExpressionFactory를 찾을 수 없음
+expressionFactory.readFailed=[{0}] 읽기 실패
+
+importHandler.ambiguousImport=이미 가져온 [{1}]과(와) 충돌하므로 클래스 [{0}]을(를) 가져올 수 없습니다.
+importHandler.ambiguousStaticImport=이미 가져온 [{1}]과(와) 충돌하므로 정적 가져오기 [{0}]을(를) 처리할 수 없습니다.
+importHandler.classNotFound=클래스 [{0}]을(를) 찾을 수 없으므로 가져올 수 없습니다.
importHandler.invalidClass=클래스 [{0}]은(는), 반드시 public이어야 하고 abstract가 아니어야 하며 인터페이스가 아니어야 합니다.
-importHandler.invalidClassName=임포트할 클래스 이름 [{0}]은(는) 반드시 패키지를 포함해야 합니다.
-importHandler.invalidClassNameForStatic=정적 임포트 [{1}]을(를) 위해 지정된 클래스 [{0}]은(는) 유효하지 않습니다.
-importHandler.invalidStaticName=임포트할 정적 메소드나 필드의 이름은, 반드시 클래스를 포함해야 합니다: [{0}]
-importHandler.staticNotFound=임포트 [{2}]을(를) 위한 클래스 [{1}] 내에서, 정적 임포트 [{0}]을(를) 찾을 수 없습니다.
+importHandler.invalidClassName=[{0}]을(를) 가져올 클래스의 이름에는 패키지가 포함되어야 합니다.
+importHandler.invalidClassNameForStatic=정적 가져오기 [{1}]에 지정된 클래스 [{0}]이(가) 유효하지 않습니다.
+importHandler.invalidStaticName=[{0}]을(를) 가져올 정적 메소드 또는 필드의 이름에는 클래스가 포함되어야 합니다.
+importHandler.staticNotFound=정적 가져오기 [{0}]을(를) 가져오기 [{2}]의 클래스 [{1}]에서 찾을 수 없습니다.
-lambdaExpression.tooFewArgs=적어도 [{1}]개의 아규먼트들을 요구하는 람다 표현식에, 단지 [{0}]개의 아규먼트들만이 제공되었습니다.
+lambdaExpression.tooFewArgs=최소한 [{1}]개를 필요로 하는 lambda 표현식에 [{0}]개의 인수만 제공되었습니다.
-objectNotAssignable=타입 [{0}]의 객체를, 타입 [{1}]의 객체 배열에 추가할 수 없습니다.
-propertyNotFound=타입 [{0}]에서 프로퍼티 [{1}]을(를) 찾을 수 없습니다.
-propertyNotReadable=타입 [{0}]에서 프로퍼티 [{1}]을(를) 읽을 수 없습니다.
-propertyNotWritable=타입 [{0}]에서 쓰기 가능하지 않은 프로퍼티 [{1}]
-propertyReadError=타입 [{0}]에서 [{1}]을(를) 읽는 중 오류 발생
-propertyWriteError=타입 [{0}]에 [{1}]을(를) 쓰는 중 오류 발생
+objectNotAssignable=[{0}] 유형의 오브젝트를 [{1}] 유형의 오브젝트 배열에 추가할 수 없습니다.
+propertyNotFound=[{1}] 특성이 [{0}] 유형에 없습니다.
+propertyNotReadable=[{0}] 유형에서 [{1}] 특성을 읽을 수 없습니다.
+propertyNotWritable=[{1}] 특성이 [{0}] 유형에서 쓰기 가능하지 않습니다.
+propertyReadError=[{0}] 유형에서 [{1}]을(를) 읽는 중에 오류가 발생했습니다.
+propertyWriteError=[{0}] 유형에 [{1}]을(를) 쓰는 중에 오류가 발생했습니다.
-staticFieldELResolver.methodNotFound=클래스 [{1}]에 [{0}](이)라는 이름의 public static 메소드가 발견되지 않습니다.
+staticFieldELResolver.methodNotFound=일치하는 공용 정적 메소드 [{0}]이(가) [{1}] 클래스에 없음
staticFieldELResolver.notFound=클래스 [{1}]에, [{0}](이)라는 이름의 public static 필드가 없습니다.
-staticFieldELResolver.notWritable=정적 필드들에 대해 쓰기는 허용되지 않습니다 (이번 경우는 클래스 [{1}]의 필드 [{0}]).
+staticFieldELResolver.notWritable=[{1}] 클래스의 이 케이스 필드 [{0}]에 있는 정적 필드에 쓰기가 허용되지 않음
-util.method.ambiguous=애매하지 않고 명백하게 메소드를 찾을 수 없습니다: {0}.{1}({2})
-util.method.notfound=메소드를 찾을 수 없습니다: {0}.{1}({2})
+util.method.ambiguous=명확한 메소드를 찾을 수 없음: {0}.{1}({2})
+util.method.notfound=메소드를 찾을 수 없음: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_pt_BR.properties b/java/jakarta/el/LocalStrings_pt_BR.properties
index a31dbbb..e270c49 100644
--- a/java/jakarta/el/LocalStrings_pt_BR.properties
+++ b/java/jakarta/el/LocalStrings_pt_BR.properties
@@ -13,9 +13,38 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-beanNameELResolver.beanReadOnly=O nome do bean [{0}] é apenas para leitura
+beanNameELResolver.beanReadOnly=O nome do bean {0}] é somente leitura
-elProcessor.defineFunctionInvalidClass=A classe [{0}] não possui visibilidade pública
-elProcessor.defineFunctionInvalidMethod=O método [{0}] da classe [{1}] não é um método público e estático
+elProcessor.defineFunctionInvalidClass=A classe [{0}] não é pública
+elProcessor.defineFunctionInvalidMethod=O método [{0}] na classe [{1}] não é um método estático público
+elProcessor.defineFunctionInvalidParameterList=A lista de parâmetros [{0}] do método [{1}] na classe [{2}] não é válida
+elProcessor.defineFunctionInvalidParameterTypeName=O tipo de parâmetro [{0}] do método [{1}] na classe [{2}] não é válido
+elProcessor.defineFunctionNoMethod=Um método estático público [{0}] na classe [{1}] não pôde ser localizado
+elProcessor.defineFunctionNullParams=Um ou mais parâmetros de entrada era nulo
-importHandler.invalidClassNameForStatic=A classe [{0}] especificada para o import estático [{1}] é inválida
+expressionFactory.cannotCreate=Não foi possível criar ExpressionFactory do tipo [{0}]
+expressionFactory.cannotFind=Não foi possível localizar ExpressionFactory do tipo [{0}]
+expressionFactory.readFailed=Falha ao ler [{0}]
+
+importHandler.ambiguousImport=A classe [{0}] não pôde ser importada, pois ela entra em conflito com [{1}] que já foi importado
+importHandler.ambiguousStaticImport=A importação estática [{0}] não pôde ser processada, pois ela entra em conflito com [{1}] que já foi importada
+importHandler.classNotFound=A classe [{0}] não pôde importada, pois não pôde ser localizada
+importHandler.invalidClassName=O nome da classe a ser importada [{0}] deve incluir um pacote
+importHandler.invalidClassNameForStatic=A classe [{0}] especificada para importação estática [{1}] não é válida
+importHandler.invalidStaticName=O nome do método ou campo estático a ser importado [{0}] deve incluir uma classe
+importHandler.staticNotFound=A importação estática [{0}] não pôde ser localizada na classe [{1}] para importação [{2}]
+
+lambdaExpression.tooFewArgs=Somente [{0}] argumentos foram fornecidos para uma expressão lambda que requer pelo menos [{1}]
+
+objectNotAssignable=Não é possível incluir um objeto do tipo [{0}] em uma matriz de objetos do tipo [{1}]
+propertyNotFound=Não foi possível localizar a propriedade [{1}] no tipo [{0}]
+propertyNotReadable=Não foi possível ler a propriedade [{1}] no tipo [{0}]
+propertyNotWritable=Não foi possível gravar a propriedade [{1}] no tipo [{0}]
+propertyReadError=Erro ao ler [{1}] no tipo [{0}]
+propertyWriteError=Erro ao gravar [{1}] no tipo [{0}]
+
+staticFieldELResolver.methodNotFound=Nenhum método estático público correspondente chamado [{0}] localizado na classe [{1}]
+staticFieldELResolver.notWritable=Não é permitido gravar nos campos estáticos (nesse caso, o campo [{0}] na classe [{1}])
+
+util.method.ambiguous=Não é possível localizar método inequívoco: {0}.{1}({2})
+util.method.notfound=Método não localizado: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_ru.properties b/java/jakarta/el/LocalStrings_ru.properties
new file mode 100644
index 0000000..67bdcf3
--- /dev/null
+++ b/java/jakarta/el/LocalStrings_ru.properties
@@ -0,0 +1,50 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+beanNameELResolver.beanReadOnly=Имя объекта EJB [{0}] доступно только для чтения
+
+elProcessor.defineFunctionInvalidClass=Класс [{0}] не public
+elProcessor.defineFunctionInvalidMethod=Метод [{0}] в классе [{1}] не public static
+elProcessor.defineFunctionInvalidParameterList=Недопустимый список параметров [{0}] для метода [{1}] в классе [{2}]
+elProcessor.defineFunctionInvalidParameterTypeName=Недопустимый тип параметра [{0}] для метода [{1}] в классе [{2}]
+elProcessor.defineFunctionNoMethod=Не найден метод public static [{0}] в классе [{1}]
+elProcessor.defineFunctionNullParams=Часть входных параметров равна null
+
+expressionFactory.cannotCreate=Не удалось создать ExpressionFactory типа [{0}]
+expressionFactory.cannotFind=Не удалось найти ExpressionFactory типа [{0}]
+expressionFactory.readFailed=Не удалось прочитать [{0}]
+
+importHandler.ambiguousImport=Класс [{0}] не удалось импортировать, так как он конфликтует с уже импортированным классом [{1}]
+importHandler.ambiguousStaticImport=Статический импорт класса [{0}] не удалось обработать, так как он конфликтует с уже импортированным классом [{1}]
+importHandler.classNotFound=Класс [{0}] не удалось импортировать, поскольку он не найден
+importHandler.invalidClassName=Имя класса для импорта [{0}] должно включать пакет
+importHandler.invalidClassNameForStatic=Класс [{0}], указанный для статического импорта [{1}], недопустимый
+importHandler.invalidStaticName=Имя метода или поля static для импорта [{0}] должно включать класс
+importHandler.staticNotFound=Статический импорт [{0}] не найден в классе [{1}] для импорта [{2}]
+
+lambdaExpression.tooFewArgs=В лямбда-выражение передано только [{0}] аргументов, а требуется не менее [{1}]
+
+objectNotAssignable=Не удалось добавить объект типа [{0}] в массив объектов типа [{1}]
+propertyNotFound=Свойство [{1}] не найдено в типе [{0}]
+propertyNotReadable=Свойство [{1}] не является читаемым в типе [{0}]
+propertyNotWritable=Свойство [{1}] не является записываемым в типе [{0}]
+propertyReadError=Ошибка чтения [{1}] в типе [{0}]
+propertyWriteError=Ошибка записи [{1}] в типе [{0}]
+
+staticFieldELResolver.methodNotFound=В классе [{1}] не найден соответствующий метод public static с именем [{0}]
+staticFieldELResolver.notWritable=Запись в поле static (в данном случае это поле [{0}] в классе [{1}]) запрещена
+
+util.method.ambiguous=Не удалось однозначно найти метод: {0}.{1}({2})
+util.method.notfound=Метод не найден: {0}.{1}({2})
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org