{{#invoke:CS1 translator|function_name}}
Las plantillas admitidas por este módulo son sustituidas automáticamente por el usuario:AnomieBOT/docs/TemplateSubster porque no funcionan dentro de etiquetas. Las plantillas deben estar incluidas en la categoría:Plantillas de Wikipedia para que se sustituyan automáticamente .{{subst:}}<ref>...</ref>
.svg/1280px-Test_Template_Info-Icon_-_Version_(2).svg.png){kind=icon}
--[[ TODO: |título=Copia archivada -> |title=¿Copia archivada? ¿Otros idiomas? TODO: asegurarse de que el bot de citas no renombre incorrectamente las plantillas traducibles; ver $fix_it actualmente en https://github.com/ms609/citation-bot/blob/master/Template.php#L85 ]] require ( 'strict' ); local _month_xlate = require ( 'Módulo:Traductor de meses' ). _month_xlate ; local data = mw . loadData ( 'Módulo:Traductor/datos de CS1' ); local params_main_t = data . params_main_t ; local params_dates_t = data . params_dates_t ; local params_misc_dates_t = data . params_misc_dates_t ; local params_identifiers_t = data . params_identifiers_t ; local params_language_t = data . params_language_t ; local content_lang = mw . getContentLanguage (). code ; -- etiqueta de idioma de esta wiki --[[--------------------------< IN _ ARRAY >-------------------------------------------------------------- Si la aguja está en el pajar ]] función local in_array ( needle , haystack ) si la aguja == nil entonces devuelve falso ; fin para n , v en ipairs ( haystack ) si v == la aguja entonces devuelve n ; fin fin devuelve falso ; fin --[[--------------------------< ARGS _ GET >-------------------------------------------------------------- obtiene los nombres y valores de los parámetros en una tabla asociativa desde <frame> (los parámetros en #invoke) y desde el marco padre (los parámetros en la plantilla de llamada); establece todos los nombres de parámetros (claves) en minúsculas, omite los parámetros con valores de cadena vacía, omite los parámetros con valores de solo espacios en blanco, omite los nombres de parámetros duplicados (los nombres de los parámetros en el marco #invoke tienen precedencia sobre el mismo nombre de parámetro en el marco de plantilla). Esto reemplaza a Module:Arguments.getArgs() porque nos permite poner los nombres de los parámetros en minúsculas; algo que no se puede hacer con getArgs() devuelve <count> (la cantidad de parámetros agregados a <args_t>) porque #args_t no siempre funciona ]] local function args_get ( frame , args_t ) local count = 0 ; for _ , frame_t in ipairs ({ frame , frame : getParent ()}) do -- invocar primero el marco, luego el marco de plantilla for k , v in pairs ( frame_t . args ) do -- para cada parámetro en la tabla asociativa <frames_t.args> if 'string' == type ( k ) then -- ignorar los parámetros posicionales k = mw . ustring . lower ( k ); -- poner <k> más bajo aquí para que solo lo hagamos una vez; ustring porque ru.wiki si v y no ( args_t [ k ] o ( '' == v ) o ( v : match ( '^%s$' ))) entonces -- omitir cuando <args_t[k]> ya está presente, omitir cuando <v> es una cadena vacía, omitir cuando <v> es un espacio en blanco args_t [ k ] = v ; -- guardar el par k/v en en <args_t> count = count + 1 ; fin fin fin fin devolver count ; -- devuelve el número de parámetros en <args_t> fin --[[--------------------------< DATE _ MAKE >------------------------------------------------------------ <args_t> - tabla de pares k/v donde k es el nombre del parámetro no inglés y v es el valor asignado del marco <params_dates_t> - tabla de pares k/v_t donde k es la parte de fecha y v_t es una tabla de secuencia de nombres de parámetros que contienen fechas no inglesas <cite_args_t> - una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar si args_t[<date_param>] está establecido, traducir el nombre del mes (si es necesario) de lo contrario ensamblar y traducir la fecha a partir de las partes de fecha args_t[<year_param>], args_t[<month_param>], args_t[<day_param>]. El formato resultante siempre es dmy. Anular la configuración de todos los valores de fecha después de la fecha de creación. agregar la fecha traducida como cadena de texto a la tabla de secuencia <cite_args_t> los nombres de los meses en parámetros que no están en inglés |year= que contienen más de la parte del año de un dato (francés |année=8 mars 2007 por ejemplo) NO se traducen ]] función local date_make ( args_t , cite_args_t , params_dates_t ) fecha local , año , mes , día ; si params_dates_t . date_t entonces -- TODO: ¿hay una mejor manera de hacer esto? para _ , v en ipairs ( params_dates_t . date_t ) hacer - recorrer los parámetros que contienen la fecha date = args_t [ v ]; - será nulo si no está establecido if date then break end - si está establecido, hemos terminado end end if params_dates_t . year_t then para _ , v en ipairs ( params_dates_t . year_t ) hacer - recorrer los parámetros que contienen el año - también puede contener mes y/o día year = args_t [ v ]; - será nulo si no está establecido if year then break end - si está establecido, hemos terminado end end if params_dates_t . month_t then para _ , v en ipairs ( params_dates_t . month_t ) hacer - recorrer los parámetros que contienen el mes month = args_t [ v ]; -- será nulo si no se establece si es mes entonces interrumpe fin -- si se establece, hemos terminado fin fin si params_dates_t . day_t entonces para _ , v en ipairs ( params_dates_t . day_t ) hacer -- recorrer los parámetros que contienen el día day = args_t [ v ]; -- será nulo si no está configurado if day then break end -- si está configurado, hemos terminado end end if date then date = _month_xlate ({ date }); -- intentar traducción elseif year then -- if 'year'; sin año, cualquier parámetro 'mes' y/o 'día' espurio sin sentido; pasar como está a cs1|2 para manejo de errores if month then month = _month_xlate ({ month }); -- si hay un parámetro de mes, traducir su valor local date_parts_t = { day , month , year }; local date_t = {} para i = 1 , 3 hacer -- se hace de esta manera porque los miembros de <date_parts_t> pueden ser nulos si date_parts_t [ i ] entonces -- si no es nulo table.insert ( date_t , date_parts_t [ i ]); -- agregar a una tabla temporal end end date = table.concat ( date_t , ' ' ); -- crear la cadena de fecha dmy else -- date = year; -- no hay fecha, por lo que crea |date=<year> date = _month_xlate ({ year }); -- intentar la traducción si el nombre de mes de |year= no es inglés end year = nil ; -- ya no es necesario anular la configuración end local keys_t = { 'date_t' , 'year_t' , 'month_t' , 'day_t' }; para _ , clave en ipairs ( keys_t ) hacer -- recorrer la tabla de secuencia keys_t si params_dates_t [ clave ] entonces -- si hay una tabla coincidente para _ , param in ipairs ( params_dates_t [ key ]) do -- obtiene cada nombre de parámetro y args_t [ param ] = nil ; -- no establecido porque ya no es necesario end end end if date then table.insert ( cite_args_t , table.concat ({ 'date=' , date })); -- crea y guarda una cadena similar a un parámetro (sin barra vertical) if year then table.insert ( cite_args_t , table.concat ({ 'year=' , year })); -- haz lo mismo aquí; year porque tanto |date= como |year= están permitidos en cs1|2 end end end --[[--------------------------< MISC _ DATE _ MAKE >-------------------------------------------------- <args_t> - tabla de pares k/v donde k es el nombre del parámetro que no está en inglés y v es el valor asignado del marco <cite_args_t> - una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar <in_lang> - índice de código de idioma en la tabla de nombres de parámetros que no están en inglés TODO: translate |orig-date=? puede tener una fecha traducible pero también puede tener texto extraño... En este momento, _month_xlate() espera solo una fecha. ]] local function misc_date_make ( args_t , cite_args_t , in_lang ) local misc_date ; for _ , lang in ipairs ({ in_lang , 'en' }) do -- primero busca nombres que no estén en inglés luego, debido a que pueden estar presentes, busca nombres de parámetros en inglés for param , en_param in pairs ( data . params_misc_dates_t [ lang ]) do if args_t [ param ] then -- si el parámetro que no está en inglés tiene un valor misc_date = _month_xlate ({ args_t [ param ]}); -- traducir la tabla de fechas.insert ( cite_args_t , table.concat ({ en_param , '=' , misc_date })); -- hacer que el parámetro en inglés args_t [ param ] = nil ; -- sin establecer, el consumido ya no es necesario fin fin fin fin --[[--------------------------< SERIES _ MAKE >-------------------------------------------------------- ensamblar las distintas partes de la 'serie' en |series= series={{{Reihe|}}} {{{NummerReihe|}}} {{{BandReihe|}}} {{{HrsgReihe|}}} TODO: ¿esta función debería ser solo en alemán o necesita permitir otros idiomas? ¿Es el alemán el único idioma que combina múltiples elementos en |series=? ]] función local series_make ( args_t , cite_args_t ) serie_t local = {}; parámetros locales = { 'reihe' , 'nummerreihe' , 'bandreihe' , 'hrsgreihe' }; para _ , parámetro en ipairs ( params ) hacer si args_t [ parámetro ] entonces tabla.insert ( series_t , args_t [ parámetro ]); -- agregar a la secuencia temporal tabla args_t [ parámetro ] = nil ; -- no establecido, ya no es necesario fin fin si 0 ~= # series_t entonces serie local = tabla.concat ( series_t , ', ' ); -- concatenar los parámetros que estén presentes tabla.insert ( cite_args_t , tabla.concat ({ 'series=' , series })); -- y hacer un parámetro fin fin --[[--------------------------< ISXN _ MAKE >------------------------------------------------------------ hacer un parámetro |isbn= o |issn=. Esta función aplica el marcado ((accept-as-written)) cuando hay algún tipo de parámetro equivalente a la función local isxn_make ( args_t , cite_args_t , type , aliases_t , ignore_params_t ) de cs1|2 (ahora obsoleta) |ignore-isbn-error= ]] , ignore_values_t ) isxn local ; ignore_value local ; para _ , v en ipairs ( aliases_t ) hacer - recorrer la tabla de secuencias aliases_t si args_t [ v ] entonces isxn = args_t [ v ]; fin args_t [ v ] = nil ; - no establecido porque ya no es necesario fin para _ , v en ipairs ( ignore_params_t ) hacer - recorrer la tabla de secuencias ignor_params_t si args_t [ v ] entonces ignore_value = args_t [ v ]; fin args_t [ v ] = nil ; -- no establecido porque ya no se necesita end if isxn and ignore_value and ( in_array ( ignore_value , ignore_values_t ) or ignore_values_t [ '*' ]) then -- <ignore_values_t> es una tabla de valores que evalúan 'sí' o comodín table.insert ( cite_args_t , table.concat ({ type , '=((' , isxn , '))' })); -- crea un parámetro pero acepta este isxn como está escrito end end --[[--------------------------< AT _ MAKE >---------------------------------------------------------------- crea |at= para aquellas plantillas que tienen cosas como |column=. No calificado por |page= o |pages= para que cs1|2 emita un mensaje de error cuando estén presentes tanto |at= como |page(s)=. <aliases_t> es una tabla de secuencia de nombres de parámetros que no están en inglés <prefix> - cadena de texto que antepone el valor en <alias>; 'col.' por ejemplo ]] función local at_make ( args_t , cite_args_t , aliases_t , prefijo ) para _ , alias en ipairs ( aliases_t ) hacer si args_t [ alias ] entonces tabla.insert ( cite_args_t , tabla.concat ({ prefijo , args_t [ alias ]})); fin args_t [ alias ] = nil ; -- sin establecer, ya no es necesario fin fin --[[--------------------------< CHAPTER _ MAKE _ FR >------------------------------------------------ make |chapter= de la concatenación del número de capítulo (si está presente) y el nombre del capítulo; nombre del capítulo else ]] función local chapter_make_fr ( args_t , cite_args_t ) capítulo local = args_t [ 'título chapitre' ] o args_t [ 'chapitre' ]; si capítulo y ( args_t [ 'numéro chapitre' ] o args_t [ 'numéro' ]) entonces - cuando los números de capítulo, concatene el número con el nombre del capítulo capítulo = ( args_t [ 'numéro chapitre' ] o args_t [ 'numéro' ]) .. '' .. capítulo ; table.insert ( cite_args_t , 'chapter=' ..capítulo ) ; elseif capítulo entonces table.insert ( cite_args_t , 'chapter=' .. capítulo ); -- aquí cuando el capítulo sin número termina args_t [ 'titre chapitre' ] = nil ; -- desarmado porque ya no es necesario args_t [ 'chapitre' ] = nil ; args_t [ 'número capítulo' ] = nil ; args_t [ 'número' ] = nil ; fin --[[--------------------------< ID _ MAKE >---------------------------------------------------------------- crea una lista separada por comas de identificadores que se incluirán en |id= <params_identifiers_t> es una tabla de secuencia de tablas de secuencia donde: [1] es el nombre del parámetro no inglés normalizado a minúsculas [2] es la etiqueta de wikitexto asociada que se usará en la representación [3] es el prefijo de URL que se adjuntará al valor del identificador del parámetro de plantilla [4] es el sufijo de URL que se adjuntará al valor del identificador ]] función local id_make ( frame , args_t , cite_args_t , params_identifiers_t ) id_t local = {}; valor local ; para _ , identificador_t en ipairs ( params_identifiers_t ) hacer si args_t [ identificador_t [ 1 ]] entonces -- si este parámetro identificador tiene un valor valor_t local = {} si identificador_t [ 2 ] entonces -- si hay una etiqueta (todas excepto |id= deben tener una etiqueta) tabla.insert ( valor_t , identificador_t [ 2 ]); -- la etiqueta tabla.insert ( valor_t , ': ' ); -- la puntuación y el espaciado necesarios si identifier_t [ 3 ] entonces -- si es un prefijo de enlace externo table.insert ( value_t , '[' ); -- abrir marcado de enlace externo table.insert ( value_t , identifier_t [ 3 ]); -- el prefijo del enlace table.insert ( value_t , args_t [ identifier_t [ 1 ]]); -- el valor del identificador si identifier_t [ 4 ] entonces -- ¿sufijo? table.insert ( value_t , identifier_t [ 4 ]); -- el sufijo final del enlace table.insert ( value_t , ' ' ); -- requerir espacio entre la URL y la etiqueta table.insert ( value_t , args_t [ identifier_t [ 1 ]]); -- el valor del identificador como etiqueta table.insert ( value_t , ']' ); -- cerrar el marcado extlink else table.insert ( value_t , args_t [ identifier_t [ 1 ]]); -- el valor del identificador end else table.insert ( value_t , args_t [ identifier_t [ 1 ]]); -- sin etiqueta, por lo que solo el valor end table.insert ( id_t , table.concat ( value_t )); -- agregar a la secuencia temporal table args_t [ identifier_t [ 1 ]] = nil ; -- sin establecer, ya no es necesario end end if 0 ~= # id_t then local id = table.concat ( id_t , ', ' ); -- concatenar los parámetros que estén presentes en una lista separada por comas table.insert ( cite_args_t , table.concat ({ 'id=' , id })); -- y hacer que un parámetro termine --[[--------------------------< TITLE _ MAKE _ FR >---------------------------------------------------- join |title= with |subtitle= to make new |title= ]] local function title_make_fr ( args_t , cite_args_t ) local title = args_t [ 'titre' ]; -- obtener el parámetro de título 'requerido' args_t [ 'titre' ] = nil ; -- anular la configuración porque ya no es necesario si no es título entonces título = args_t [ 'titre original' ] o args_t [ 'titre vo' ]; -- si |titre= está vacío o falta, use uno de estos 'alias' args_t [ 'titre original' ] = nil ; -- anular la configuración porque ya no es necesario args_t [ 'titre vo' ] = nil ; fin si título entonces -- solo cuando hay un título si args_t [ 'subtítulo' ] entonces -- añadir subtítulo si está presente title = title .. ': ' .. args_t [ 'subtítulo' ]; args_t [ 'subtítulo' ] = nil ; -- desconfigurar porque ya no se necesita end table.insert ( cite_args_t , 'title=' .. ( title o '' )); -- añadir a cite_args_t end end --[[--------------------------< TITLE _ MAKE _ PT >---------------------------------------------------- unir |title= con |subtitle= para crear nuevo |title= ]] función local title_make_pt ( args_t , cite_args_t ) título local = args_t [ 'título' ] o args_t [ 'titulo' ] o args_t [ 'titlo' ]; -- obtener el parámetro de título 'requerido' args_t [ 'título' ] = nil ; -- desarmado porque ya no es necesario args_t [ 'titulo' ] = nil ; args_t [ 'título' ] = nil ; si no es título entonces devuelve fin si args_t [ 'subtítulo' ] o args_t [ 'subtitulo' ] entonces -- agrega subtítulo si presente título = título .. ': ' .. ( args_t [ 'subtítulo' ] o args_t [ 'subtitulo' ]); args_t [ 'subtítulo' ] = nil ; -- desarmado porque ya no es necesario args_t [ 'subtitulo' ] = nil ; end table.insert ( cite_args_t , 'title=' .. ( título o '' )); -- agregar al final de cite_args_t --[[--------------------------< URL _ STATUS _ MAKE >------------------------------------------------ <aliases_t> es una tabla de secuencia de alias de parámetros |dead-url= <no_values_t> es una tabla de pares k/v donde k es un valor de parámetro válido que significa 'no' como en |dead-url=no (es decir, |url-status=live) ]] función local url_status_make ( args_t , cite_args_t , aliases_t , no_values_t ) para _ , alias en ipairs ( aliases_t ) hacer -- recorrer la tabla de secuencia aliases_t si args_t [ alias ] y no_values_t [ args_t [ alias ]] entonces -- si el alias tiene un valor y el valor equivale a 'no' tabla.insert ( cite_args_t , 'url-status=live' ) fin args_t [ alias ] = nada ; -- no establecido porque ya no es necesario fin fin --[[--------------------------< URL _ ACCESS _ MAKE >------------------------------------------------ <aliases_t> es una tabla de secuencia de alias de parámetros |subscription= o |registration= <values_t> es una tabla de pares k/v donde k es un valor de parámetro válido que significa 'sí' como en |subscription=yes (es decir, |url-access=subscription) <values_t> puede tener un comodín ('*'=true) que indica que cualquier cosa asignada a |subscription= o |registration= es suficiente ]] función local url_access_make ( args_t , cite_args_t , type , aliases_t , values_t ) para _ , alias en ipairs ( aliases_t ) hacer -- recorrer la tabla de secuencia aliases_t si in_array ( args_t [ alias ], values_t ) o ( args_t [ alias ] y values_t [ '*' ]) entonces -- si el alias tiene un valor y el valor equivale a 'sí' o al comodín si 'suscripción' == tipo entonces table.insert ( cite_args_t , 'url-access=subscription' ) else table.insert ( cite_args_t , 'url-access=registration' ) end end args_t [ alias ] = nil ; -- sin establecer porque ya no es necesario end end --[[--------------------------< LANGUAGE _ TAG _ GET >---------------------------------------------- Pruebe <lang> para ver si es una etiqueta de idioma conocida. Si lo es, devuelva <lang>. Cuando <lang> no es una etiqueta de idioma conocida, busque en <known_langs_t> <lang> como nombre de idioma; si se encuentra, devuelva la etiqueta de idioma asociada; <lang> else. ]] función local language_tag_get ( known_langs_t , lang ) si mw . language . isKnownLanguageTag ( lang ) entonces devuelva lang ; -- <lang> es una etiqueta de idioma conocida ('en', 'da', etc.); devuelve la etiqueta end local lang_lc = lang : lower (); -- hace una copia en minúsculas para comparaciones para etiqueta , nombre en pares ( known_langs_t ) do -- recorre <known_langs_t> if lang_lc == name : lower () then -- buscando <lang_lc> return tag ; -- lo encuentra, devuelve la etiqueta de idioma asociada end end return lang ; -- no es un idioma o etiqueta conocidos; devuelve como está end --[[--------------------------< LANGUAGE _ MAKE >---------------------------------------------------- esta función mira <lang_param_val> para ver si es una etiqueta de idioma conocida por WikiMedia. Si es una etiqueta de idioma conocida, agrega |language=<lang_param_val> a cite_args_t y anula los valores de args_t[<lang_param>]. Cuando <lang_param_val> no es una etiqueta de idioma conocida, obtiene una tabla ak/v de etiquetas y nombres de idiomas conocidos de MediaWiki para el idioma <in_lang> (una etiqueta de idioma), donde 'k' es una etiqueta de idioma y 'v' es el nombre del idioma asociado. Busca en esa tabla <lang_param_val>. Si lo encuentra,agrega |language=<tag> a cite_args_t y anula el valor de args_t[<lang_param>] esta función no realiza ninguna acción y no devuelve nada cuando no se conoce <lang_param_val>. Se espera que los nombres de los idiomas estén escritos con mayúscula y de forma correcta según las reglas de la wiki de origen, por lo que la coincidencia debe ser exacta. ]] local function language_make ( args_t , cite_args_t , in_lang , lang_params_t ) local lang_param ; local lang_param_val ; for _ , v in ipairs ( lang_params_t [ in_lang ]) do -- recorrer la lista de parámetros de 'idioma' admitidos en <in_lang>.wiki if args_t [ v ] then -- si este parámetro tiene un valor lang_param = v ; -- guardar el nombre del parámetro lang_param_val = args_t [ v ]; -- guardar el valor del parámetro end args_t [ v ] = nil ; -- unset no es necesario; si se establecen varios parámetros de 'idioma', usamos el 'último' end if not lang_param_val then return ; -- no hay parámetro 'idioma' en esta plantilla, por lo que se hace fin localknown_langs_t = mw . language . fetchLanguageNames ( in_lang , 'all' ); -- obtiene la tabla k/v de nombres de idiomas de MediaWiki para <in_lang> language; (el par k/v es ['tag'] = 'name') local tag = language_tag_get ( known_langs_t , lang_param_val ); -- devuelve una etiqueta de idioma válida o el contenido de <lang_param_val> table.insert ( cite_args_t , table.concat ({ 'language=' , tag })); -- prefiere 'tag' porque es más traducible args_t [ lang_param ] = nil ; -- no está establecido porque ya no es necesario fin --[[---------------------------< LANGUAGE _ MAKE _ PT >---------------------------------------------- Caso especial para pt que admite algunos parámetros de 'idioma' que no están enumerados y algunos parámetros de 'idioma' que sí están enumerados. Inspecciona los parámetros no enumerados |codling=, |in= y |ling=; si hay alguno establecido, devuelve el valor. Si no hay ninguno establecido, inspecciona los parámetros enumerables |idioma=, |língua=, |lingua= en ese orden. Recopila el valor de uno de los parámetros no enumerados y devuelve ese valor o recopila todos los valores de un conjunto de parámetros enumerables y devuelve solo ese conjunto de idiomas. Si otros parámetros no enumerados tienen valores u otros conjuntos de parámetros enumerables tienen valores, se ignoran para que la plantilla emita errores de parámetros no reconocidos por la mezcla incorrecta de nombres de parámetros. TODO: ¿es posible compartir esto con pl? ]] función local language_make_pt ( args_t , cite_args_t ) localknown_langs_t = mw . language . fetchLanguageNames ( 'pt' , 'all' ); -- obtiene una tabla de nombres de idiomas conocidos y etiquetas para el idioma local portugués ; for _ , lang_param in ipairs ({ 'codling' , 'in' , 'ling' }) do -- parámetros de idioma no enumerados if args_t [ lang_param ] then language = args_t [ lang_param ]; args_t [ lang_param ] = nil ; return language_tag_get ( known_langs_t , language ); -- intentar obtener una etiqueta de idioma; devolver etiqueta o <idioma> end end local langs_t = {}; for _ , lang_param in ipairs ({ 'idioma' , 'lingua' , 'lingua' }) do -- para cada conjunto de parámetros de idioma enumerables local i = 1 ; -- crear un enumerador while 1 do -- bucle para siempre if i == 1 then if args_t [ lang_param ] or args_t [ lang_param .. i ] then -- si no está enumerado o su alias enumerado table.insert ( langs_t , ( args_t [ lang_param ] o args_t [ lang_param .. i ])); -- prefiere no enumerado args_t [ lang_param ] = nil ; -- no se establece porque ya no se necesita args_t [ lang_param .. i ] = nil ; de lo contrario break ; -- no hay parámetros <lang_param> o <lang_param1>; salir de while end elseif args_t [ lang_param .. i ] then table.insert ( langs_t , args_t [ lang_param .. i ]); args_t [ lang_param .. i ] = nil ; -- no establecido porque ya no es necesario elseif 0 ~= # langs_t then -- aquí cuando <lang_param..(i-1)> pero no <lang_param..i> for i , lang in ipairs ( langs_t ) do -- recorrer <langs_t> y langs_t [ i ] = language_tag_get ( known_langs_t , lang ); -- intentar obtener una etiqueta de idioma; devuelve etiqueta o <lang> end return table.concat ( langs_t , ', ' ); -- crear una cadena y listo else break ; -- no hay parámetro <lang_param .. i>; salir de while; no debería llegar aquí end i = i + 1 ; -- bump el enumerador end end end --[[--------------------------< NOMBRE _ LISTA _ ESTILO _ HACER >-------------------------------------- <aliases_t> es una tabla de secuencia de alias de parámetros |name-list-style= <values_t> es una tabla de pares k/v donde 'k' es el valor del parámetro que no está en inglés y 'v' es su traducción para parámetros que son traducciones |last-author-amp=, en la llamada de función escriba: {['*'] = 'amp'} ]] función local name_list_style_make ( args_t , cite_args_t , aliases_t , values_t ) para _ , alias en ipairs ( aliases_t ) hacer -- recorrer la secuencia aliases_t tabla si args_t [ alias ] y ( values_t [ args_t [ alias ]] o values_t [ '*' ]) entonces -- si el alias tiene un valor reconocido tabla.insert ( cite_args_t , tabla.concat ({ 'name-list-style=' , values_t [ args_t [ alias ]] o values_t [ '*' ]})); fin args_t [ alias ] = nil ; -- no establecido porque ya no es necesario end end --[[--------------------------< RENDER >------------------------------------------------------------------ renderizador común que traduce parámetros (después de traducciones de casos especiales) y luego renderiza la plantilla cs1|2 ]] función local render ( frame , args_t , cite_args_t , params_main_t , template , lang_tag ) local out_t = {} -- tabla asociativa para frame:expandTemplate local expand = args_t . expand ; -- guardar el contenido de |expand= para renderizar una versión nowiki de la plantilla traducida args_t . expand = nil ; -- no establecido para que no pasemos a cs1|2 para param , val en pares ( args_t ) hacer -- para cada parámetro en la plantilla si val y ( 'subst' ~= param ) entonces -- cuando tiene un valor asignado; omitir '|subst=subst:' (de AnomieBOT cuando sustituye la plantilla cs1) enumeración local = parámetro : match ( '%d+' ); -- obtener el enumerador si <param> está enumerado; nulo en caso contrario local param_key = param : gsub ( '%d+' , '#' ); -- reemplaza el enumerador con '#' si <param> está enumerado si params_main_t [ param_key ] entonces -- si params_main_t[<param_key>] se asigna a un parámetro de plantilla cs1|2 local en_param = params_main_t [ param_key ]; si enum entonces en_param = en_param : gsub ( '#' , enum ); -- reemplaza '#' en el parámetro cs1|2 enumerado con el enumerador del parámetro no inglés end table.insert ( cite_args_t , table.concat ({ en_param , '=' , val })); -- usa el parámetro cs1|2 con el enumerador si está presente de lo contrario table.insert ( cite_args_t , table.concat ({ param , '=' , val })); -- usar parámetro no inglés end end end local language = mw . language . fetchLanguageName ( lang_tag , content_lang ); xlated_msg local = table.concat ({ '<!-- traducido automáticamente de ' , ( '' == language ) y lang_tag o language , -- normalmente language pero hay 'desconocido (italiano o español)' ' por el traductor de Módulo:CS1 -->' }); si se expande entonces -- para ver la traducción como una plantilla sin procesar, crea una versión nowiki table.sort ( cite_args_t ); -- ordenar para que la representación de nowiki sea bastante local xlation = table.concat ({ '{{' , plantilla , ' |' , table.concat ( cite_args_t , ' |' ), '}}' }); -- la cadena de plantilla devuelve frame : preprocess ( table.concat ({ '<syntaxhighlight lang="wikitext" inline="1">' , xlation , xlated_msg , '</syntaxhighlight>' })); fin para _ , arg en ipairs ( cite_args_t ) hacer - recorrer la tabla de secuencia de parámetros local param , val = arg : match ( '^([^=]+)=(.+)' ); - dividir la cadena de parámetros si nil == param entonces error ( mw.dumpObject ( cite_args_t ) ) fin out_t [ param ] = val ; - y poner los resultados en la tabla de salida fin devolver tabla.concat ({ frame : expandTemplate ({ title = template , args = out_t }), xlated_msg }) ; -- renderizar la plantilla {{<template>}} con los parámetros traducidos fin --[[---------------------------< FECHAS _ Y _ IDIOMA >------------------------------------------ funciones de parámetros de fecha e idioma utilizadas para casi todas las traducciones (pl y pt admiten parámetros de idioma enumerados) ]] función local dates_and_language ( args_t , cite_args_t , in_lang ) date_make ( args_t , cite_args_t , params_dates_t [ in_lang ]); -- ensamblar y traducir |date= misc_date_make ( args_t , cite_args_t , in_lang ); language_make ( args_t , cite_args_t , in_lang , params_language_t ); -- traducir el idioma del alemán al final de la etiqueta del idioma apropiado --[[=========================<< FUNCIONES _ COMBINADAS >>================================================= ]] --[[--------------------------< _ CITE _ AR >-------------------------------------------------------- Función común a implementar: {{citar libro/árabe}} (ar:قالب:استشهاد بكتاب) {{citar diario/árabe}} (ar:قالب:استشهاد بدورية محكمة) {{citar noticias/árabe{{ (ar:قالب:استشهاد بخبر) {{citar web/árabe}} (ar:قالب:استشهاد ويب) ]] función local _cite_ar ( marco , plantilla ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores locales cite_args_t = {}; -- una tabla de secuencia que contiene cadenas de parámetro=valor (sin canalizaciones); para ordenar - casos especiales fechas_y_idioma ( args_t , cite_args_t , 'ar' ); -- traducir fechas y parámetros de idioma -- url_status_make (args_t, cite_args_t, {'deadurl', 'dead-url', 'dodeurl', 'dode-url'}, {['no'] = true, ['nee' ] = true}); -- sin palabras clave de estado en árabe 2023-12-08 -- id_make (frame, args_t, cite_args_t, params_identifiers_t.ar ) ; -- ensamblar |id= return render ( frame , args_t , cite_args_t , params_main_t .ar , plantilla , 'ar' ); -- ahora ve a renderizar el final de la cita --[[--------------------------< CITE _ BOOK _ AR >----- ------------------------------------------------- entrada punto para {{cite book/Arabic}} ]] función local cite_book_ar ( frame ) return _cite_ar ( frame , 'cite book/subst' ); fin --[[-------------- ------------< CITA _ REVISTA _ AR >------------------------------- ----------------- punto de entrada para {{cite journal/Arabic}} ]] función local cite_journal_ar ( frame ) return _cite_ar ( frame , 'cite journal/subst' ); fin --[[---------------------------< CITA _ NOTICIAS _ AR >------------- ----------------------------------------- punto de entrada para {{cite news/Arabic }} ]] función local cite_news_ar ( frame ) return _cite_ar ( frame , 'cite news/subst' ); fin --[[--------------------------< CITE _ WEB _ AR >-------------------------------------------------------- punto de entrada para {{cite web/Arabic}} ]] función local cite_web_ar ( frame ) return _cite_ar ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ CA >-------------------------------------------------------------- Función común a implementar: {{cite book/Catalan}} (ca:Plantilla:Ref-llibre) {{cite journal/Catalan}} (ca:Plantilla:Ref-publicació) {{cite news/Catalan}} (ca:Plantilla:Ref-notícia) {{cite web/Catalan}} (ca:Plantilla:Ref-web) ]] función local _cite_ca ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'ca' ); -- traducir parámetros de fechas e idioma return render ( frame , args_t , cite_args_t , params_main_t . ca , template , 'ca' ); -- ahora ve a renderizar la cita end --[[--------------------------< CITE _ BOOK _ CA >------------------------------------------------------ punto de entrada para {{cite book/Catalan}} ]] función local cite_book_ca ( frame ) return _cite_ca ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ NEWS _ CA >------------------------------------------------------ punto de entrada para {{cite news/Catalan}} ]] función local cite_news_ca ( frame ) return _cite_ca ( frame , 'cite news/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ CA >------------------------------------------------ punto de entrada para {{cite journal/Catalan}} ]] función local cite_journal_ca ( frame ) return _cite_ca ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ WEB _ CA >-------------------------------------------------------- punto de entrada para {{cite web/Catalan}} ]] función local cite_web_ca ( frame ) return _cite_ca ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ DA >-------------------------------------------------------------- <includeonly>{{safesubst:<noinclude />#invoke:Sandbox/trappist_the_monk/Literatur|cite_journal_da}}</includeonly><noinclude>{{documentation}}</noinclude> Función común a implementar: {{cite book/Danish}} (da:Skabelon:Kilde bog) {{cite journal/Danish}} (da:Skabelon:Kilde ) {{cite web/Danish}} (da:Skabelon:Kilde www) ]] función local _cite_da ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas de parámetros=valores (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'da' ); -- traducir parámetros de fechas e idioma url_status_make ( args_t , cite_args_t , { 'dead-url' , 'deadurl' , 'dødtlink' , 'dødlenke' , 'deadlink' , 'død-lenke' }, {[ 'no' ] = true , [ 'nej' ] = true }); url_access_make ( args_t , cite_args_t , 'subscription' ,{ 'suscripción' , 'abonnement' }, { 'sí' , 'verdadero' , 'y' , 'ja' , 'arena' , 'j' }); url_access_make ( args_t , cite_args_t , 'registro' , { 'registro' }, { 'sí' , 'verdadero' , 'y' , 'ja' , 'arena' , 'j' }); isxn_make ( args_t , cite_args_t , 'isbn' , { 'isbn' , 'isbn13' }, { 'ignorer-isbn-fejl' , 'ignoreisbnerror' , 'ignore-isbn-error' }, { 'sí' , 'verdadero' , 'y' , 'ja' , 'arena' , 'j' }); return render ( frame , args_t , cite_args_t , params_main_t . da , template , 'da' ); -- ahora ve a renderizar la cita fin --[[------------------ --------< CITA _ LIBRO _ DA >----------------------------------- ------------------- punto de entrada para {{cite book/Danish}} ]] función local cite_book_da ( frame ) return _cite_da ( frame , 'cite book/subst' ) ; fin --[[--------------------------< CITE _ JOURNAL _ DA >----------- ------------------------------------- punto de entrada para {{cite journal/Danish}} ]] función local cite_journal_da ( frame ) devuelve _cite_da ( frame , 'cite journal/subst' ); fin --[[-------------------------- < CITE _ WEB _ DA >------------------------------------------- ------------- punto de entrada para {{cite web/Danish}} Esta función es llamada por la función intermedia cite_web_da_no() porque da.wiki y no.wiki ambos usan {{kilde www}} ]] función local cite_web_da ( frame ) return _cite_da ( frame) , 'cite web/subst' ); fin --[[---------------------------< _ CITE _ DE >-------------------------------------------------------------- implementa {{Literatur}} (de:Vorlage:Literatur), {{Cite web/German}} (de:Vorlage:Internetquelle) ]] función local _cite_de ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtiene los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'de' ); -- traduce fechas y parámetros de idioma series_make ( args_t , cite_args_t ); -- ensambla |series= local isxn ; para _ , param en ipairs ({ 'isbnformalfalsch' , 'isbndefekt' }) hacer -- estos dos parámetros toman un isbn 'roto' pero válido if args_t [ param ] then isxn = table.concat ({ 'isbn=((' , args_t [ param ], '))' }); -- crear |isbn=((<isbn roto>)) end args_t [ param ] = nil ; -- no establecido porque ya no es necesario end if isxn then table.insert ( cite_args_t , isxn ); -- guardar el parámetro end if args_t [ 'issnformalfalsch' ] then -- estos parámetros toman un issn 'roto' pero válido isxn = table.concat ( { 'issn=((' , args_t [ 'issnformalfalsch' ], '))' }); -- crear |issn=((<issn roto>)) tabla.insert ( cite_args_t , isxn ); -- guardar el parámetro end args_t [ 'issnformalfalsch' ] = nil ; -- no establecido porque ya no es necesario at_make ( args_t , cite_args_t , { 'Spalten' }, 'col.' ); -- ensamblar |at=col. ... id_make ( frame , args_t , cite_args_t , params_identifiers_t . de ); -- ensamblar |id= if args_t . hrsg then if template == 'cite web/subst' then -- cite web/German tiene un significado diferente al de en de:Vorlage:Literatur (cite book/German) table.insert ( cite_args_t , table.concat ({ 'publisher=' , args_t . hrsg })); else - significado diferente del significado de este mismo parámetro en de:Vorlage:Internetquelle (cite web/German) table.insert ( cite_args_t , table.concat ( { 'editor=' , args_t.hrsg})); end args_t.hrsg = nil; - no establecido, ya no es necesario end if args_t.offline then args_t.offline = nil ; - cualquier valor significa | url - status = dead ; no hay ninguna forma de este parámetro que signifique |url-status=live; así que simplemente no se establece end return render ( frame , args_t , cite_args_t , params_main_t.de , template , ' de ' ); -- ahora ve a renderizar la cita fin --[[--------------------------< CITE _ BOOK _ DE >------------------------------------------------------ punto de entrada para {{cite book/German}} ]] función local cite_book_de ( frame ) return _cite_de ( frame , 'citation/subst' ); -- TODO: ¿cambiar esto a 'cite book/German'? fin --[[--------------------------< CITE _ WEB _ DE >-------------------------------------------------------- punto de entrada para {{cite web/German}} ]] función local cite_web_de ( frame ) return _cite_de ( frame , 'cite web/subst' ); -- TODO: ¿cambiar esto a 'cite book/German'? fin --[[--------------------------< _ CITE _ ES >---------------------------------------------------------- implementa {{Cita libro}} (:es:Plantilla:Cita_libro) ]] función local _cite_es ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtiene los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'es' ); -- traducir fechas y parámetros de idioma url_status_make ( args_t , cite_args_t , { 'urlmuerta' }, {[ 'no' ] = true }); url_access_make ( args_t , cite_args_t , 'subscription' , { 'suscripción' , 'subscription' }, {[ '*' ] = true }); url_access_make ( args_t , cite_args_t , 'registro' , { 'registro' , 'requiere-registro' , 'requiereregistro' , 'registro' }, {[ '*' ] = true }) isxn_make ( args_t , cite_args_t , 'isbn' , { 'isbn' , 'isbn13' }, { 'ignore-isbn-error' , 'ignoreisbnerror' }, {[ '*' ] = verdadero }); -- |ignore-isbn-error=<cualquier cosa> nombre_lista_estilo_make ( args_t ,cite_args_t , { 'y comercial' , 'lastauthoramp' , 'last-author-amp' }, {[ '*' ] = 'amp' }); return render ( frame , args_t , cite_args_t , params_main_t . es , template , 'es' ); -- ahora ve a renderizar la cita end --[[--------------------------< CITE _ BOOK _ ES >------------------------------------------------------ punto de entrada para {{cita book}} (es:Plantilla:Cita publicación) ]] local function cite_book_es ( frame ) return _cite_es ( frame , 'cite book/subst' ); end --[[--------------------------< CITE _ JOURNAL _ ES >-------------------------------------- punto de entrada para {{cita publicación}} (es:Plantilla:Cita publicación) ]] local function cite_journal_es ( frame ) return _cite_es ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ NEWS _ ES >------------------------------------------------------ punto de entrada para {{cita news}} (español: {{cita noticia}}) ]] función local cite_news_es ( frame ) return _cite_es ( frame , 'cite news/subst' ); fin --[[--------------------------< CITE _ WEB _ ES >-------------------------------------------------------- punto de entrada para {{cita web}} (español: {{cita web}}) ]] función local cite_web_es ( frame ) return _cite_es ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ FI >-------------------------------------------------------------- implementa {{Kirjaviite}} :fi:Malline:Kirjaviite ]] función local _cite_fi ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'fi' ); -- traducir parámetros de fechas e idioma at_make ( args_t , cite_args_t , { 'palsta' , 'palstat' }, 'col. ' ) return render ( frame , args_t , cite_args_t , params_main_t . fi , template , 'fi' ); -- ahora ve a renderizar la cita end --[[--------------------------< CITE _ BOOK _ FI >------------------------------------------------------ punto de entrada para {{cite book/Finnish}} ]] función local cite_book_fi ( frame ) return _cite_fi ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ FI >------------------------------------------------ punto de entrada para {{cite journal/Finnish}} ]] función local cite_journal_fi ( frame ) return _cite_fi ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ WEB _ FI >-------------------------------------------------------- punto de entrada para {{cite web/Finnish}} ]] función local cite_web_fi ( frame ) return _cite_fi ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ FR >-------------------------------------------------------------- implementa {{cite book/French}} (:fr:Modèle:Ouvrage) ]] función local _cite_fr ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'fr' ); -- traducir parámetros de fechas e idioma if template : find ( 'book' , 1 , true ) then chapter_make_fr ( args_t , cite_args_t ) else if args_t [ 'numéro' ] then cite_args_t . issue = args_t [ 'numéro' ]; args_t [ 'numéro' ] = nil ; end end title_make_fr ( args_t , cite_args_t ); si args_t [ 'acceso url' ] entonces valores locales = {[ 'inscripción' ] = 'suscripción' , [ 'pagador' ] = 'suscripción' , [ 'limitado' ] = 'limitado' , [ 'libre' ] = 'libre' }; -- 'libre' no es compatible; inclúyalo para obtener el mensaje de error table.insert ( cite_args_t , 'url-access=' .. ( values [ args_t [ 'acceso url' ]] or args_t [ 'acceso url' ])); args_t [ 'acceso url' ] = nil ; fin url_status_make ( args_t , cite_args_t , { 'dead-url' }, {[ 'no' ] = true , [ 'non' ] = true }); si 'oui' == args_t [ 'et al.' ] o 'oui' == args_t [ 'et alii' ] entonces -- valor aceptado 'oui'; caso especial |display-authors=etal table.insert ( cite_args_t , 'display-authors=etal' ); args_t [ 'et al.' ] = nil ; -- no se establece porque ya no es necesario args_t [ 'et alii' ] = nil ; fin si args_t [ 'isbn erroné' ] entonces table.insert ( cite_args_t , 'isbn=((' .. args_t [ 'isbn erroné' ] .. '))' ); -- aplicar marcado de aceptación tal como está escrito args_t [ 'isbn' ] = nil ; -- no puede haber |isbn= y |isbn erroné= args_t [ 'isbn erroné' ] = nil ; -- no se establece porque ya no es necesario fin volumen local ; si args_t [ 'título volumen' ] o args_t [ 'tomo' ] entonces si args_t [ 'tomo' ] entonces volumen = args_t [ 'tomo' ]; -- comienza con el volumen 'número' fin si volumen entonces volumen = volumen .. ' ' .. args_t [ 'tomo' ]; -- añade el volumen 'título' de lo contrario volumen = args_t [ 'título volumen' ]; -- solo el volumen 'título' fin args_t [ 'título volumen' ] = nil ; -- no se establece porque ya no es necesario args_t [ 'tomo' ] = nil ; fin id_make ( frame , args_t , cite_args_t , params_identifiers_t .es ); -- ensamblar |id= si args_t [ 'páginas' ] entonces args_t [ 'páginas' ] = nil ; -- no establecido; alias de |páginas totales=; no hay equivalente en cs1|2 fin devolver render ( frame , args_t , cite_args_t , params_main_t . fr , template , 'fr' ); -- ahora ve a renderizar la cita fin --[[--------------------------< CITE _ BOOK _ FR >------------------------------------------------------ punto de entrada para {{cite book/French}} ]] función local cite_book_fr ( frame ) return _cite_fr ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ FR >------------------------------------------------ punto de entrada para {{cite journal/French}} ]] función local cite_journal_fr ( frame ) return _cite_fr ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ NEWS _ FR >------------------------------------------------------ punto de entrada para {{cite news/French}} ]] función local cite_news_fr ( frame ) return _cite_fr ( frame , 'cite news/subst' ); fin --[[--------------------------< CITE _ WEB _ FR >-------------------------------------------------------- punto de entrada para {{cite web/French}} ]] función local cite_web_fr ( frame ) return _cite_fr ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ IT >-------------------------------------------------------------- implementa {{Cita libro}} (:it:Template:Cita_libro) ]] función local _cite_it ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'it' ); -- traducir fechas y parámetros de idioma url_status_make ( args_t , cite_args_t , { 'urlmorto' }, {[ 'no' ] = true }); url_access_make ( args_t , cite_args_t , 'subscription' , { 'suscripción de suscripción' }, {[ '*' ] = true }); -- |suscripción de suscripción=<cualquier cosa> -> |url-access=suscripción isxn_make ( args_t , cite_args_t , 'isbn' , { 'isbn' , 'isbn13' }, { 'ignoraisbn' }, {[ '*' ] = true }); -- |ignore-isbn-error=<cualquier cosa> name_list_style_make ( args_t , cite_args_t , { 'lastauthoramp' }, {[ '*' ] = 'amp' }); -- listado en ~/Whitelist y ~/Configuration pero no soportado en el módulo principal if args_t [ 'etal' ] then -- aparentemente cualquier valor (normalmente 's', 'sì', o 'si'); más bien como |display-authors=etal table.insert ( cite_args_t , 'display-authors=etal' ); args_t [ 'etal' ] = nil ; end if args_t [ 'etalcuratori' ] then table.insert ( cite_args_t , 'display-editors=etal' ); args_t [ 'etalcuratori' ] = nil ; fin de retorno render ( marco , args_t , cite_args_t , params_main_t . it , plantilla ,'it' ); -- ahora ve a renderizar el final de la cita --[[---------------------------< CITE _ BOOK _ IT >------------------------------------------------------- punto de entrada para {{cite book/Italian}} it:Template:Cita libro ]] función local cite_book_it ( frame ) return _cite_it ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ IT >------------------------------------------------ punto de entrada para {{cite journal/Italian}} it:Template:Cita pubblicazione ]] función local cite_journal_it ( frame ) return _cite_it ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ NEWS _ IT >------------------------------------------------------ punto de entrada para {{cite news/Italian}} it:Template:Cita news ]] función local cite_news_it ( frame ) return _cite_it ( frame , 'cite news/subst' ); fin --[[--------------------------< CITE _ WEB _ IT >-------------------------------------------------------- punto de entrada para {{cite web/Italian}} it:Plantilla:Cita web ]] función local cite_web_it ( frame ) return _cite_it ( frame , 'cite web/subst' ); fin --[[--------------------------< _ CITE _ NL >-------------------------------------------------------------- <includeonly>{{safesubst:<noinclude />#invoke:Sandbox/trappist_the_monk/Literatur|cite_journal_nl}}</includeonly><noinclude>{{documentation}}</noinclude> Función común a implementar: {{cite book/Dutch}} (nl:Sjabloon:Citeer boek) {{cite journal/Dutch}} (nl:Sjabloon:Citeer journal) {{cite web/Dutch}} (nl:Sjabloon:Citeer) ]] función local _cite_nl ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas de parámetros=valores (sin barras verticales); para ordenar -- casos especiales dates_and_language ( args_t , cite_args_t , 'nl' ); -- traducir parámetros de fechas e idioma url_status_make ( args_t , cite_args_t , { 'deadurl' , 'dead-url' , 'dodeurl' , 'dode-url' }, {[ 'no' ] = true , [ 'nee' ] = true }); id_make ( marco , args_t , cite_args_t , params_identifiers_t.nl ); -- ensamblar |id= return render ( marco , args_t , cite_args_t , params_main_t.nl , plantilla , 'nl' ) ; -- ahora ve a renderizar la cita fin --[[--------------------------< CITATION _ NL >-------------------------------------------------------- punto de entrada para {{citation/Dutch}} ]] --local function cite_book_nl(marco) -- return _cite_nl(marco, 'citation/subst'); --fin --[[--------------------------< CITE _ BOOK _ NL >------------------------------------------------------ punto de entrada para {{cite book/Dutch}} ]] función local cite_book_nl ( frame ) return _cite_nl ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ NL >------------------------------------------------ punto de entrada para {{cite journal/Dutch}} ]] función local cite_journal_nl ( frame ) return _cite_nl ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ WEB _ NL >-------------------------------------------------------- punto de entrada para {{cite web/Dutch}} ]] función local cite_web_nl ( frame ) return _cite_nl ( frame , 'cite web/subst' ); fin --[[---------------------------< _ CITE _ PL >-------------------------------------------------------------- <includeonly>{{safesubst:<noinclude />#invoke:Sandbox/trappist_the_monk/Literatur|cite_journal_pl}}</includeonly><noinclude>{{documentación}}</noinclude> Función común a implementar: {{citation/Polish}} (pl:Szablon:Cytuj) {{cite book/Polish}} (pl:Szablon:Cytuj książkę) {{cite journal/Polish}} (pl:Szablon:Cytuj pismo) {{cite web/Polish}} (pl:Szablon:Cytuj stronę) ]] función local _cite_pl ( frame , template ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores local cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales date_make ( args_t , cite_args_t , params_dates_t . pl ); -- ensamblar y traducir |date= misc_date_make ( args_t , cite_args_t , 'pl' ); si 'tak' == args_t [ 'odn' ] entonces -- |ref=tak es más o menos lo mismo que |ref=harv en en.wiki args_t [ ' odn' ] = nil ; -- no establecido porque es superfluo en en.wiki fin si args_t [ 'tom' ] o args_t [ 'tytuł tomu' ] entonces volumen local ; si args_t [ 'tom' ] entonces volumen = args_t [ 'tom' ]; fin si args_t [ 'tytuł tomu' ] entonces si volumen entonces volumen = volumen .. ' ' .. args_t [ 'tytuł tomu' ]; de lo contrario volumen = args_t [ 'tytuł tomu' ]; fin fin si volumen entonces tabla.insert ( cite_args_t , 'volume=' .. volumen ); args_t [ 'tom' ] = nil ; -- sin establecer porque ya no es necesario args_t [ 'tipo de objeto' ] = nil ; end end local i = 1 ; -- crea un contador local language ; while 1 do -- bucle para siempre TODO: ¿suficientemente igual que pt para combinarlo con language_make_pt()? si i == 1 entonces si args_t [ 'język' ] o args_t [ 'język1' ] entonces -- si no está enumerado o su alias enumerado language = args_t [ 'język' ] o args_t [ 'język1' ]; -- prefiere no enumerado args_t [ 'język' ] = nil ; -- sin establecer porque ya no es necesario args_t [ 'język1' ] = nil ; de lo contrario break ; fin elseif args_t [ 'język' .. i ] entonces idioma = idioma .. ', ' .. args_t [ 'język' .. i ]; args_t [ 'język' .. i ] = nil ; -- anular porque ya no se necesita de lo contrario break ; fin i = i + 1 ; -- aumentar el contador fin if idioma entonces tabla.insert ( cite_args_t , 'idioma=' .. idioma ); fin return render ( frame , args_t , cite_args_t , params_main_t . pl , template , 'pl' ); -- ahora ve a renderizar la cita fin --[[--------------------------< CITATION _ PL >-------------------------------------------------------- punto de entrada para {{citation/Polish}} ]] función local citation_pl ( frame ) return _cite_pl ( frame ,'cita/sust.' ); fin --[[--------------------------< CITE _ BOOK _ PL >------------------------------------------------------ punto de entrada para {{cite book/Polish}} ]] función local cite_book_pl ( frame ) return _cite_pl ( frame , 'cite book/subst' ); fin --[[--------------------------< CITE _ JOURNAL _ PL >------------------------------------------------ punto de entrada para {{cite journal/Polish}} ]] función local cite_journal_pl ( frame ) return _cite_pl ( frame , 'cite journal/subst' ); fin --[[--------------------------< CITE _ WEB _ PL >-------------------------------------------------------- punto de entrada para {{cite web/Polish}} ]] función local cite_web_pl ( frame ) return _cite_pl ( frame , 'cite web/subst' ); end --[[--------------------------< _ CITE _ PT >-------------------------------------------------------------- Función común a implementar: {{citation/Portuguese}} (pt:Predefinição:Citation) {{cite book/Portuguese}} (pt:Predefinição:Citar livro) {{cite journal/Portuguese}} (pt:Predefinição:Citar periódico) {{cite news/Portuguese}} (pt:Predefinição:Citar jornal) {{citar web/Portugués}} (pt:Predefinição:Citar web) ]] función local _cite_pt ( marco , plantilla ) local args_t = {}; -- una tabla de pares k/v que contiene los parámetros de la plantilla args_get ( frame , args_t ); -- obtener los parámetros y sus valores locales cite_args_t = {}; -- una tabla de secuencia que contiene cadenas parámetro=valor (sin barras verticales); para ordenar -- casos especiales date_make ( args_t , cite_args_t , params_dates_t . pt ); -- ensamblar y traducir |date= misc_date_make ( args_t , cite_args_t , 'pt' ); title_make_pt ( args_t , cite_args_t ); -- join |title= with |subtitle= to make new titleurl_status_make (args_t, cite_args_t, {'datali', 'dead-url', 'deadurl', 'li', 'ligação inactiva', 'ligação inativa', 'urlmorta'}, {['no'] = true, ['não'] = true});local language = language_make_pt (args_t, cite_args_t);-- get string of language tags and/or unknown language names (or nil if no language parameters)if language thentable.insert (cite_args_t, 'language=' .. language);endreturn render (frame, args_t, cite_args_t, params_main_t.pt, template, 'pt');-- now go render the citationend--[[--------------------------< C I T A T I O N _ P T >--------------------------------------------------------entry point for {{citation/Portuguese}}]]local function cite_book_pt (frame)return _cite_pt (frame, 'citation/subst');end--[[--------------------------< C I T E _ B O O K _ P T >------------------------------------------------------entry point for {{cite book/Portuguese}}]]local function cite_book_pt (frame)return _cite_pt (frame, 'cite book/subst');end--[[--------------------------< C I T E _ J O U R N A L _ P T >------------------------------------------------entry point for {{cite journal/Portuguese}}]]local function cite_journal_pt (frame)return _cite_pt (frame, 'cite journal/subst');end--[[--------------------------< C I T E _ N E W S _ P T >------------------------------------------------------entry point for {{cite news/Portuguese}}]]local function cite_news_pt (frame)return _cite_pt (frame, 'cite news/subst');end--[[--------------------------< C I T E _ W E B _ P T >--------------------------------------------------------entry point for {{cite web/Portuguese}}]]local function cite_web_pt (frame)return _cite_pt (frame, 'cite web/subst');end--[[--------------------------< _ C I T E _ S V >--------------------------------------------------------------<includeonly>{{safesubst:<noinclude />#invoke:Sandbox/trappist_the_monk/Literatur|cite_journal_sv}}</includeonly><noinclude>{{documentation}}</noinclude>Common function to implement:{{cite book/Swedish}} (sv:Mall:Bokref){{cite journal/Swedish}} (sv:Mall:Tidskriftsref){{cite web/Swedish}} (sv:Mall:Webbref)]]local function _cite_sv (frame, template)local args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valueslocal cite_args_t = {};-- a sequence table that holds parameter=value strings (without pipes); for sorting-- special casesdates_and_language (args_t, cite_args_t, 'sv');-- translate dates and language parametersname_list_style_make (args_t, cite_args_t, {'författarsep'}, {['*'] = 'amp'});id_make (frame, args_t, cite_args_t, params_identifiers_t.sv)return render (frame, args_t, cite_args_t, params_main_t.sv, template, 'sv');-- now go render the citationend--[[--------------------------< C I T A T I O N _ S V >--------------------------------------------------------entry point for {{citation/Swedish}}]]--local function citation_sv (frame)-- return _cite_sv (frame, 'citation/subst');--end--[[--------------------------< C I T E _ B O O K _ S V >------------------------------------------------------entry point for {{cite book/Swedish}}]]local function cite_book_sv (frame)return _cite_sv (frame, 'cite book/subst');end--[[--------------------------< C I T E _ J O U R N A L _ S V >------------------------------------------------entry point for {{cite journal/Swedish}}]]local function cite_journal_sv (frame)return _cite_sv (frame, 'cite journal/subst');end--[[--------------------------< C I T E _ W E B _ S V >--------------------------------------------------------entry point for {{cite web/Swedish}}]]local function cite_web_sv (frame)return _cite_sv (frame, 'cite web/subst');end--[[=========================<< C I T E B O O K F U N C T I O N S >>=======================================]]--[[--------------------------< C I T E _ B O O K _ R U >------------------------------------------------------implements {{Книга}} (:ru:Шаблон:Книга)]]local function cite_book_ru (frame)local args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valueslocal cite_args_t = {};-- a sequence table that holds parameter=value strings (without pipes); for sorting-- special casesdates_and_language (args_t, cite_args_t, 'ru');-- translate dates and language parametersat_make (args_t, cite_args_t, {'столбцы'}, 'col. ')return render (frame, args_t, cite_args_t, params_main_t.ru, 'cite book/subst', 'ru');-- now go render the citationend--[[=========================<< C I T E W E B F U N C T I O N S >>=========================================]]--[[--------------------------< _ C I T E _ N O >--------------------------------------------------------------implements{{cite book/Norwegian}} (:no:Mal:Kilde bok){{cite journal/Norwegian}} (:no:Mal:Kilde artikkel){{cite web/Norwegian}} (:no:Mal:Kilde www)]]local function _cite_no (frame, template)local args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valueslocal cite_args_t = {};-- a sequence table that holds parameter=value strings (without pipes); for sorting-- special casesdates_and_language (args_t, cite_args_t, 'no');-- translate dates and language parametersurl_status_make (args_t, cite_args_t, {'død-lenke', 'dødlenke'}, {['no'] = true, ['nei'] = true});url_access_make (args_t, cite_args_t, 'subscription', {'abonnement', 'abb'}, {'yes', 'true', 'y', 'ja'});-- for |subscription=url_access_make (args_t, cite_args_t, 'registration', {'registrering'}, {'yes', 'true', 'y', 'ja'});-- for |registration=if args_t['url-tilgang'] then-- translate value assigned to |url-access= TODO: make this into a shared function?local values = {['abonnement'] = 'subscription', ['registrering'] = 'registration', ['begrenset'] = 'limited', ['åpen'] = 'åpen'};-- 'åpen' not supported; include it to get the error messagetable.insert (cite_args_t, 'url-access=' .. (values[args_t['url-tilgang']] or args_t['url-tilgang']));args_t['url-tilgang'] = nil;endisxn_make (args_t, cite_args_t, 'isbn', {'isbn', 'isbn13'}, {'ignorer-isbn-feil', 'ignorerisbnfeil'}, {'yes', 'true', 'y', 'ja'});if not args_t['navnelisteformat'] thenname_list_style_make (args_t, cite_args_t, {'sisteforfatteramp'}, {['*']='amp'});endreturn render (frame, args_t, cite_args_t, params_main_t.no, template, 'no');-- now go render the citationend--[[--------------------------< C I T E _ B O O K _ N O >------------------------------------------------------entry point for {{cite web/Norwegian}}]]local function cite_book_no (frame)return _cite_no (frame, 'cite book/subst');end--[[--------------------------< C I T E _ J O U R N A L _ N O >------------------------------------------------entry point for {{cite journal/Norwegian}}]]local function cite_journal_no (frame)return _cite_no (frame, 'cite journal/subst');end--[[--------------------------< C I T E _ N E W S _ N O >------------------------------------------------------entry point for {{cite news/Norwegian}}]]local function cite_news_no (frame)return _cite_no (frame, 'cite news/subst');end--[[--------------------------< C I T E _ W E B _ N O >--------------------------------------------------------entry point for {{cite web/Norwegian}}This function called by intermediate function cite_web_da_no() because da.wiki and no.wiki both use {{kilde www}}]]local function cite_web_no (frame)return _cite_no (frame, 'cite web/subst');end--[[--------------------------< _ C I T E _ T R >--------------------------------------------------------------implements:{{Akademik dergi kaynağı}} (:tr:Şablon:Akademik dergi kaynağı) – {{cite journal}}{{Haber kaynağı}} (:tr:Şablon:Haber kaynağı) – {{cite news}}{{Kitap kaynağı}} (:tr:Şablon:Kitap kaynağı) – {{cite book}}{{Web kaynağı}} (:tr:Şablon:Web_kaynağı) – {{cite web}}]]local function _cite_tr (frame, template)local args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valueslocal cite_args_t = {};-- a sequence table that holds parameter=value strings (without pipes); for sorting-- special casesdates_and_language (args_t, cite_args_t, 'tr');-- translate dates and language parametersurl_status_make (args_t, cite_args_t, {'ölüurl', 'ölü-url', 'bozukurl'}, {['hayır'] = true, ['h'] = true, ['no'] = true});if not (args_t['url-access'] or args_t['url-erişimi'] or args_t['URLerişimi']) thenurl_access_make (args_t, cite_args_t, 'subscription', {'subscription'}, {'yes', 'true', 'y', 'e', 'evet', 'doğru'})url_access_make (args_t, cite_args_t, 'registration', {'registration'}, {'yes', 'true', 'y', 'e', 'evet', 'doğru'})endisxn_make (args_t, cite_args_t, 'isbn', {'isbn', 'isbn13'}, {'ignore-isbn-error', 'ignoreisbnerror'}, {'yes', 'true', 'y', 'e', 'evet', 'doğru'});name_list_style_make (args_t, cite_args_t, {'last-author-amp', 'lastauthoramp', 'sonyazarve'}, {['*']='amp'});-- listed in ~/Whitelist and ~/Configuration (SonYazarVe) not supported in mainreturn render (frame, args_t, cite_args_t, params_main_t.tr, template, 'tr');-- now go render the citationend--[[--------------------------< C I T E _ B O O K _ T R >------------------------------------------------------implements {{Kitap kaynağı}} (:tr:Şablon:Kitap kaynağı)]]local function cite_book_tr (frame)return _cite_tr (frame, 'cite book/subst');end--[[--------------------------< C I T E _ J O U R N A L _ T R >------------------------------------------------implements {{Akademik dergi kaynağı}} (:tr:Şablon:Akademik dergi kaynağı)]]local function cite_journal_tr (frame)return _cite_tr (frame, 'cite journal/subst');end--[[--------------------------< C I T E _ N E W S _ T R >------------------------------------------------------implements {{Haber kaynağı}} (:tr:Şablon:Haber kaynağı)]]local function cite_news_tr (frame)return _cite_tr (frame, 'cite news/subst');end--[[--------------------------< C I T E _ W E B _ T R >--------------------------------------------------------implements {{Web kaynağı}} (:tr:Şablon:Web_kaynağı)]]local function cite_web_tr (frame)return _cite_tr (frame, 'cite web/subst');end--[[=========================<< I N T E R M E D I A T E F U N C T I O N S >>=================================]]--[[--------------------------< _ C I T E _ E S _ I T >--------------------------------------------------------Because the Spanish and Italian templates {{cita news}}, {{cita libro}}, and {{cita web}} share the names but nothing else, they must be distinguished one from the other. This is done by looking at their (required) titleparameters:título – Spanishtitolo – Italian <funct_t> is a k/v table where k is the ISO 639-1 language code (es: Spanish; it: Italian) and v is the matchingfuntion that handles this {{cita news}}, {{cita libro}}, or {{cita web}} templateit.wiki supports positional parameters for <url> ({{{1}}}) and <title> ({{{2}}}); because it is necessary to usethe |title= equivalent to determine which function to call, the it.wiki positional parameters are not supported.]]local function _cite_es_it (frame, funct_t, template)local f_title = frame.args['título'];-- look for Spanish |title= parameter in the framelocal p_title = frame:getParent().args['título'];-- and in the parent frameif (f_title and '' ~= f_title) or (p_title and '' ~= p_title) then-- when set and not be an empty stringreturn funct_t.es (frame);-- call the Spanish versionendf_title = frame.args['titolo'];-- look for Italian |title= parameterp_title = frame:getParent().args['titolo'];if (f_title and '' ~= f_title) or (p_title and '' ~= p_title) then-- when set and not be an empty stringreturn funct_t.it (frame);-- call the Italian versionend-- when here we don't know what we've gotlocal args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valuesreturn render (frame, args_t, {}, {}, template, 'unknown (Italian or Spanish)');-- can't tell what we have so translate template name onlyend--[[--------------------------< C I T E _ B O O K _ E S _ I T >------------------------------------------------use common function _cite_es_it to determine which of cite_book_es() or cite_book_it() should be used to handlethis {{cita libro}} template.]]local function cite_book_es_it (frame)return _cite_es_it (frame, {es = cite_book_es, it = cite_book_it}, 'cite book/subst');-- determine which language (Spanish or Italian) and then call the appropriate functionend--[[--------------------------< C I T E _ N E W S _ E S _ I T >------------------------------------------------use common function _cite_es_it to determine which of cite_news_es() or cite_news_it() should be used to handlethis {{cita news}} template.]]local function cite_news_es_it (frame)return _cite_es_it (frame, {es = cite_news_es, it = cite_news_it}, 'cite news/subst');-- determine which language (Spanish or Italian) and then call the appropriate functionend--[[--------------------------< C I T E _ W E B _ E S _ I T >--------------------------------------------------use common function _cite_es_it to determine which of cite_web_es() or cite_web_it() should be used to handlethis {{cita web}} template.]]local function cite_web_es_it (frame)return _cite_es_it (frame, {es = cite_web_es, it = cite_web_it}, 'cite web/subst');-- determine which language (Spanish or Italian) and then call the appropriate functionend--[[--------------------------< C I T E _ W E B _ D A _ N O >--------------------------------------------------implements {{cite web/Danish}} (da:Skabelon:Kilde_www and no:Mal:Kilde_www)this function counts the number of parameter names that are listed in params_main_t.da and params_main_t.no and thenfrom those counts, decides which of cite_web_da() or cite_web_no() to call.]]local function cite_web_da_no (frame)local args_t = {};-- a table of k/v pairs that holds the template's parametersargs_get (frame, args_t);-- get the parameters and their valueslocal count_da = 0;-- number of parameter that are listed in <params_main_t.da>local count_no = 0;-- number of parameter that are listed in <params_main_t.no>for k, _ in pairs (args_t) do-- for each parameter in <args_t>for _, map_t in ipairs ({params_main_t, params_misc_dates_t}) do-- and for each of these tablesfor _, code in ipairs ({'da', 'no'}) do-- and for each of these language codesif map_t[code][k] and 'da' == code then-- when this is a Danish parametercount_da = count_da + 1;-- bump the Danish counterendif map_t[code][k] and 'no' == code then-- when this is a Norwegian parametercount_no = count_no + 1;-- bump the Norwegian counterendendendendif count_da >= count_no then-- when count of da.wiki params greater than or equal to count of no.wiki parmsreturn cite_web_da (frame);-- assume this is a da.wiki cite webelsereturn cite_web_no (frame);-- else assume this is a no.wiki cite webendend--[[--------------------------< P A R A M _ N A M E S _ G E T >------------------------------------------------utility function to support the creation of translation data for Module:CS1 translate/data from a non-Englishwikitext template. This function fetches the unparsed content of a local copy of the non-English template andextracts a list of the parameters that it supports.parameters:{{{1}}} – when provided is the page name (including namespace) of the page that holds the local copy of thenon-English template; if omitted uses the current page (page with the {{#invoke}}). If a page name is notspecified, the parameter must be present if {{{2}}} is specified.{{{2}}} – language tag of the wiki from which the non-English template was copied; 'ca' in https://ca.wikipedia.org/This function uses that tag to know if a certain parameter has already been translatedexamples:{{#invoke:CS1 translator|param_names_get|<page name>|<tag>}}– non-English template is located at <page name>; <tag> specifies the template's language{{#invoke:CS1 translator|param_names_get||<tag>}}– non-English template is colocated with the {{#invoke}} of this funtion; <tag> specifies the template's language note empty {{{1}}}return a table in lua format listing all parameter names that do not have translations. In this list, enumeratedparameter names are collapsed: 'autor1' .. 'autor4' all collapsed to 'autor#']]local function param_names_get (frame)local args_t = require ('Module:Arguments').getArgs (frame);local template_content;-- unparsed template content goes herelocal title_objectif args_t[1] thentemplate_content = mw.title.new(args_t[1]):getContent() or '';-- if a page name supplied in {{{1}}} get its contentelsetemplate_content = mw.title.getCurrentTitle():getContent() or '';-- get the content of the current pageendlocal raw_params_t = {};-- table to hold all unique <param> names from any {{{<param name> that we findlocal raw_param_count = 0;-- tally of unique raw parameters; used in final outputlocal params_t = {};-- table to hold all (possibly modified) <param> nameslocal param_count = 0;-- tally of (possibly modified) <param> names in the templatefor param in template_content:gmatch ('{{{([^|}]+)') do-- loop through <template_content> and extract parameter namesif not raw_params_t[param] then-- have we seen this parameter name?raw_params_t[param] = true-- no; save itraw_param_count = raw_param_count + 1;-- and tallyendparam = param:gsub ('%d+', '#');-- replace any enumerator with '#'if not params_t[param] then-- have we seen this (possibly modified) parameter name?params_t[param] = true;-- no; save itparam_count = param_count + 1;-- and tallyendend--mw.logObject (raw_params_t)local out_t = {};-- sequence table to hold param names for outputlocal xlated_params_t = {};-- will hold list of args_t[2] language parameter translationsif args_t[2] then-- if a language tag suppliedxlated_params_t = data.params_main_t[args_t[2]];-- attempt to load a table of that language's parameters known to CS1 translatorendlocal cs1_common_parameters_t = mw.loadData ('Module:Citation/CS1/Whitelist').common_parameters_t;-- fetch the list of cs1|2 common parametersfor param, _ in pairs (params_t) do-- loop through the list of unique template parameter namesif xlated_params_t and not xlated_params_t[param] then-- does Module:CS1 translator/data has translation data for args_t[2] language but not for this <param>?if not cs1_common_parameters_t[param] then-- is <param> a known cs1|2 parameter?table.insert (out_t, '[\'' .. param .. '\']');-- no translation and not known to cs1|2, add to output list as lua table indexendelseif not xlated_params_t then-- if no data for the args_t[2] languagetable.insert (out_t, param);-- add to output listendendtable.sort (out_t);-- sort list of parameter nameslocal untranslated_count = #out_t;-- get the tally of parameter names that don't have translationsout_t = {table.concat (out_t, ' = \'\',\n\t\t')};-- replace individual entries with a single formatted stringtable.insert (out_t, 1, table.concat ({-- open lua table and formatting'<syntaxhighlight lang="lua">\t',args_t[2] and args_t[2] or '??',-- language tag or '??' if not specified in {{{2}}}'= {\n\t\t'}));table.insert (out_t, ' = \'\',\n\t\t}</syntaxhighlight>');-- close lua table and formattingtable.insert (out_t, 1, table.concat ({-- insert commentarymw.language.fetchLanguageName (args_t[2] and args_t[2] or 'und', 'en'),-- get language name for {{{2}}}': the template has ',raw_param_count,-- total number of unmodified unique parameter names' parameter names; ',untranslated_count,-- total number of parameter names without translation' parameter names not translated.'}));return frame:preprocess (table.concat (out_t));-- and make all pretty-like and doneend--[[--------------------------< E X P O R T E D F U N C T I O N S >------------------------------------------]]return {param_names_get = param_names_get,-- utility function reads parameter names from wikitext template to aid creation of table in ~/datacitation_pl = citation_pl,-- pl:Szablon:Cytujcite_book_ar = cite_book_ar,-- ar:قالب:استشهاد بكتابcite_book_ca = cite_book_ca,-- ca:Plantilla:Ref-llibrecite_book_da = cite_book_da,-- da:Skabelon:Kilde bogcite_book_de = cite_book_de,-- de:Vorlage:Literatur-- cite_book_es = cite_book_es, -- es:Plantilla:Cita librocite_book_fi = cite_book_fi,-- fi:Malline:Kirjaviitecite_book_fr = cite_book_fr,-- fr:Modèle:Ouvrage-- cite_book_it = cite_book_it, -- it:Template:Cita librocite_book_nl = cite_book_nl,-- nl:Sjabloon:Citeer boekcite_book_no = cite_book_no,-- no:Mal:Kilde bokcite_book_pl = cite_book_pl,-- pl:Szablon:Cytuj książkęcite_book_pt = cite_book_pt,-- pt:Predefinição:citar livrocite_book_sv = cite_book_sv,-- sv:Mall:Bokrefcite_book_tr = cite_book_tr,-- tr:Şablon:Kitap kaynağıcite_journal_ar = cite_journal_ar,-- ar:قالب:استشهاد بدورية محكمةcite_journal_ca = cite_journal_ca,-- ca:Plantilla:Ref-publicaciócite_journal_da = cite_journal_da,-- da:Skabelon:Kilde tidsskrift / da:Skabelon:Kilde artikel (da.wiki prefers da:Skabelon:cite journal)cite_journal_es = cite_journal_es,-- es:Plantilla:Cita publicacióncite_journal_fi = cite_journal_fi,-- fi:Malline:Lehtiviitecite_journal_fr = cite_journal_fr,-- fr:Modèle:Articlecite_journal_it = cite_journal_it,-- it:Template:Cita pubblicazionecite_journal_nl = cite_journal_nl,-- nl:Sjabloon:Citeer journalcite_journal_no = cite_journal_no,-- no:Mal:Kilde artikkelcite_journal_pl = cite_journal_pl,-- pl:Szablon:Cytuj pismocite_journal_pt = cite_journal_pt,-- pt:Predefinição:citar periódicocite_journal_sv = cite_journal_sv,-- sv:Mall:Tidskriftsrefcite_journal_tr = cite_journal_tr,-- tr:Şablon:Akademik dergi kaynağıcite_news_ar = cite_news_ar,-- ar:قالب:استشهاد بخبرcite_news_ca = cite_news_ca,-- ca:Plantilla:Ref-notíciacite_news_es = cite_news_es,-- en:Template:Cite news/Spanish; for cita news see cite_news_es_it()cite_news_fr = cite_news_fr,-- fr:Modèle:Articlecite_news_it = cite_news_it,-- en:Template:Cite news/Italian; for cita news see cite_news_es_it()cite_news_no = cite_news_no,-- no:Mal:Kilde aviscite_news_pt = cite_news_pt,-- pt:Predefinição:citar jornalcite_news_tr = cite_news_tr,-- tr:Şablon:Haber kaynağıcite_web_ar = cite_web_ar,-- ar:قالب:استشهاد ويبcite_web_ca = cite_web_ca,-- ca:Plantilla:Ref-webcite_web_da = cite_web_da,-- da:Skabelon:Kilde www or da:Skabelon:Cite webcite_web_de = cite_web_de,-- de:Vorlage:Internetquellecite_web_es = cite_web_es,-- es:Plantilla:Cita webcite_web_fi = cite_web_fi,-- fi:Malline:Verkkoviitecite_web_fr = cite_web_fr,-- fr:Modèle:Lien webcite_web_it = cite_web_it,-- it:Template:Cita webcite_web_nl = cite_web_nl,-- nl:Sjabloon:Citeer webcite_web_no = cite_web_no,-- no:Mal:Kilde wwwcite_web_pl = cite_web_pl,-- pl:Szablon:Cytuj stronęcite_web_pt = cite_web_pt,-- pt:Predefinição:citar webcite_web_sv = cite_web_sv, -- sv:Mall:Webbref cite_web_tr = cite_web_tr , -- tr:Şablon:Web kaynağı cite_book_es_it = cite_book_es_it , -- punto de entrada común para {{cita book}} (español es:Plantilla:Cita libro / italiano it:Template: Cita libro) --cite_libro_es_it = cite_book_es_it, -- punto de entrada común para {{cita book}} (español es:Plantilla:Cita libro / italiano it:Template:Cita libro) cite_news_es_it = cite_news_es_it , -- punto de entrada común para {{cita news}} (español es:Plantilla :Cita noticia / Italian it:Template:Cita news) cite_web_es_it = cite_web_es_it , -- punto de entrada común para {{cita web}} (español es:Plantilla:Cita web / Italiano it:Template:Cita web) cite_web_da_no = cite_web_da_no , -- punto de entrada común para {{cite web/danés o noruego}} (danés da:Skabelon:Kilde www / noruego no:Mal:Kilde www) }