Wikipedia

Modul:Lang/ujian: Perbezaan antara semakan

Layar sejarah secara interaktif
← Suntingan sebelumnyaSuntingan berikutnya →
Kandungan dihapus Kandungan ditambah
Tiada ringkasan suntingan
Tiada ringkasan suntingan
Baris 6:
 
require('Module:No globals');
 
local initial_style_state; -- set by lang_xx_normal() and lang_xx_italic()
 
local getArgs = require ('Module:Arguments').getArgs;
Baris 13 ⟶ 11:
local yesno = require ('Module:Yesno');
 
local lang_name_tablelang_data = mw.loadData ('Module:Language/nameLang/data/ujian'); -- 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
Baris 114 ⟶ 120:
local count = 0
for _, arg in pairs {'italic', 'italics', 'i', 'italik'} do
if args[arg] then
count = count + 1
Baris 121 ⟶ 127:
 
if count > 1 then -- return nil and an error message if more than one is set
return nil, 'hanyaonly satuone dariof |italic=, |italics=, or |i= atau |italik=can bolehbe diperincikanspecified';
end
Baris 186 ⟶ 192:
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
Baris 216 ⟶ 227:
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
 
Baris 246 ⟶ 257:
 
if not is_set (source) then
return nil, nil, nil, nil, nil, 'tegmissing bahasalanguage hilangtag';
end
 
Baris 301 ⟶ 312:
 
if not code then
return nil, nil, nil, nil, nil, table.concat ({'tegunrecognized bahasalanguage tidak diiktiraftag: ', source}); -- don't know what we got but it is malformed
end
 
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 ({'tegunrecognized bahasalanguage tidak diiktirafcode: ', code}); -- invalid language code, don't know about the others (don't care?)
end
if synonym_table[code] then -- if 639-2/639-2T code has a 639-1 synonym
table.insert (maint_cats, table.concat ({'KodLang lang danand lang-xx digalakkancode promoted keto ISO 639-1|', code}));
table.insert (maint_msgs, table.concat ({'kodcode: ', code, ' digalakkanpromoted keto kodcode: ', synonym_table[code]}));
code = synonym_table[code]; -- use the synonym
end
Baris 318 ⟶ 329:
if is_set (script) then
if is_set (args_script) then
return code, nil, nil, nil, nil, 'tegredundant aksarascript lewahtag'; -- both code with script and |script= not allowed
end
else
Baris 326 ⟶ 337:
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 ({'aksaraunrecognized tidak diiktirafscript: ', script, ' untukfor kodcode: ', 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 ({'aksarascript: ', script, ' tidaknot disokongsupported untukfor kodcode: ', code}); -- language code ok, script is suppressed for this code
end
end
Baris 338 ⟶ 349:
if is_set (region) then
if is_set (args_region) then
return code, nil, nil, nil, nil, 'tegredundant rantauregion lewahtag'; -- both code with region and |region= not allowed
end
else
Baris 346 ⟶ 357:
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 ({'rantauunrecognized tidak diiktirafregion: ', region, ' untukfor kodcode: ', code});
end
end
Baris 353 ⟶ 364:
if is_set (variant) then
if is_set (args_variant) then
return code, nil, nil, nil, nil, 'tegredundant varianvariant lewahtag'; -- both code with variant and |variant= not allowed
end
else
Baris 361 ⟶ 372:
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 ({'varianunrecognized tidak diiktirafvariant: ', 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 ({'varianunrecognized tidak diiktirafvariant: ', variant, ' untuk pasanganfor aksaracode-script kodpair: ', 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, lang_name_table.variantvariant_table[variant]['awalanprefixes']) then
return code, script, region, nil, nil, table.concat ({'varianunrecognized tidak diiktirafvariant: ', variant, ' untukfor kodcode: ', code});
end
end
Baris 377 ⟶ 394:
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 ({'tegunrecognized persendirianprivate tidak diiktiraftag: ', private});
end
end
Baris 398 ⟶ 415:
category = 'transl';
else
category = 'lang danand lang-xx'
end
Baris 404 ⟶ 421:
table.insert (out, table.concat ({'<span style=\"font-size:100%; font-style:normal;\" class=\"error\">error: {{', template, '}}: '}));
table.insert (out, msg);
table.insert (out, table.concat ({' ([[:KategoriCategory:Ralat templat ', category, ' template errors|bantuanhelp]])'}));
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 ({'[[KategoriCategory:Ralat templat ', category, ' template errors]]'}));
end
 
Baris 480 ⟶ 497:
 
if text:match ('^%*') then
table.insert (html, '&#42;'); -- move proto language text prefix outside of italic markup if any; use numeric entity because planeplain splat confuses MediaWiki
text = text:gsub ('^%*', ''); -- remove the splat from the text
end
Baris 514 ⟶ 531:
 
if is_set (language) then
table.insert (html, table.concat ({style_added, ' title=\"', language})); --start the title text
if language:find ('[Bb]ahasa-bahasa' or '[Bb]ahasalanguages') then
table.insert (html, table.concat ({'Teks kolektif bahasacollective text', language, '\"'})); -- for collective languages
else
table.insert (html, table.concat ({'Teks bahasa ', 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
Baris 531 ⟶ 548:
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
Baris 539 ⟶ 555:
 
For individual language, <language>, returns:
[[KategoriCategory:Articles containing <language>-language text]]
 
for English:
[[KategoriCategory:Articles containing explicitly cited English-language text]]
for artificial languages (code: art)
[[Kategori:Articles containing constructed-language text]]
 
for ISO 639-2 collective languages (and for 639-1 bh):
[[KategoriCategory:Articles with text from 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 ('[Bb]ahasa-bahasa' or '[Bb]ahasalanguages') then
return table.concat ({'[[KategoriCategory:RencanaArticles denganwith tekstext kolektiffrom dari bahasathe ', language_name, ' collective]]'});
-- return table.concat ({'[[Category:Articles with text from ', language_name, ']]'}); -- proposed version at Wikipedia:Categories_for_discussion/Log/2020_August_18#Category:Articles_with_text_from_the_Afro-Asiatic_languages_collective
end
table.insert (cat, '[[KategoriCategory:RencanaArticles yang mengandungi teks bahasacontaining ');
 
if 'msen' == code then
table.insert (cat, 'secaraexplicitly jelascited menyebut' Bahasa.. Melayu]]'language_name); -- falls back to English if regional name not available
elseif 'art' == code then
table.insert (cat, 'yang dibina')
else
table.insert (cat, language_name .. ']]');
end
table.insert (cat, '-language text]]');
 
return table.concat (cat);
end
 
Baris 601 ⟶ 616:
if is_set (code) then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
if not style then -- nil for is the default italic style
table.insert (tout, "<i lang=\""); -- so use <i> tag
else
Baris 615 ⟶ 630:
if not is_set (std) and not is_set (tscript) then -- when neither standard nor script specified
table.insert (tout, language_name); -- write a generic tool tip
if not language_name:find ('[Bb]ahasa-bahasa' or '[Bb]ahasalanguages') then -- collective language names (plural 'languages' is part of the name)
table.insert (tout, 'bahasa -language') -- skip this text (individual and macro languages only)
end
table.insert (tout, 'Transliterasi romanization'); -- finish the tool tip; use romanization when neither script nor standard supplied
elseif is_set (std) and is_set (tscript) then -- when both are specified
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 ({'Transliterasi ', title_table[std][tscript:lower()], ' (tulisan bahasa ', 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?
Baris 635 ⟶ 650:
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 ({'Transliterasi ', title_table[std][code:lower()], ' (bahasa ', 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
else -- code doesn't match
table.insert (tout, title_table[std]['default']); -- so use the standard's default
Baris 646 ⟶ 662:
else
if is_set (tscript) then
table.insert (tout, table.concat ({language_name, 'Transliterasi tulisan bahasa-script transliteration', language_name})); -- write a script tool tip
elseif is_set (code) then
if not language_name:find ('languages') then -- collective language names (plural 'languages' is part of the name)
table.insert (tout, 'transliterasi '); -- finish the tool tip
table.insert (tout, '-language') -- skip this text (individual and macro languages only)
if not language_name:find ('[Bb]ahasa-bahasa' or '[Bb]ahasa') then -- collective language names (plural 'languages' is part of the name)
table.insert (tout, 'bahasa ') -- skip this text (individual and macro languages only)
end
table.insert (tout, ' transliteration'); -- finish the tool tip
else
table.insert (tout, 'transliterasi transliteration'); -- generic tool tip (can we ever get here?)
end
end
Baris 660 ⟶ 676:
table.insert (tout, '">');
table.insert (tout, translit);
if is_set (code) and not style then -- when a language code is provided (always with {{lang-xx}} templates, not always with {{transl}})
table.insert (tout, "</i>"); -- close the italic tag
else
Baris 681 ⟶ 697:
local function validate_text (template, args)
if not is_set (args.text) then
return make_error_msg ('tiadano tekstext', args, template);
end
 
if args.text:find ("%f[\']\'\'\'\'%f[^\']") or args.text:find ("\'\'\'\'\'[\']+") then -- because we're looking, look for 4 appostrophes or 6+ appostrophes
return make_error_msg ('tekstext mempunyaihas penandamalformed cacatmarkup', args, template);
end
 
Baris 692 ⟶ 708:
if ('unset' ~= style) and ('invert' ~=style) then
if args.text:find ("%f[\']\'\'%f[^\']") or args.text:find ("%f[\']\'\'\'\'\'%f[^\']") then -- italic but not bold, or bold italic
return make_error_msg ('tekstext mempunyaihas penandaitalic italikmarkup', args, template);
end
end
Baris 717 ⟶ 733:
if (0 < #maint_cats) and (0 == namespace) and not nocat then -- when there are maintenance categories; article namespace only
for _, cat in ipairs (maint_cats) do
table.insert (maint, table.concat ({'[[KategoriCategory:', cat, ']]'})); -- format and add the categories
end
end
Baris 797 ⟶ 813:
return text, tag;
end
 
 
--[[--------------------------< V A L I D A T E _ P R O T O >--------------------------------------------------
 
validates value assigned to |proto=; permitted values are yes and no; yes returns as true, no returns as false,
empty string (or parameter omitted) returns as nil; any other value returns as nil with a second return value of
true indicating that some other value has been assigned to |proto=
 
]]
 
local function validate_proto (proto_param)
if 'yes' or 'ya' == proto_param then
return true;
elseif 'no' or 'tidak' == proto_param then
return false;
elseif is_set (proto_param) then
Baris 816 ⟶ 835:
end
 
 
--[[--------------------------< L A N G >----------------------------------------------------------------------
--[[--------------------------< 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}}
Baris 823 ⟶ 879:
<includeonly>{{#invoke:lang|lang}}</includeonly>
 
parameters are recievedreceived from the template's frame (parent frame)
 
]]
Baris 830 ⟶ 886:
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
Baris 835 ⟶ 892:
local tag = 'span'; -- initial value for make_text_html()
local template = args.template or 'lang';
 
validate_cat_args (args); -- determine if categorization should be suppressed
 
if args[1] and args.code then
Baris 854 ⟶ 913:
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
 
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, ' tidak sah'}), args, template);
end
 
code, subtags.script, subtags.region, subtags.variant, subtags.private, msg = get_ietf_parts (args.code); -- |script=, |region=, |variant= not supported because they should be part of args.code ({{{1}}} in {{lang}})
Baris 892 ⟶ 949:
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
args.text = invert_italics (args.text)
end
 
args.text = proto_prefix (args.text, language_name, args.proto); -- prefix proto-language text with a splat
 
Baris 916 ⟶ 964:
return table.concat (out); -- put it all together and done
end
 
 
--[[--------------------------< L A N G >----------------------------------------------------------------------
 
entry point for {{lang}}
 
there should be no reason to set parameters in the {{lang}} {{#invoke:}}
<includeonly>{{#invoke:lang|lang}}</includeonly>
 
parameters are received from the template's frame (parent frame)
 
]]
 
Baris 938 ⟶ 991:
end -- end of valueFunc
});
return _lang (args);
 
return _lang (args);
end
 
 
--[[--------------------------< L A N G _ X X >----------------------------------------------------------------
Baris 1,067 ⟶ 1,121:
end
end
 
args.proto, msg = validate_proto (args.proto); -- return boolean, or nil, or nil and error message flag
if msg then
Baris 1,072 ⟶ 1,127:
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)
Baris 1,103 ⟶ 1,141:
table.insert (out, language_name); -- language name without wikilink
else
if language_name:find ('[Bb]ahasa-bahasa' or '[Bb]ahasalanguages') then
table.insert (out, make_wikilink (language_name)); -- collective language name uses simple wikilink
elseif lang_data.article_name[code] then
table.insert (out, make_wikilink (lang_data.article_name[code][1], language_name)); -- language name with wikilink from override data
else
table.insert (out, make_wikilink ('Bahasa 'language_name .. language_name, 'Bahasa language' .., language_name)); -- language name with wikilink
end
end
Baris 1,120 ⟶ 1,158:
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, 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)
Baris 1,126 ⟶ 1,164:
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
end
translit_title = mw.title.makeTitle (0, table.concat ({'PerumianRomanization untukof ', translit_script_name})); -- make a title object
if translit_title.exists and ('no' ~= args.link) then
table.insert (out, make_wikilink ('PerumianRomanization untukof ' .. translit_script_name or 'translit.language_name, 'romanized') .. language_name)':'); -- make a wikilink if there is an article to link to
else
table.insert (out, '<abbr title="transliterasi">translit.</abbr>romanized:'); -- else define theplain abbreviationtext
end
table.insert (out, '&nbsp;</small>'); -- close the small tag
Baris 1,153 ⟶ 1,191:
table.insert (out, '<small>');
if 'no' == args.link then
table.insert (out, '<abbr title="terjemahan literal translation">lit.</abbr>');
else
table.insert (out, make_wikilink ('TerjemahanLiteral literaltranslation', 'lit.'));
end
table.insert (out, "&nbsp;</small>");
Baris 1,167 ⟶ 1,205:
return table.concat (out); -- put it all together and done
end
 
 
--[[--------------------------< L A N G _ X X _ A R G S _ G E T >----------------------------------------------
Baris 1,254 ⟶ 1,293:
 
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
Baris 1,263 ⟶ 1,299:
 
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
Baris 1,276 ⟶ 1,312:
]]
 
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; getArgs() so we also get parent frame
end
 
 
--[[--------------------------< _ N A M E _ F R O M _ CT OA D EG >--------------------------------------------------
 
Returns language name associated with IETF language tag if valid; emptyerror stringmessage else.
 
All code combinations supported by {{lang}} and the {{lang-xx}} templates are supported by this function.
Baris 1,297 ⟶ 1,333:
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
Baris 1,307 ⟶ 1,344:
end
 
raw_code = format_ietf_tag (code, subtags.script, subtags.region, subtags.variant, subtags.private); -- format to recommended subtag styles; private omitted because private
if lang_data.override[raw_code:lower()] then -- look for whole IETF tag in override table (force lower case)
language_name = language_name_get (raw_code, code); -- get language name; try ietf tag first, then code w/o variant then code w/ variant
language_name = lang_data.override[raw_code:lower()][1];
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
 
if link then -- when |link=yes, wikilink the language name
if language_name:find ('[Bb]ahasa-bahasa' or '[Bb]ahasalanguages') then
returnlanguage_name = make_wikilink (language_name, label); -- collective language name uses simple wikilink
elseif lang_data.article_name[code] then
returnlanguage_name = make_wikilink (lang_data.article_name[code][1], label or language_name); -- language name with wikilink from override data
else
returnlanguage_name = make_wikilink ('Bahasa 'language_name .. language_name, 'Bahasa language', ..label or language_name); -- language name with wikilink
end
end
 
return language_name;
 
end
 
 
--[[--------------------------< N A M E _ F R O M _ CT OA D EG >----------------------------------------------------
 
Module entry point from an {{#invoke:}}
Baris 1,345 ⟶ 1,370:
 
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
 
Baris 1,363 ⟶ 1,388:
 
if args[1] and '' ~= args[1] then
local data = mw.loadData ('Module:Lang/nametag tofrom tagname'); -- 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_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
Baris 1,391 ⟶ 1,416:
 
local function tag_from_name (frame) -- entry point from an {{#invoke:Lang|tag_from_name|<language name>|link=<yes>|template=<template name>}}
returnlocal result, _ = _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
 
Baris 1,435 ⟶ 1,473:
end
else
return make_error_msg ('missing language / script code', args, 'transl'); -- missing language / script code so quit
end
 
Baris 1,447 ⟶ 1,485:
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_table.langlang_table[args.code][1];
elseif lang_name_table.scriptlang_dep_table[args.code] then -- if here,is code is not a language code; isdefined itin athe scriptdeprecated language code tables?
language_name = lang_name_table.scriptlang_dep_table[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
Baris 1,470 ⟶ 1,510:
 
local function transl (frame)
localreturn args =_transl (getArgs(frame)); -- no {{#invoke:}} parameters
end
return _transl (args);
 
 
--[[--------------------------< 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
 
Baris 1,479 ⟶ 1,562:
 
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_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_category_from_tag = _lang_category_from_tag, -- 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,
Diambil daripada "https://ms.wikipedia.org/wiki/Modul:Lang/ujian"