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-unsubscr...@tomcat.apache.org For additional commands, e-mail: dev-h...@tomcat.apache.org