Википедија

Модул:Lang: Разлика помеѓу преработките

Интерактивен преглед на историјата
[проверена преработка][проверена преработка]
← Постаро уредувањеПоново уредување →
Избришана содржина Додадена содржина
Нема опис на уредувањето
Ознаки: Рачно отповикување Отповикано
Revert на скриптата.
Ознаки: Рачно отповикување Отповикано
Ред 6:
 
require('Module:No globals');
 
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
 
local getArgs = require ('Module:Arguments').getArgs;
Ред 11 ⟶ 13:
local yesno = require ('Module:Yesno');
 
local lang_datalang_name_table = mw.loadData ('Module:LangLanguage/name/data'); -- language name override and transliteration tool-tip tables
local lang_name_table = lang_data.lang_name_table; -- language codes, names, regions, scripts, suppressed scripts
local lang_table = lang_data.lang_name_table.lang;
local lang_dep_table = lang_data.lang_name_table.lang_dep;
local script_table = lang_data.lang_name_table.script;
local region_table = lang_data.lang_name_table.region;
local variant_table = lang_data.lang_name_table.variant;
local suppressed_table = lang_data.lang_name_table.suppressed;
local override_table = lang_data.override;
 
local synonym_table = mw.loadData ('Module:Lang/ISO 639 synonyms'); -- ISO 639-2/639-2T code translation to 639-1 code
 
local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables
 
local namespace = mw.title.getCurrentTitle().namespace; -- used for categorization
 
local this_wiki_lang = mw.language.getContentLanguage().code; -- get this wiki's language
 
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
 
local maint_cats = {}; -- maintenance categories go here
Ред 127 ⟶ 121:
 
if count > 1 then -- return nil and an error message if more than one is set
return nil, 'only one of ||italic=, ||italics=, or ||i= can be specified';
end
Ред 192 ⟶ 186:
region: upper case
variant: lower case
 
private: lower case prefixed with -x-
]]
 
local function format_ietf_tag (code, script, region, variant, private)
local out = {};
 
if is_set (private) then
return table.concat ({code:lower(), 'x', private:lower()}, '-'); -- if private, all other tags ignored
end
table.insert (out, code:lower());
if is_set (script) then
Ред 227 ⟶ 216:
script subtag - four character IANA script code
region subtag - two-letter or three digit IANA region code
variant subtag - four digit or 5-8 alnum variant code; only one variant subtag supported
private subtag - x- followed by 1-8 alnum private code; only supported with the primary language tag
 
Ред 317 ⟶ 306:
code = code:lower(); -- ensure that we use and return lower case version of this
if not (override_tablelang_data.override[code] or lang_table[code] or synonym_table[code] or lang_dep_tablelang_name_table.lang[code]) then
return nil, nil, nil, nil, nil, table.concat ({'unrecognized language code: ', code}); -- invalid language code, don't know about the others (don't care?)
end
Ред 337 ⟶ 326:
if is_set (script) then
script = script:lower(); -- ensure that we use and return lower case version of this
if not script_tablelang_name_table.script[script] then
return code, nil, nil, nil, nil, table.concat ({'unrecognized script: ', script, ' for code: ', code}); -- language code ok, invalid script, don't know about the others (don't care?)
end
end
if suppressed_tablelang_name_table.suppressed[script] then -- ensure that code-script does not use a suppressed script
if in_array (code, suppressed_tablelang_name_table.suppressed[script]) then
return code, nil, nil, nil, nil, table.concat ({'script: ', script, ' not supported for code: ', code}); -- language code ok, script is suppressed for this code
end
Ред 357 ⟶ 346:
if is_set (region) then
region = region:lower(); -- ensure that we use and return lower case version of this
if not region_tablelang_name_table.region[region] then
return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code});
end
Ред 372 ⟶ 361:
if is_set (variant) then
variant = variant:lower(); -- ensure that we use and return lower case version of this
if not variant_tablelang_name_table.variant[variant] then -- make sure variant is valid
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant});
end -- does this duplicate/replace tests in lang() and lang_xx()?
if is_set (script) then -- if script set it must be part of the 'prefix'
if not in_array (table.concat ({code, '-', script}), variant_tablelang_name_table.variant[variant]['prefixes']) then
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script});
end
elseif is_set (region) then -- if region set, there are some prefixes that require lang code and region (en-CA-newfound)
if not in_array (code, variant_table[variant]['prefixes']) then -- first see if lang code is all that's required (en-oxendict though en-GB-oxendict is preferred)
if not in_array (table.concat ({code, '-', region}), variant_table[variant]['prefixes']) then -- now try for lang code and region (en-CA-newfound)
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-region pair: ', code, '-', region});
end
end
else
if not in_array (code, variant_tablelang_name_table.variant[variant]['prefixes']) then
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code});
end
Ред 394 ⟶ 377:
if is_set (private) then
private = private:lower(); -- ensure that we use and return lower case version of this
if not override_tablelang_data.override[table.concat ({code, '-x-', private})] then -- make sure private tag is valid; note that index
return code, script, region, nil, nil, table.concat ({'unrecognized private tag: ', private});
end
Ред 412 ⟶ 395:
local category;
if 'Transltransl' == template then
category = 'Transltransl';
else
category = 'Langlang and lang-xx'
end
table.insert (out, table.concat ({'[[', args.text or 'undefined', ']] '})); -- for error messages output args.text if available
table.insert (out, table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Errorerror: {{', template, '}}: '}));
table.insert (out, msg);
table.insert (out, table.concat ({' ([[:Category:', category, ' template errors|help]])'}));
table.insert (out, '</span>');
if (0 == namespace or 10 == namespace) and not args.nocat then -- only categorize in article space (and template space to take care of broken usages)
table.insert (out, table.concat ({'[[Category:', category, ' template errors]]'}));
end
Ред 517 ⟶ 500:
 
if 'normal' == style then -- when |italic=no
table.insert (html, ' style=\"font-style: normal;'); -- override external markup, if any
style_added = '\"'; -- remember that style attribute added and is not yet closed
end
Ред 523 ⟶ 506:
if is_set (size) then -- when |size=<something>
if is_set (style_added) then
table.insert (html, table.concat ({' font-size: ', size, ';'})); -- add when style attribute already inserted
else
table.insert (html, table.concat ({' style=\"font-size: ', size, ';'})); -- create style attribute
style_added = '\"'; -- remember that style attribute added and is not yet closed
end
Ред 533 ⟶ 516:
table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text
if language:find ('languages') then
table.insert (html, ' collective text\"'); -- for collective languages
else
table.insert (html, '- language text\"'); -- for individual languages
end
table.insert (html, '\">'); -- close the opening html tag
else
table.insert (html, table.concat ({style_added, '>'})); -- close the style attribute and close opening html tag
Ред 548 ⟶ 531:
table.insert (html, '&lrm;'); -- make sure the browser knows that we're at the end of the rtl
end
return table.concat (html); -- put it all together and done
end
Ред 560 ⟶ 544:
[[Category:Articles containing explicitly cited English-language text]]
for artificial languages (code: art)
[[Category:Articles containing constructed-language text]]
 
for ISO 639-2 collective languages (and for 639-1 bh):
[[Category:Articles with text infrom the <language> languages collective]]
 
]=]
 
local function make_category (code, language_name, nocat, name_get)
local cat = {};
local retval;
if (0 ~= namespace) or nocat then -- only categorize in article space
 
if ((0 ~= namespace) or nocat) and not name_get then -- only categorize in article space
return ''; -- return empty string for concatenation
end
 
if language_name:find ('languages') then
return table.concat ({'[[Category:Articles with text infrom the ', language_name, ' collective]]'});
end
table.insert (cat, '[[Category:Articles containing ');
 
if 'en' == code then
table.insert (cat, 'explicitly cited English' .. language_name); -- falls back to English if regional name not available
elseif 'art' == code then
table.insert (cat, 'constructed')
else
table.insert (cat, language_name);
Ред 587 ⟶ 575:
table.insert (cat, '-language text]]');
 
return table.concat (cat);
end
 
Ред 618 ⟶ 606:
table.insert (tout, "<i lang=\""); -- so use <i> tag
else
table.insert (tout, table.concat ({'<span style=\"font-style: ', style, '\" lang=\"'})); -- non-standard style, construct a span tag for it
end
table.insert (tout, code);
Ред 637 ⟶ 625:
if title_table[std] then -- and if standard is legitimate
if title_table[std][tscript] then -- and if script for that standard is legitimate
table.insert (tout, table.concat ({title_table[std][tscript:lower()], ' (', script_tablelang_name_table.script[tscript][1], ' script) transliteration'})); -- add the appropriate text to the tool tip
else
table.insert (tout, title_table[std]['default']); -- use the default if script not in std table; TODO: maint cat? error message because script not found for this standard?
Ред 649 ⟶ 637:
if title_table[std][code] then -- if language code is in the table (transl may not provide a language code)
-- table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', lang_tablelang_name_table.lang[code][1], ' language) transliteration'})); -- add the appropriate text to the tool tip
table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', language_name, ' language) transliteration'})); -- add the appropriate text to the tool tip
else -- code doesn't match
table.insert (tout, title_table[std]['default']); -- so use the standard's default
Ред 723 ⟶ 710:
if 0 < #maint_msgs then -- when there are maintenance messages
table.insert (maint, table.concat ({'<span class="lang-comment" style="font-style: normal; display: none; color: #33aa33; margin-left: 0.3em;">'})); -- opening <span> tag
for _, msg in ipairs (maint_msgs) do
table.insert (maint, table.concat ({msg, ' '})); -- add message strings
Ред 835 ⟶ 822:
 
 
--[[--------------------------< L A N G U A G E _ N A M E _ G E T >----------------------------------------------------------------------
 
common function to return language name from the data set according to IETF tag
 
returns language name if found in data tables; nil else
 
]]
 
local function language_name_get (ietf, code, cat)
ietf = ietf:lower(); -- ietf:lower() because format_ietf_tag() returns mixed case
local name; -- remains nil if not found
if override_table[ietf] then -- look for whole IETF tag in override table
name = override_table[ietf][1];
elseif override_table[code] then -- not there so try basic language code
name = override_table[code][1];
elseif lang_table[code] then -- shift to iana code/name table
name = lang_table[code][1]; -- table entries sometimes have multiple names, always take the first one
elseif lang_dep_table[code] then
-- if cat then
-- table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));
-- table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));
-- end
name = lang_dep_table[code][1]; -- table entries sometimes have multiple names, always take the first one
end
 
if lang_dep_table[code] and cat then -- because deprecated code may have been overridden to en.wiki preferred name
table.insert (maint_cats, table.concat ({'Lang and lang-xx using deprecated ISO 639 codes|', code}));
table.insert (maint_msgs, table.concat ({'code: ', code, ' is deprecated'}));
end
 
return name; -- name from data tables or nil
end
 
 
--[[--------------------------< _ L A N G >--------------------------------------------------------------------
 
entry point for {{lang}}
Ред 885 ⟶ 836:
local out = {};
local language_name; -- used to make category names
local category_name; -- same as language_name except that it retains any parenthetical disambiguators (if any) from the data set
local subtags = {}; -- IETF subtags script, region, variant, and private
local code; -- the language code
local msg; -- for error messages
local tag = 'span'; -- initial value for make_text_html()
local template = args.template or 'Langlang';
 
validate_cat_args (args); -- determine if categorization should be suppressed
 
if args[1] and args.code then
return make_error_msg ('conflicting: {{{1}}} and |&#124;code=', args, template);
else
args.code = args[1] or args.code; -- prefer args.code
Ред 901 ⟶ 849:
 
if args[2] and args.text then
return make_error_msg ('conflicting: {{{2}}} and |&#124;text=', args, template);
else
args.text = args[2] or args.text; -- prefer args.text
end
msg = validate_text (template, args); -- ensure that |text= is set
if is_set (msg) then -- msg is an already-formatted error message
return msg;
Ред 912 ⟶ 860:
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly
 
validate_cat_args (args); -- determine if categorization should be suppressed
 
args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false
Ред 917 ⟶ 867:
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag
if msg then
return make_error_msg (table.concat ({'invalid |&#124;proto=: ', args.proto}), args, template);
end
 
Ред 948 ⟶ 898:
end
 
args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
 
language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag
 
if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization
language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name
elseif lang_data.override[code] then
language_name = lang_data.override[code][1] -- then language names taken from the override table
elseif lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
 
if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content
Ред 1.051 ⟶ 1.010:
local msg; -- for error messages
local tag = 'span'; -- initial value for make_text_html()
local template = args.template or 'Langlang-xx';
 
if args[1] and args.text then
return make_error_msg ('conflicting: {{{1}}} and |&#124;text=', args, template);
else
args.text = args[1] or args.text; -- prefer args.text
Ред 1.067 ⟶ 1.026:
 
if args[2] and args.translit then
return make_error_msg ('conflicting: {{{2}}} and |&#124;translit=', args, template);
else
args.translit = args[2] or args.translit -- prefer args.translit
Ред 1.073 ⟶ 1.032:
if args[3] and (args.translation or args.lit) then
return make_error_msg ('conflicting: {{{3}}} and |&#124;lit= or |&#124;translation=', args, template);
elseif args.translation and args.lit then
return make_error_msg ('conflicting: |&#124;lit= and |&#124;translation=', args, template);
else
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation
Ред 1.081 ⟶ 1.040:
 
if args.links and args.link then
return make_error_msg ('conflicting: |&#124;links= and |&#124;link=', args, template);
else
args.link = args.link or args.links; -- prefer args.link
Ред 1.123 ⟶ 1.082:
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag
if msg then
return make_error_msg (table.concat ({'invalid |&#124;proto=: ', args.proto}), args, template);
end
 
args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles
language_name = language_name_get (args.code, code, true); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
subtags.private = subtags.private and table.concat ({code, '-x-', subtags.private}) or nil; -- assemble a complete private ietf subtag; args.code does not get private subtag
 
if is_set (subtags.private) and lang_data.override[subtags.private] then -- get the language name for categorization
language_name = lang_data.override[subtags.private][1]; -- first look for private use tag language name
elseif lang_data.override[args.code:lower()] then -- look for whole IETF tag in override table
language_name = lang_data.override[args.code:lower()][1]; -- args.code:lower() because format_ietf_tag() returns mixed case
elseif lang_data.override[code] then -- not there so try basic language code
language_name = lang_data.override[code][1];
elseif not is_set (subtags.variant) then
if lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
else -- TODO: is this the right thing to do: take language display name from variants table?
if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things
language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one
end
end
 
category_name = language_name; -- category names retain IANA parenthetical diambiguators (if any)
Ред 1.157 ⟶ 1.133:
args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat
 
table.insert (out, make_text_html (args.code, args.text, tag, args.rtl, args.italic, args.size, ('none' == args.label) and language_name or nil))
 
if is_set (args.translit) and not unicode.is_Latin (args.text) then -- transliteration (not supported in {{lang}}); not supported when args.text is wholly latn text (this is an imperfect test)
Ред 1.163 ⟶ 1.139:
if 'none' ~= args.label then
table.insert (out, '<small>');
if script_tablelang_name_table.script[args['translit-script']] then -- when |translit-script= is set, try to use the script's name
translit_script_name = script_tablelang_name_table.script[args['translit-script'][1]];
else
translit_script_name = language_name; -- fall back on language name
Ред 1.194 ⟶ 1.170:
table.insert (out, make_wikilink ('Literal translation', 'lit.'));
end
table.insert (out, "&thinspnbsp;</small>");
end
table.insert (out, table.concat ({'&#39;', args.translation, '&#39;'})); -- use html entities to avoid wiki markup confusion
Ред 1.292 ⟶ 1.268:
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
 
The purpose of this function is to replace {{#ifexist:Template:ISO 639 name xx|<exists>|<does not exist>}} in
templates that are better served by using {{#invoke:lang|name_from_tag|<code>}}
 
Module entry point from another module
Ред 1.298 ⟶ 1.277:
 
local function _is_ietf_tag (tag) -- entry point when this module is require()d into another
local c, s, r, v, p, err; -- code, script, region, variant, private, error message
c, s, r, v, p, err = get_ietf_parts (tag); -- disassemble tag into constituent part and validate
 
return ((c and not err) and true) or nil; -- return true when code portion has a value without error message; nil else
end
Ред 1.311 ⟶ 1.290:
]]
 
local function is_ietf_tag (frame) -- entry point from an {{#invoke:Lang|is_ietf_tag|<ietf tag>}}
return _is_ietf_tag (getArgs (frame).args[1]); -- frame.args[1] is the ietf language tag to be tested; also get parent frame
end
 
 
--[[--------------------------< I_ SN _A IM E T_ F _R TO A GM _ FC RO A MD E >------------------------------------------------
 
Returns language name associated with IETF language tag if valid; empty string else.
Module entry point from an {{#invoke:}}; same as is_ietf_tag() except does not get parameters from the parent
(template) frame. This function not useful when called by {{lang|fn=is_ietf_tag_frame|<tag>}} because <tag>
is in the parent frame.
 
]]
 
local function is_ietf_tag_frame (frame)
return _is_ietf_tag (getArgs (frame, {frameOnly = true,})[1]); -- args[1] is the ietf language tag to be tested; do not get parent frame
end
 
 
--[[--------------------------< _ N A M E _ F R O M _ T A G >--------------------------------------------------
 
Returns language name associated with IETF language tag if valid; error message else.
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
Ред 1.345 ⟶ 1.311:
local raw_code = args[1]; -- save a copy of the input IETF subtag
local link = 'yes' == args['link']; -- make a boolean
local label = args.label;
local code; -- the language code
local msg; -- gets an error message if IETF language tag is malformed or invalid
Ред 1.353 ⟶ 1.318:
if msg then
local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)
return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Errorerror: ', template, msg, '</span>'});
end
 
if lang_data.override[raw_code:lower()] then -- look for whole IETF tag in override table (force lower case)
raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
language_name = lang_data.override[raw_code:lower()][1];
language_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
elseif lang_data.override[code] then -- not there so try basic language code in override table
language_name = lang_data.override[code][1];
elseif not is_set (subtags.variant) then
if lang_name_table.lang[code] then
language_name = lang_name_table.lang[code][1]; -- table entries sometimes have multiple names, always take the first one
end
else -- TODO: is this the right thing to do: take language display name from variants table?
if lang_name_table.variant[subtags.variant] then -- TODO: there is some discussion at Template talk:Lang about having a label parameter for use when variant name is not desired among other things
language_name = lang_name_table.variant[subtags.variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one
end
end
 
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them
Ред 1.363 ⟶ 1.339:
if link then -- when |link=yes, wikilink the language name
if language_name:find ('languages') then
language_name =return make_wikilink (language_name, label); -- collective language name uses simple wikilink
elseif lang_data.article_name[code] then
language_name =return make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data
else
language_name =return make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink
end
end
 
return language_name;
 
end
 
 
--[[--------------------------< N A M E _ F R O M _ TC AO GD E >----------------------------------------------------
 
Module entry point from an {{#invoke:}}
Ред 1.382 ⟶ 1.359:
 
local function name_from_tag (frame) -- entry point from an {{#invoke:Lang|name_from_tag|<ietf tag>|link=<yes>|template=<template name>}}
return _name_from_tag (getArgs(frame.args)); -- pass-on the args table, nothing else; getArgs() so we also get parent frame
end
 
Ред 1.400 ⟶ 1.377:
 
if args[1] and '' ~= args[1] then
local data = mw.loadData ('Module:Lang/tagname fromto nametag'); -- get the reversed data tables TODO: change when going live
local lang = args[1]:lower(); -- allow any-case for the language name (speeling must till be correct)
local tag = data.rev_override_tablerev_lang_data[lang] or data.rev_lang_table[lang] or data.rev_lang_dep_tablerev_lang_name_table[lang]; -- get the code; look first in the override then in the standard
 
if tag then
return tag, true; -- language name found so return tag and done; second return used by is_lang_name()
else
msg = 'language: ' .. args[1] .. ' not found' -- language name not found, error message
Ред 1.417 ⟶ 1.394:
template = table.concat ({'{{', args['template'], '}}: '}); -- make template name (if provided by the template)
end
return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Errorerror: ', template, msg, '</span>'});
end
 
Ред 1.428 ⟶ 1.405:
 
local function tag_from_name (frame) -- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}}
local result, _ =return _tag_from_name (getArgs(frame.args)); -- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by is_lang_name()
return result;
end
 
 
--[[--------------------------< I S _ L A N G _ N A M E >------------------------------------------------------
 
Module entry point from an {{#invoke:}}
 
]]
 
local function is_lang_name (frame)
local _, result = _tag_from_name (getArgs(frame)) -- pass-on the args table, nothing else; getArgs() so we also get parent frame; supress second return used by tag_from_name()
return result and true or nil;
end
 
Ред 1.454 ⟶ 1.418:
local title_table = lang_data.translit_title_table; -- table of transliteration standards and the language codes and scripts that apply to those standards
local language_name; -- language name that matches language code; used for tool tip
local translit; -- transliteratedtranslitterated text to display
local script; -- IANA script
local msg; -- for when called functions return an error message
Ред 1.463 ⟶ 1.427:
 
if not title_table[args.translit_std] then
return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'Transltransl');
end
else
Ред 1.470 ⟶ 1.434:
else
if args[1] and args[1]:match ('^%a%a%a?%a?$') then -- args[2] missing; is args[1] a code or its it the transliterated text?
return make_error_msg ('no text', args, 'Transltransl'); -- args[1] is a code so we're missing text
else
args.text = args[1]; -- args[1] is not a code so we're missing that; assign args.text for error message
return make_error_msg ('missing language / script code', args, 'Transltransl');
end
end
Ред 1.482 ⟶ 1.446:
args.code = args[1]:lower(); -- use the language/script code; only (2, 3, or 4 alpha characters); lower case because table indexes are lower case
else
return make_error_msg (table.concat ({'unrecognized language / script code: ', args[1]}), args, 'Transltransl'); -- invalid language / script code
end
else
return make_error_msg ('missing language / script code', args, 'Transltransl'); -- missing language / script code so quit
end
 
args.italic, msg = validate_italic (args);
if msg then
return make_error_msg (msg, args, 'Transltransl');
end
Ред 1.497 ⟶ 1.461:
end
 
if override_tablelang_data.override[args.code] then -- is code a language code defined in the override table?
language_name = override_tablelang_data.override[args.code][1];
elseif lang_tablelang_name_table.lang[args.code] then -- is code a language code defined in the standard language code tables?
language_name = lang_tablelang_name_table.lang[args.code][1];
elseif lang_dep_tablelang_name_table.script[args.code] then -- isif here, code is not a language code; definedis init thea deprecated languagescript code tables?
language_name = lang_dep_tablelang_name_table.script[args.code][1];
elseif script_table[args.code] then -- if here, code is not a language code; is it a script code?
language_name = script_table[args.code][1];
script = args.code; -- code was an ISO 15924 script so use that instead
args.code = ''; -- unset because not a language code
else
return make_error_msg (table.concat ({'unrecognized language / script code: ', args.code}), args, 'Transltransl'); -- invalid language / script code
end
-- here only when all parameters passed to make_translit() are valid
Ред 1.522 ⟶ 1.484:
 
local function transl (frame)
returnlocal _translargs = (getArgs(frame)); -- no {{#invoke:}} parameters
return _transl (args);
end
 
 
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------
 
Returns category name associated with IETF language tag if valid; error message else
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
 
Module entry point from another module
 
]]
 
local function _category_from_tag (args)
local subtags = {}; -- IETF subtags script, region, variant, and private
local raw_code = args[1]; -- save a copy of the input IETF subtag
local link = 'yes' == args['link']; -- make a boolean
local label = args.label;
local code; -- the language code
local msg; -- gets an error message if IETF language tag is malformed or invalid
local category_name = '';
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (raw_code);
if msg then
local template = (args['template'] and table.concat ({'{{', args['template'], '}}: '})) or ''; -- make template name (if provided by the template)
return table.concat ({'<span style=\"font-size: 100%; font-style: normal;\" class=\"error\">Error: ', template, msg, '</span>'});
end
 
raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
category_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
category_name = make_category (code, category_name, nil, true):gsub ('[%[%]]', '');
 
return category_name;
end
 
 
--[[--------------------------< C A T E G O R Y _ F R O M _ T A G >--------------------------------------------
 
Module entry point from an {{#invoke:}}
 
]]
 
local function category_from_tag (frame) -- entry point from an {{#invoke:Lang|category_from_tag|<ietf tag>|template=<template name>}}
return _category_from_tag (getArgs (frame)); -- pass-on the args table, nothing else; getArgs() so we also get parent frame
end
 
Ред 1.574 ⟶ 1.493:
 
return {
category_from_tag = category_from_tag,
lang = lang, -- entry point for {{lang}}
lang_xx_inherit = lang_xx_inherit, -- entry points for {{lang-??}}
lang_xx_italic = lang_xx_italic,
is_ietf_tag = is_ietf_tag,
is_ietf_tag_frame = is_ietf_tag_frame,
is_lang_name = is_lang_name,
tag_from_name = tag_from_name, -- returns ietf tag associated with language name
name_from_tag = name_from_tag, -- used for template documentation; possible use in ISO 639 name from code templates
transl = transl, -- entry point for {{transl}}
 
_category_from_tag_lang = _category_from_tag_lang, -- entry points when this module is require()d into other modules
_lang = _lang,
_lang_xx_inherit = _lang_xx_inherit,
_lang_xx_italic = _lang_xx_italic,
_is_ietf_tag = _is_ietf_tag,
get_ietf_parts = get_ietf_parts,
_tag_from_name = _tag_from_name,
_name_from_tag = _name_from_tag,
Преземено од „https://mk.wikipedia.org/wiki/Модул:Lang“