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 20:02:22 UTC
[tomcat] branch main updated: Expand coverage of translations for jakarta.el package.
This is an automated email from the ASF dual-hosted git repository.
markt pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/tomcat.git
The following commit(s) were added to refs/heads/main by this push:
new a84580e Expand coverage of translations for jakarta.el package.
a84580e is described below
commit a84580ecfe7401f34c4138de07de83e131c0a6fd
Author: Mark Thomas <ma...@apache.org>
AuthorDate: Tue Mar 29 21:02:12 2022 +0100
Expand coverage of translations for jakarta.el package.
Based on <pr>488</pr> from Volodymyr Siedlecki.
---
java/jakarta/el/LocalStrings_cs.properties | 41 +++++++++++++--
java/jakarta/el/LocalStrings_de.properties | 41 +++++++++++++--
java/jakarta/el/LocalStrings_es.properties | 56 ++++++++++++--------
java/jakarta/el/LocalStrings_fr.properties | 64 +++++++++++------------
java/jakarta/el/LocalStrings_ja.properties | 74 +++++++++++++--------------
java/jakarta/el/LocalStrings_ko.properties | 71 ++++++++++++-------------
java/jakarta/el/LocalStrings_pt_BR.properties | 40 +++++++++++++--
java/jakarta/el/LocalStrings_ru.properties | 53 +++++++++++++++++++
java/jakarta/el/LocalStrings_zh_CN.properties | 72 +++++++++++++-------------
webapps/docs/changelog.xml | 4 ++
10 files changed, 342 insertions(+), 174 deletions(-)
diff --git a/java/jakarta/el/LocalStrings_cs.properties b/java/jakarta/el/LocalStrings_cs.properties
index 1d4eed0..8195659 100644
--- a/java/jakarta/el/LocalStrings_cs.properties
+++ b/java/jakarta/el/LocalStrings_cs.properties
@@ -13,8 +13,41 @@
# 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í
+
+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.invalidClass=Třída [{0}] musí být veřejná, v exportovaném balíku (pro Java 9+), neabstraktní a nesmí být rozhraním
+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.notFound=Nebylo nalezeno žádné veřejné statické pole s názvem [{0}] ve třídě [{1}] (exportované pro Java 9+)
+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})
-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á
diff --git a/java/jakarta/el/LocalStrings_de.properties b/java/jakarta/el/LocalStrings_de.properties
index 402e9b5..0b8a092 100644
--- a/java/jakarta/el/LocalStrings_de.properties
+++ b/java/jakarta/el/LocalStrings_de.properties
@@ -13,10 +13,41 @@
# 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.
+
+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.invalidClass=Die Klasse [{0}] muss eine öffentliche, in einem exportierten Paket (für Java 9+), nicht abstrakte Klasse und darf keine Schnittstelle sein.
+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.notFound=Es wurde kein öffentliches statisches Feld mit dem Namen [{0}] in der (für Java 9+ exportierten) 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})
-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}]
diff --git a/java/jakarta/el/LocalStrings_es.properties b/java/jakarta/el/LocalStrings_es.properties
index 3cf450c..644a47a 100644
--- a/java/jakarta/el/LocalStrings_es.properties
+++ b/java/jakarta/el/LocalStrings_es.properties
@@ -13,26 +13,40 @@
# 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}] del método [{1}] en la clase [{2}] es inválida
-elProcessor.defineFunctionInvalidParameterTypeName=El parámetro de tipo [{0}] del método [{1}] en la clase [{2}] es inválido
-
-expressionFactory.cannotCreate=Imposible crear ExpressionFactory de tipo [{0}]
-expressionFactory.cannotFind=No se halló ExpressionFactory de tipo [{0}]
-expressionFactory.readFailed=Fallo al leer [{0}]
-
-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.invalidClass=La clase [{0}] debe ser pública, no abstracta o una interfaz y estar en un paquete exportado
-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}]
-
-staticFieldELResolver.notFound=No se halló un campo estático público llamado [{0}] en la clase exportada [{1}]
+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.invalidClass=La clase [{0}] debe ser pública, estar en un paquete exportado (para Java 9+), ser no abstracta y no ser una interfaz
+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.notFound=No se ha encontrado ningún campo estático público denominado [{0}] en la clase [{1}] (exportada para Java 9+)
+staticFieldELResolver.notWritable=No se permite escribir en campos estáticos (en este caso, el campo [{0}] en la clase [{1}])
+
+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_fr.properties b/java/jakarta/el/LocalStrings_fr.properties
index 7f72ce9..963ce2f 100644
--- a/java/jakarta/el/LocalStrings_fr.properties
+++ b/java/jakarta/el/LocalStrings_fr.properties
@@ -17,36 +17,36 @@ beanNameELResolver.beanReadOnly=Le nom de bean [{0}] est en lecture seule
elProcessor.defineFunctionInvalidClass=La classe [{0}] n''est pas publique
elProcessor.defineFunctionInvalidMethod=La méthode [{0}] sur la classe [{1}] n''est pas une méthode statique publique
-elProcessor.defineFunctionInvalidParameterList=La liste de paramètres [{0}] pour la méthode [{1}] de la classe [{2}] n''est pas valide
-elProcessor.defineFunctionInvalidParameterTypeName=Le type [{0}] du paramètre de la méthode [{1}] sur la classe [{2}] n''est pas valide
-elProcessor.defineFunctionNoMethod=Une méthode statique et publique [{0}] n''a pas pu être trouvée sur la classe [{1}]
-elProcessor.defineFunctionNullParams=On ou plusieurs paramètres d'entrée sont null
-
-expressionFactory.cannotCreate=Impossible de créer une ExpressionFactory de type [{0}]
-expressionFactory.cannotFind=Impossible de trouver une ExpressionFactory de type [{0}]
-expressionFactory.readFailed=Impossible de lire [{0}]
-
-importHandler.ambiguousImport=La classe [{0}] n''a pas pu être importée car elle entre en conflit avec [{1}] qui a déjà été importée
-importHandler.ambiguousStaticImport=L''import statique [{0}] ne peut pas être traité parce qu''il est en conflit avec [{1}] qui a déjà été importé
-importHandler.classNotFound=La classe [{0}] n''a pu être importée, vu qu''on ne l''a pas trouvée
-importHandler.invalidClass=La classe [{0}] doit être publique, non abstraite, ne pas être une interface et être dans un package exporté
-importHandler.invalidClassName=Le nom de la classe à importer [{0}] doit comprendre un paquet
-importHandler.invalidClassNameForStatic=La classe [{0}] spécifiée pour l''import statique [{1}] n''est pas valide
-importHandler.invalidStaticName=Le nom de la méthode statique ou champ à importer [{0}] doit inclure une calsse
-importHandler.staticNotFound=L''importation statique [{0}] n''a pas été trouvée dans la classe [{1}] pour [{2}]
-
-lambdaExpression.tooFewArgs=Seuls [{0}] arguments ont été fournis pour une expression lambda qui en demande au moins [{1}]
-
-objectNotAssignable=Impossible d''ajouter un objet du type [{0}] à un tableau d''objets de type [{1}]
-propertyNotFound=La propriété [{1}] n''a pas été trouvée sur le type [{0}]
-propertyNotReadable=La propriété [{1}] n''est pas lisible sur le type [{0}]
-propertyNotWritable=La propriété [{1}] ne peut pas être écrite pour le type [{0}]
-propertyReadError=Erreur lors de la lecture de [{1}] sur le type [{0}]
-propertyWriteError=Erreur d''écriture [{1}] sur le type [{0}]
-
-staticFieldELResolver.methodNotFound=Aucune méthode publique et statique nommée [{0}] n''a été trouvée dans la classe [{1}]
-staticFieldELResolver.notFound=Aucun champ public statique nommé [{0}] n''a été trouvé dans la classe [{1}] (exportée pour Java 9+)
-staticFieldELResolver.notWritable=L''écriture dans les champs statiques (champ [{0}] dans la classe [{1}] dans le cas présent) est interdite
-
-util.method.ambiguous=Impossible de trouver une méthode non ambiguë : {0}.{1}({2})
+elProcessor.defineFunctionInvalidParameterList=La liste de paramètres [{0}] pour la méthode [{1}] sur la classe [{2}] n''est pas valide
+elProcessor.defineFunctionInvalidParameterTypeName=Le type de paramètre [{0}] pour la méthode [{1}] sur la classe [{2}] n''est pas valide
+elProcessor.defineFunctionNoMethod=Une méthode statique publique [{0}] sur la classe [{1}] est introuvable
+elProcessor.defineFunctionNullParams=Un ou plusieurs des paramètres en entrée avaient une valeur nulle
+
+expressionFactory.cannotCreate=Impossible de créer ExpressionFactory de type [{0}]
+expressionFactory.cannotFind=Impossible de trouver ExpressionFactory de type [{0}]
+expressionFactory.readFailed=Echec de lecture de [{0}]
+
+importHandler.ambiguousImport=.La classe [{0}] n''a pas pu être importée car elle est en conflit avec [{1}] qui est déjà importé
+importHandler.ambiguousStaticImport=L''importation statique [{0}] n''a pas pu être traitée car elle est en conflit avec [{1}] qui est déjà importé
+importHandler.classNotFound=La classe [{0}] n''a pas pu être importée car elle est introuvable
+importHandler.invalidClass=La classe [{0}] doit être publique, dans un package exporté (pour Java 9+), non abstraite et ne doit pas être une interface
+importHandler.invalidClassName=Le nom de la classe à importer [{0}] doit inclure un package
+importHandler.invalidClassNameForStatic=La classe [{0}] spécifiée pour l''importation statique [{1}] n''est pas valide
+importHandler.invalidStaticName=Le nom de la méthode ou de la zone statique à importer [{0}] doit inclure une classe
+importHandler.staticNotFound=L''importation statique [{0}] est introuvable dans la classe [{1}] pour l''importation [{2}]
+
+lambdaExpression.tooFewArgs=Seuls [{0}] arguments ont été fournis pour une expression lambda qui en requiert au moins [{1}]
+
+objectNotAssignable=Impossible d''ajouter un objet de type [{0}] à un tableau d''objets de type [{1}]
+propertyNotFound=Propriété [{1}] introuvable sur le type [{0}]
+propertyNotReadable=Propriété [{1}] illisible sur le type [{0}]
+propertyNotWritable=Propriété [{1}] non inscriptible sur le type [{0}]
+propertyReadError=Erreur de lecture de [{1}] sur le type [{0}]
+propertyWriteError=Erreur d''écriture de [{1}] sur le type [{0}]
+
+staticFieldELResolver.methodNotFound=Aucune méthode statique publique nommée [{0}] n''a été détectée sur la classe [{1}]
+staticFieldELResolver.notFound=Aucune zone statique publique nommée [{0}] n''a été détectée sur la classe (exportée pour Java 9+) [{1}]
+staticFieldELResolver.notWritable=L''écriture dans les zones statiques (dans ce cas la zone [{0}] sur la classe [{1}]) n''est pas autorisée
+
+util.method.ambiguous=Méthode non ambiguë : {0}.{1}({2}) non trouvée
util.method.notfound=Méthode non trouvée : {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_ja.properties b/java/jakarta/el/LocalStrings_ja.properties
index 86c83d9..dbae191 100644
--- a/java/jakarta/el/LocalStrings_ja.properties
+++ b/java/jakarta/el/LocalStrings_ja.properties
@@ -13,40 +13,40 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-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=1つ以上の入力パラメータがnullでした。
-
-expressionFactory.cannotCreate=型[{0}]のExpressionFactoryを作成できません。
-expressionFactory.cannotFind=[{0}]型のExpressionFactoryを見つけることができません。
-expressionFactory.readFailed=[{0}]の読み取りに失敗しました
-
-importHandler.ambiguousImport=クラス [{0}] はすでにインポートした [{1}] と衝突するためインポートできません。
-importHandler.ambiguousStaticImport=static import [{0}] はすでにインポートした [{1}] と衝突するため処理できません。
-importHandler.classNotFound=存在しないクラス [{0}] はインポートできません。
-importHandler.invalidClass=クラス [{0}] は publicで、エクスポートされたパッケージ内にあり、非abstract で非インタフェースである必要があります
-importHandler.invalidClassName=インポートするクラスの名前[{0}]にはパッケージが含まれている必要があります
-importHandler.invalidClassNameForStatic=クラス [{0}] の static import [{1}] は無効です
-importHandler.invalidStaticName=インポートするstaticメソッドまたはフィールドの名前[{0}]にはクラスが含まれている必要があります。
-importHandler.staticNotFound=インポート [{2}] の静的インポート [{0}] はクラス [{1}] で見つかりませんでした
-
-lambdaExpression.tooFewArgs=少なくとも [{1}] を必要とするラムダ式に対しては、[{0}] 引数のみが提供されました
-
-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.notFound=(Java 9 以降ではエクスポートされた) クラス [{1}] に [{0}] という名前のpublic staticフィールドが見つかりませんでした
-staticFieldELResolver.notWritable=静的フィールド (この場合、クラス [{1}] のフィールド [{0}]) への書き込みは許可されていません
-
-util.method.ambiguous=曖昧さのないメソッドを見つけることができません：{0}。{1}（{2}）
-util.method.notfound=メソッドが見つかりません：{0}。{1}（{2}）
+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=1 つ以上の入力パラメーターがヌルでした
+
+expressionFactory.cannotCreate=タイプ [{0}] の ExpressionFactory を作成できません
+expressionFactory.cannotFind=タイプ [{0}] の ExpressionFactory が見つかりません
+expressionFactory.readFailed=[{0}] を読み取れませんでした
+
+importHandler.ambiguousImport=クラス [{0}] は、既にインポート済みの [{1}] と矛盾するため、インポートできませんでした
+importHandler.ambiguousStaticImport=static インポート [{0}] は、既にインポート済みの [{1}] と矛盾するため、処理できませんでした
+importHandler.classNotFound=クラス [{0}] は、見つからなかったため、インポートできませんでした
+importHandler.invalidClass=クラス [{0}] は、public (Java 9+ 用にエクスポートされたパッケージ内で) かつ非抽象でなければならず、インターフェースであってはなりません
+importHandler.invalidClassName=インポートするクラスの名前 [{0}] はパッケージを含む必要があります
+importHandler.invalidClassNameForStatic=static インポート [{1}] に指定されたクラス [{0}] は無効です
+importHandler.invalidStaticName=インポートする static メソッドまたはフィールドの名前 [{0}] は、クラスを含まなければなりません
+importHandler.staticNotFound=static インポート [{0}] が、インポート [{2}] のクラス [{1}] で見つかりませんでした
+
+lambdaExpression.tooFewArgs=少なくとも [{1}] 個の引数を必要とするラムダ式に、[{0}] 個の引数しか指定されませんでした
+
+objectNotAssignable=タイプ [{0}] のオブジェクトをタイプ [{1}] のオブジェクト配列に追加できません
+propertyNotFound=タイプ [{0}] でプロパティー [{1}] が見つかりません
+propertyNotReadable=タイプ [{0}] でプロパティー [{1}] を読み取れません
+propertyNotWritable=タイプ [{0}] でプロパティー [{1}] を書き込めません
+propertyReadError=タイプ [{0}] で [{1}] を読み取り中のエラー
+propertyWriteError=タイプ [{0}] で [{1}] を書き込み中のエラー
+
+staticFieldELResolver.methodNotFound=クラス [{1}] に [{0}] という名前の一致する public static メソッドが見つかりませんでした
+staticFieldELResolver.notFound=(Java 9+ 用にエクスポートされた) クラス [{1}] に public static フィールド [{0}] が見つかりませんでした
+staticFieldELResolver.notWritable=static フィールド (この場合、クラス [{1}] のフィールド [{0}]) への書き込みは許可されません
+
+util.method.ambiguous=あいまいでないメソッドが見つかりません: {0}.{1}({2})
+util.method.notfound=メソッドが見つかりません: {0}.{1}({2})
diff --git a/java/jakarta/el/LocalStrings_ko.properties b/java/jakarta/el/LocalStrings_ko.properties
index d3d3dc5..8107a11 100644
--- a/java/jakarta/el/LocalStrings_ko.properties
+++ b/java/jakarta/el/LocalStrings_ko.properties
@@ -15,38 +15,39 @@
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}]을(를) 찾을 수 없어서 임포트될 수 없습니다.
-importHandler.invalidClass=클래스 [{0}]은(는), 반드시 public이어야 하고 abstract가 아니어야 하며 인터페이스가 아니어야 합니다.
-importHandler.invalidClassName=임포트할 클래스 이름 [{0}]은(는) 반드시 패키지를 포함해야 합니다.
-importHandler.invalidClassNameForStatic=정적 임포트 [{1}]을(를) 위해 지정된 클래스 [{0}]은(는) 유효하지 않습니다.
-importHandler.invalidStaticName=임포트할 정적 메소드나 필드의 이름은, 반드시 클래스를 포함해야 합니다: [{0}]
-importHandler.staticNotFound=임포트 [{2}]을(를) 위한 클래스 [{1}] 내에서, 정적 임포트 [{0}]을(를) 찾을 수 없습니다.
-
-lambdaExpression.tooFewArgs=적어도 [{1}]개의 아규먼트들을 요구하는 람다 표현식에, 단지 [{0}]개의 아규먼트들만이 제공되었습니다.
-
-objectNotAssignable=타입 [{0}]의 객체를, 타입 [{1}]의 객체 배열에 추가할 수 없습니다.
-propertyNotFound=타입 [{0}]에서 프로퍼티 [{1}]을(를) 찾을 수 없습니다.
-propertyNotReadable=타입 [{0}]에서 프로퍼티 [{1}]을(를) 읽을 수 없습니다.
-propertyNotWritable=타입 [{0}]에서 쓰기 가능하지 않은 프로퍼티 [{1}]
-propertyReadError=타입 [{0}]에서 [{1}]을(를) 읽는 중 오류 발생
-propertyWriteError=타입 [{0}]에 [{1}]을(를) 쓰는 중 오류 발생
-
-staticFieldELResolver.methodNotFound=클래스 [{1}]에 [{0}](이)라는 이름의 public static 메소드가 발견되지 않습니다.
-staticFieldELResolver.notFound=클래스 [{1}]에, [{0}](이)라는 이름의 public static 필드가 없습니다.
-staticFieldELResolver.notWritable=정적 필드들에 대해 쓰기는 허용되지 않습니다 (이번 경우는 클래스 [{1}]의 필드 [{0}]).
-
-util.method.ambiguous=애매하지 않고 명백하게 메소드를 찾을 수 없습니다: {0}.{1}({2})
-util.method.notfound=메소드를 찾을 수 없습니다: {0}.{1}({2})
+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}] 클래스는 내보낸 패키지(자바 9+용), 비추상 및 인터페이스가 아닌 공용이어야 합니다.
+importHandler.invalidClassName=[{0}]을(를) 가져올 클래스의 이름에는 패키지가 포함되어야 합니다.
+importHandler.invalidClassNameForStatic=정적 가져오기 [{1}]에 지정된 클래스 [{0}]이(가) 유효하지 않습니다.
+importHandler.invalidStaticName=[{0}]을(를) 가져올 정적 메소드 또는 필드의 이름에는 클래스가 포함되어야 합니다.
+importHandler.staticNotFound=정적 가져오기 [{0}]을(를) 가져오기 [{2}]의 클래스 [{1}]에서 찾을 수 없습니다.
+
+lambdaExpression.tooFewArgs=최소한 [{1}]개를 필요로 하는 lambda 표현식에 [{0}]개의 인수만 제공되었습니다.
+
+objectNotAssignable=[{0}] 유형의 오브젝트를 [{1}] 유형의 오브젝트 배열에 추가할 수 없습니다.
+propertyNotFound=[{1}] 특성이 [{0}] 유형에 없습니다.
+propertyNotReadable=[{0}] 유형에서 [{1}] 특성을 읽을 수 없습니다.
+propertyNotWritable=[{1}] 특성이 [{0}] 유형에서 쓰기 가능하지 않습니다.
+propertyReadError=[{0}] 유형에서 [{1}]을(를) 읽는 중에 오류가 발생했습니다.
+propertyWriteError=[{0}] 유형에 [{1}]을(를) 쓰는 중에 오류가 발생했습니다.
+
+staticFieldELResolver.methodNotFound=일치하는 공용 정적 메소드 [{0}]이(가) [{1}] 클래스에 없음
+staticFieldELResolver.notFound=[{0}](으)로 이름 지정된 공용 정적 필드가 (Java 9+에 대해 내보낸) 클래스 [{1}] 에서 발견되지 않았습니다.
+staticFieldELResolver.notWritable=[{1}] 클래스의 이 케이스 필드 [{0}]에 있는 정적 필드에 쓰기가 허용되지 않음
+
+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..6e9fcbe 100644
--- a/java/jakarta/el/LocalStrings_pt_BR.properties
+++ b/java/jakarta/el/LocalStrings_pt_BR.properties
@@ -13,9 +13,41 @@
# 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
+
+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.invalidClass=A classe [{0}] deve ser pública, deve estar em um pacote exportado (para Java 9+) e não deve ser abstrata e uma interface
+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.notFound=Nenhum campo público estático denominado [{0}] foi localizado na classe (exportada para Java 9+) [{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})
-importHandler.invalidClassNameForStatic=A classe [{0}] especificada para o import estático [{1}] é inválida
diff --git a/java/jakarta/el/LocalStrings_ru.properties b/java/jakarta/el/LocalStrings_ru.properties
new file mode 100644
index 0000000..f57ed37
--- /dev/null
+++ b/java/jakarta/el/LocalStrings_ru.properties
@@ -0,0 +1,53 @@
+# 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.invalidClass=Класс [{0}] должен иметь спецификатор public, находиться в экспортированном пакете (для Java 9+), быть неабстрактным и не быть интерфейсом
+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.notFound=В классе [{1}] не найдено поле public static с именем [{0}] (экспортированное для Java 9+)
+staticFieldELResolver.notWritable=Запись в поле static (в данном случае это поле [{0}] в классе [{1}]) запрещена
+
+util.method.ambiguous=Не удалось однозначно найти метод: {0}.{1}({2})
+util.method.notfound=Метод не найден: {0}.{1}({2})
+
diff --git a/java/jakarta/el/LocalStrings_zh_CN.properties b/java/jakarta/el/LocalStrings_zh_CN.properties
index ae4905d..0558662 100644
--- a/java/jakarta/el/LocalStrings_zh_CN.properties
+++ b/java/jakarta/el/LocalStrings_zh_CN.properties
@@ -13,40 +13,40 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-beanNameELResolver.beanReadOnly=名称为[{0}]的bean只读
-
-elProcessor.defineFunctionInvalidClass=类[{0}]不是公共的
-elProcessor.defineFunctionInvalidMethod=类[{1}]的方法[{0}]不是公共静态方法
-elProcessor.defineFunctionInvalidParameterList=类[{2}]的方法[{1}]的参数列表[{0}]无效
-elProcessor.defineFunctionInvalidParameterTypeName=类[{2}]的方法[{1}]的参数类型[{0}]无效
-elProcessor.defineFunctionNoMethod=无法找到类[{1}]的公共静态方法[{0}]
-elProcessor.defineFunctionNullParams=一个或多个输入参数为null
-
-expressionFactory.cannotCreate=无法创建类型为[{0}]的表达式工厂
-expressionFactory.cannotFind=找不到类型为[{0}]的ExpressionFactory
-expressionFactory.readFailed=无法读取[{0}]
-
-importHandler.ambiguousImport=无法导入类[{0}]，因为它与已导入的[{1}]冲突
-importHandler.ambiguousStaticImport=无法处理静态导入[{0}]，因为它与已导入的[{1}]冲突
-importHandler.classNotFound=无法导入类[{0}]，因为无法找到它
-importHandler.invalidClass=类[{0}]必须是公共的、非抽象的、非接口且 在一个导出包
-importHandler.invalidClassName=要导入的类的名称[{0}]必须包含一个包。
-importHandler.invalidClassNameForStatic=类[{0}]指定的静态导入[{1}]无效
-importHandler.invalidStaticName=导入 [{0}] 的静态方法或字段名称必须包含类
-importHandler.staticNotFound=导入[{2}]的类[{1}]中找不到静态导入[{0}]
-
-lambdaExpression.tooFewArgs=仅为至少需要[{1}]个参数的lambda表达式提供了[{0}]个参数
-
-objectNotAssignable=无法将类型为[{0}]的对象添加到[{1}]类型的对象数组中
-propertyNotFound=类型[{0}]上找不到属性[{1}]
-propertyNotReadable=属性[{1}]在类型[{0}]上不可读
-propertyNotWritable=属性[{1}]在类型[{0}]上不可写
-propertyReadError=在类型[{0}]上读取[{1}]时出错
-propertyWriteError=在类型[{0}]上写入[{1}]时出错
-
-staticFieldELResolver.methodNotFound=在类[{1}]上找不到名为[{0}]的匹配的公共静态方法
-staticFieldELResolver.notFound=（Java 9+导出）类[{1}]上找不到名为[{0}]的公共静态字段
-staticFieldELResolver.notWritable=不允许写入静态字段（当前情况中为类[{1}]上的字段[{0}]）
-
-util.method.ambiguous=无法找到明确的方法：{0}.{1}({2})
+beanNameELResolver.beanReadOnly=Bean 名称 [{0}] 为只读项
+
+elProcessor.defineFunctionInvalidClass=类 [{0}] 不是公共类
+elProcessor.defineFunctionInvalidMethod=类 [{1}] 上的方法 [{0}] 不是公共静态方法
+elProcessor.defineFunctionInvalidParameterList=类 [{2}] 上方法 [{1}] 的参数列表 [{0}] 无效
+elProcessor.defineFunctionInvalidParameterTypeName=类 [{2}] 上方法 [{1}] 的参数类型 [{0}] 无效
+elProcessor.defineFunctionNoMethod=找不到类 [{1}] 上的公共静态方法 [{0}]
+elProcessor.defineFunctionNullParams=一个或多个输入参数为 null
+
+expressionFactory.cannotCreate=无法创建类型为 [{0}] 的 ExpressionFactory
+expressionFactory.cannotFind=找不到类型为 [{0}] 的 ExpressionFactory
+expressionFactory.readFailed=未能读取 [{0}]
+
+importHandler.ambiguousImport=未能导入类 [{0}]，因为它和已导入的 [{1}] 冲突
+importHandler.ambiguousStaticImport=未能处理静态导入 [{0}]，因为它和已导入的 [{1}] 冲突
+importHandler.classNotFound=未能导入类 [{0}]，因为找不到该类
+importHandler.invalidClass=在导出的包中（对于 Java 9+），类 [{0}] 必须是公用的，非抽象而不是接口
+importHandler.invalidClassName=要导入的类的名称 [{0}] 必须包含软件包
+importHandler.invalidClassNameForStatic=为静态导入 [{1}] 指定的类 [{0}] 无效
+importHandler.invalidStaticName=要导入的静态方法或字段的名称 [{0}] 必须包含类
+importHandler.staticNotFound=在导入 [{2}] 的类 [{1}] 中找不到静态导入 [{0}]
+
+lambdaExpression.tooFewArgs=对于至少需要 [{1}] 的 lambda 表达式，仅提供了 [{0}] 个自变量
+
+objectNotAssignable=无法将类型为 [{0}] 的对象添加到类型为 [{1}] 的对象阵列
+propertyNotFound=在类型 [{0}] 上未找到属性 [{1}]
+propertyNotReadable=属性 [{1}] 在类型 [{0}] 上不可读
+propertyNotWritable=属性 [{1}] 在类型 [{0}] 上不可写
+propertyReadError=在类型 [{0}] 上读取 [{1}] 时出错
+propertyWriteError=在类型 [{0}] 上写入 [{1}] 时出错
+
+staticFieldELResolver.methodNotFound=在类 [{1}] 上，找不到名为 [{0}] 的匹配公共静态方法
+staticFieldELResolver.notFound=在（导出的 Java 9+ ）类 [{1}] 上找不到名为 [{0}] 的公共静态字段
+staticFieldELResolver.notWritable=不允许写入静态字段（在此情况下，这是类 [{1}] 上的字段 [{0}]）
+
+util.method.ambiguous=找不到明确的方法：{0}.{1}({2})
util.method.notfound=找不到方法：{0}.{1}({2})
diff --git a/webapps/docs/changelog.xml b/webapps/docs/changelog.xml
index 24b7f43..ae875af 100644
--- a/webapps/docs/changelog.xml
+++ b/webapps/docs/changelog.xml
@@ -225,6 +225,10 @@
<add>
Improvements to Japanese translations contributed by tak7iji. (markt)
</add>
+ <add>
+ Expand coverage of translations for <code>jakarta.el</code> package.
+ Based on <pr>488</pr> from Volodymyr Siedlecki. (markt)
+ </add>
</changelog>
</subsection>
</section>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org