1,815
edits
Changes
m
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
local lang_data = mw.loadData ('Module:Lang/data'); -- language name override and transliteration tool-tip tables
elseelseif 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, lang_name_tablevariant_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 -- cheap way to determine if there are prefixes; fonipa and others don't have prefixes; # operator always returns 0 if variant_table[variant]['prefixes'][1] and not in_array (code, variant_table[variant]['prefixes']) then
for artificial languages (code: art)
[[Category:Articles containing constructed-language text]]
-- table.insert (tout, table.concat ({title_table[std][code:lower()], ' (', lang_name_table.langlang_table[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
validate_cat_args (args); -- determine if categorization should be suppressed
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>}}
if lang_data.override[raw_code:lower= format_ietf_tag ()] then -- look for whole IETF tag in override table (force lower case) language_name = lang_datacode, subtags.script, subtags.region, subtags.variant, subtags.override[raw_code:lower(private)][1]; elseif lang_data.override[code] then -- not there so try basic language code in override table language_name = lang_data.override[code][1]format to recommended subtag styles;private omitted because private elseif not is_set (subtags.variant) then if lang_name_table.lang[code] then language_name = lang_name_table.lang[language_name_get (raw_code, code][1]); -- table entries sometimes have multiple names, always take the first one end else -- TODO: is this the right thing to do: take get language display name from variants table? if lang_name_table.variant[subtags.; try ietf tag first, then code w/o 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.code w/ variant]['descriptions'][1]; -- table entries sometimes have multiple names, always take the first one end end
return language_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink
return language_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data
return language_name = make_wikilink (language_name .. ' language', label or language_name); -- language name with wikilink
return local result, _ = _tag_from_name (getArgs(frame.)) -- pass-on the argstable, 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;
_lang _category_from_tag = _lang_category_from_tag, -- entry points when this module is require()d into other modules _lang = _lang,
--deprecated entry points:
code_from_name = tag_from_name, -- code is wrong; should be tag; these here to ease transition to the proper name
is_ietf_code = is_ietf_tag,
name_from_code = name_from_tag,
_code_from_name = _tag_from_name,
_is_ietf_code = _is_ietf_tag,
_name_from_code = _name_from_tag,
1 revision imported
require('Module:No globals');
local getArgs = require ('Module:Arguments').getArgs;
local yesno = require ('Module:Yesno');
local lang_name_table lang_data = mw.loadData ('Module:Language/nameLang/data'); -- language name override and transliteration tool-tip tableslocal lang_name_table = lang_data.lang_name_table; -- language codes, names, regions, scripts, suppressed scriptslocal 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 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
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
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
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
code = code:lower(); -- ensure that we use and return lower case version of this
if not (lang_data.overrideoverride_table[code] or lang_name_table.langlang_table[code] or synonym_table[code] or lang_dep_table[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
if is_set (script) then
script = script:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.scriptscript_table[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 lang_name_table.suppressedsuppressed_table[script] then -- ensure that code-script does not use a suppressed script if in_array (code, lang_name_table.suppressedsuppressed_table[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
if is_set (region) then
region = region:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.regionregion_table[region] then
return code, script, nil, nil, nil, table.concat ({'unrecognized region: ', region, ' for code: ', code});
end
if is_set (variant) then
variant = variant:lower(); -- ensure that we use and return lower case version of this
if not lang_name_table.variantvariant_table[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}), lang_name_table.variantvariant_table[variant]['prefixes']) then
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code-script pair: ', code, '-', script});
end
return code, script, region, nil, nil, table.concat ({'unrecognized variant: ', variant, ' for code: ', code});
end
end
end
if is_set (private) then
private = private:lower(); -- ensure that we use and return lower case version of this
if not lang_data.overrideoverride_table[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
local category;
if 'translTransl' == template then category = 'translTransl';
else
category = 'lang Lang 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
table.insert (html, table.concat ({'<', tag})); -- open the <i>, <span>, or <div> html tag
code = code:gsub ('%-x%-.*', ''); -- strip private use subtag from code tag because meaningless outside of wikipedia
table.insert (html, table.concat ({' lang="', code, '\"'})); -- add language attribute
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
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
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
table.insert (html, '‎'); -- 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
[[Category:Articles containing explicitly cited English-language text]]
for ISO 639-2 collective languages (and for 639-1 bh):
[[Category:Articles with text from the in <language> languages collective]]
]=]
local function make_category (code, language_name, nocat, name_get)
local cat = {};
local retval; 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 from the in ', language_name, ' collective]]'});
end
table.insert (cat, '[[Category:Articles containing ');
if 'en' == code then
table.insert (cat, 'explicitly cited English'.. language_name); elseif 'art' == code then table.insert (cat, 'constructed') -- falls back to English if regional name not available
else
table.insert (cat, language_name);
table.insert (cat, '-language text]]');
return table.concat (cat);
end
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);
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()], ' (', lang_name_table.scriptscript_table[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?
if title_table[std][code] then -- if language code is in the table (transl may not provide a language code)
else -- code doesn't match
table.insert (tout, title_table[std]['default']); -- so use the standard's default
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
--[[--------------------------< 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 nilend --[[--------------------------< _ L A N G >--------------------------------------------------------------------
entry point for {{lang}}
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 ||code=', args, template);
else
args.code = args[1] or args.code; -- prefer args.code
if args[2] and args.text then
return make_error_msg ('conflicting: {{{2}}} and ||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;
args.text, tag = html_tag_select (args.text); -- inspects text; returns appropriate html tag with text trimmed accordingly
args.rtl = args.rtl == 'yes'; -- convert to boolean: 'yes' -> true, other values -> false
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 ||proto=: ', args.proto}), args, template);
end
end
args.code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private subtags.private language_name = subtags.private and tablelanguage_name_get (args.concat ({code, '-x-'code, subtags.private}true) 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]; -- try ietf tag first look for private use tag language name elseif lang_data.override[code] , then language_name = lang_data.override[code][1] -- w/o variant 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 endw/ variant
if 'invert' == args.italic and 'span' == tag then -- invert only supported for in-line content
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 ||text=', args, template);
else
args.text = args[1] or args.text; -- prefer args.text
if args[2] and args.translit then
return make_error_msg ('conflicting: {{{2}}} and ||translit=', args, template);
else
args.translit = args[2] or args.translit -- prefer args.translit
if args[3] and (args.translation or args.lit) then
return make_error_msg ('conflicting: {{{3}}} and ||lit= or ||translation=', args, template);
elseif args.translation and args.lit then
return make_error_msg ('conflicting: ||lit= and ||translation=', args, template);
else
args.translation = args[3] or args.translation or args.lit; -- prefer args.translation
if args.links and args.link then
return make_error_msg ('conflicting: ||links= and ||link=', args, template);
else
args.link = args.link or args.links; -- prefer args.link
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 ||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 subtags.private language_name = subtagslanguage_name_get (args.private and table.concat ({code, '-x-'code, subtags.private}true) 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]; -- try ietf tag 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.w/o 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.w/ 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)
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)
if 'none' ~= args.label then
table.insert (out, '<small>');
if lang_name_table.scriptscript_table[args['translit-script']] then -- when |translit-script= is set, try to use the script's name translit_script_name = lang_name_table.scriptscript_table[args['translit-script'][1]];
else
translit_script_name = language_name; -- fall back on language name
table.insert (out, make_wikilink ('Literal translation', 'lit.'));
end
table.insert (out, " thinsp;</small>");
end
table.insert (out, table.concat ({''', args.translation, '''})); -- use html entities to avoid wiki markup confusion
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
Module entry point from another module
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
]]
local function is_ietf_tag (frame) return _is_ietf_tag (getArgs (frame)[1]); -- args[1] is the ietf language tag to be tested; also get parent frameend --[[--------------------------< I S _ I E T F _ T A G _ F R A M E >---------------------------------------- ---- Module entry point from an {{#invoke:Lang}}; same as is_ietf_tag() except does not get parameters from the parent(template) frame. This function not useful when called by {{lang|is_ietf_tagfn=is_ietf_tag_frame|<ietf tag>}}because <tag>is in the parent frame. ]] local function is_ietf_tag_frame (frame) return _is_ietf_tag (getArgs (frame.args, {frameOnly = true,})[1]); -- frame.args[1] is the ietf language tagto be tested; do not get parent frame
end
--[[--------------------------< _ N A M E _ F R O M _ C O D E T A G >--------------------------------------------------
Returns language name associated with IETF language tag if valid; empty string error message else.
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
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
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
language_name = language_name:gsub ('%s+%b()', ''); -- remove IANA parenthetical disambiguators or qualifiers from names that have them
if link then -- when |link=yes, wikilink the language name
if language_name:find ('languages') then
elseif lang_data.article_name[code] then
else
end
end
return language_name;
end
--[[--------------------------< N A M E _ F R O M _ C O D E T A G >----------------------------------------------------
Module entry point from an {{#invoke:}}
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
if args[1] and '' ~= args[1] then
local data = mw.loadData ('Module:Lang/tag from name to tag'); -- get the reversed data tablesTODO: 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_lang_datarev_override_table[lang] or data.rev_lang_name_tablerev_lang_table[lang] or data.rev_lang_dep_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
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
local function tag_from_name (frame) -- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}}
end
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; -- translitterated transliterated text to display
local script; -- IANA script
local msg; -- for when called functions return an error message
if not title_table[args.translit_std] then
return make_error_msg (table.concat ({'unrecognized transliteration standard: ', args.translit_std}), args, 'translTransl');
end
else
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
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
end
if lang_data.overrideoverride_table[args.code] then -- is code a language code defined in the override table? language_name = lang_data.overrideoverride_table[args.code][1]; elseif lang_name_table.langlang_table[args.code] then -- is code a language code defined in the standard language code tables? language_name = lang_name_tablelang_table[args.langcode][1]; elseif lang_dep_table[args.code] then -- is code a language code defined in the deprecated language code tables? language_name = lang_dep_table[args.code][1]; elseif lang_name_table.scriptscript_table[args.code] then -- if here, code is not a language code; is it a script code? language_name = lang_name_table.scriptscript_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
local function transl (frame)
return _transl (getArgs(frame));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 = getArgsformat_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); -- no entry point from an {{#invoke:Lang|category_from_tag|<ietf tag>|template=<template name>}} parameters return _transl _category_from_tag (getArgs (frame)); -- pass-on the argstable, nothing else; getArgs();so we also get parent frame
end
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}}
_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,
_transl = _transl,
};