Allocosm - User contributions [en]

Template:Interlinear/styles.css

2024-04-07T03:03:38Z

Vaxjedi: Created page with "/* {{pp-template}} ------------------------------------------ -- use in the 'classN' parameter ------------------------------------------ */ .interlinear .bold { font-weight: bold; } /* "font-variant:small-caps;" ignores oddball letters (such as ḥ) "text-transform: uppercase;" handles them */ .interlinear .smallcaps { text-transform: uppercase; font-size: smaller; }"

/* {{pp-template}}
------------------------------------------
-- use in the 'classN' parameter
------------------------------------------ */
.interlinear .bold {
font-weight: bold;
}

/* "font-variant:small-caps;" ignores oddball letters (such as ḥ)
"text-transform: uppercase;" handles them */
.interlinear .smallcaps {
text-transform: uppercase;
font-size: smaller;
}

Test/Interlinear/styles.css

2024-04-05T21:23:06Z

Test

2024-04-05T21:21:57Z

Vaxjedi:

{{interlinear
|Nginda-rni ngaja-mi jurliji-rdarra diyim ka-rdu
|DEM(M)-FOC see-IRR bird-PL fly 3SG-go
|'Look at all the birds flying!'}}

Module:Interlinear

2024-04-05T21:21:10Z

Vaxjedi:

local p = {}
local data = mw.loadData( 'Module:Interlinear/data' )
local gloss_override = {} -- for custom gloss abbreviations
local getArgs = require('Module:Arguments').getArgs
local yesno = require('Module:Yesno')
--local lang_data = mw.loadData( 'Module:Lang/data' )

--------------------------
-- Almost-global variables
--------------------------
local glossing_type, displaying_messages, free_translation, msg, buffer

-------------------
-- General settings
-------------------
local conf = { --settings
WordSeparator = " \n\r\t", -- Don't replace with %s as this would include non-breaking spaces
GlossAbbrPattern = "^([Ø0-9A-Z]+)$", -- this isn't a full regex, but a Lua pattern
-- NOTE: The following characters must be formatted for use in a pattern set.
GlossAbbrBoundary = "-.,;:<>‹›/\\~+=%?%s%[%]()%_\127'",
GlossExcludeTable = {I = true,}, --strings not be treated as glossing abbreviations
GlossExcludePattern = '^[0-9][0-9]+$', -- excludes strings consisting entirely of digits
GlossSmallCapsExclude = "^[AOPS]$", -- glossing abbreviations matching this pattern will not be rendered in small caps
GlossingType = "label", -- if set to "label" gloss abbreviations are formatted as an <abbr> with the "label" appearing in a tooltip
-- if set to "wikilink" the abbreviation is formatted as a wikilink to the relevant wikipedia article
-- if set to "none" abbreviations aren't formatted at all
ErrorCategory = "[[Category:Pages with errors in interlinear text]]",
AmbiguousGlossCategory = "[[Category:Articles with ambiguous glossing abbreviations]]",
MessageGlossingError = "Error(s) in interlinear glossing",
combining_gender_numbers = "[0-9][0-9]?$", --e.g. G4 '4th gender' or CL7 'class 7'
combining_gender_prefixes = {G = "gender", CL = "class"},
combining_person = {["1"] = "first person", ["2"] = "second person", ["3"] = "third person"},
combining_number = {S = "singular", SG = "singular", P = "plural", PL = "plural", D = "dual", DU = "dual", TRI = "trial"},
combining_gender = {F = "feminine", M = "masculine", N = "neuter"},
LowerCaseGlosses = {["1sg"] = true, ["2sg"] = true, ["3sg"] = true, ["1du"] = true, ["2du"] = true, ["3du"] = true, ["1pl"] = true, ["2pl"] = true,
["3pl"] = true, ["Fsg"] = true, ["Fpl"] = true, ["Msg"] = true, ["Mpl"] = true,}, -- these are the non-all-upper-case strings that will be recognised as glossing abbreviations
ErrorHelpLocation = "Template:Interlinear",
}

---------------------
-- CSS styles and classes
---------------------
conf.style = { --CSS styles
WordDiv = "float: left; margin-bottom: 0.3em;",
WordMargin = "margin-right: 1em;",
WordP = "margin: 0px;", -- the style for the word <p> elements
GlossAbbr = "font-variant: small-caps; font-variant-numeric: oldstyle-nums; text-transform: lowercase; ", -- won't be applied to gloss abbreviations containing lower-case characters
HiddenText = "display: none;",
EndDiv = "clear: left; display: block;", -- style of the <div> element at the end of the interlinear display
ErrorMessage = "font-size: inherit",
}
conf.class = { --CSS classes
Interlinear = "interlinear",
GlossAbbr = "gloss-abbr",
GlossAbbrAmb = "gloss-abbr-ambiguous",
GlossAbbrError = "gloss-abbr-error",
ErrorMessage = "error",
}
---------------------
-- Section transclusion
---------------------
local page_content = nil -- lazy initilization
local function get_section(frame, section_name)
if page_content == nil then
local current_title = mw.title.getCurrentTitle()
page_content = current_title:getContent()
end
if page_content then
if mw.ustring.find(page_content, section_name, 1, true) then
return frame:preprocess('{{#section:{{FULLPAGENAME}}|' .. section_name .. '}}')
end
end
return ''
end
---------------------
-- Sundry small functions
---------------------
local function normalise(str)
return mw.ustring.gsub(str,"[" .. conf.WordSeparator .. "]+"," ")
end

local function tidyCss(str)
str = mw.ustring.gsub(str, '^[\"\']*(.-)[\"\']*$', "%1") -- trims quotation marks
if mw.ustring.sub(str, -1) ~= ";" then str = str .. ";" end -- appends ";" if missing
return str
end

local function highlight(text)
if text then
return '<span style="color:#C00;font-weight:bold;">' .. text .. '</span>'
else return "" end
end

local function tone_sup(str)
return mw.ustring.gsub(str, "([^%p%s0-9])([0-9]+)", "%1<sup>%2</sup>")
end

local function is_empty(str) -- returns "false" if its argument is a string containing chars other than spaces &c.
if not str then return true end
if mw.ustring.find(str, "[^" .. conf.WordSeparator .. "]")
then return false
else return true end
end

local function help_link (anchor)
if anchor then
return " ([[" .. conf.ErrorHelpLocation .. "#" .. anchor .. "|help]])"
else return "" end
end

-- the following is part of a trial implementation of automatic transliteration:
local function transliterate (str, lang_from, lang_to, scheme)
local lookup = {grc = {module = 'Module:Ancient Greek', funct = "transliterate", } }
if not lang_from then
msg:add("error", "Source language for transliteration is not set")
else
local t = lookup[lang_from]
if t then
local module = require(t.module)
return module[t.funct](str)
else msg:add("error", "Can't find transliterator for language '" .. lang_from .. "'")
end
end
return ""
end -- end of trial block

--------------------
-- The following two functions update the glossing settings based on the received
-- template arguments. set_global_glossing_settings() updates the global settings
-- that are valid for all gloss abbreviations. set_glossing_type()
-- returns the glossing type, which can vary between the different lines.
--------------------
local function set_global_glossing_settings(a)
local style = ""
if a.style then style = tidyCss(a.style) end
if a.underline == "no" then
style = style .. "text-decoration: none;" end
if a.small_caps == "no" then
style = style .. "font-variant:normal; text-transform: none;" end
if style ~= "" then conf.style.GlossAbbr = conf.style.GlossAbbr .. style end
end

local function set_glossing_type(glossing)
if glossing then
local GlossingType
glossing = mw.ustring.lower(mw.text.trim(glossing))
if mw.ustring.find(glossing, 'link') then
GlossingType = "wikilink"
elseif mw.ustring.find(glossing, 'label')
or mw.ustring.find(glossing, 'no link') then
GlossingType = 'label'
elseif mw.ustring.find(glossing, 'no abbr') then
GlossingType = "no abbr"
elseif yesno(glossing) == false then
GlossingType = nil
elseif yesno(glossing) then
GlossingType = conf.GlossingType
else
msg:add('error', 'Glossing type "' .. glossing .. '" not recognised') end
return GlossingType
else error("set_glossing_type: 'glossing' is nil or false", 2)
end
end

local function set_custom_glosses(list)
local abbs = mw.text.split(list, '[;\n\t]')
for _,v in pairs(abbs) do
local gloss = mw.text.split(v, ':')
local a = mw.text.trim(gloss[1])
if a and a ~= "" then
gloss_override[a] = {}
gloss_override[a].expansion = gloss[2]
gloss_override[a].wikipage = gloss[3]
end
end
end

---------------------
-- The UserMessages object contains and processes error messages and warnings
---------------------
local UserMessages = {errors = {}, warnings = {}, gloss_messages = {}}
function UserMessages:add(msgtype, text, gloss)
if msgtype == "gloss_message" then
self.gloss_messages[gloss] = text
elseif msgtype == "warning" then
table.insert(self.warnings, text)
elseif msgtype == "non-repeating error" then
self.errors.nre = text
elseif msgtype == "ambiguous gloss" then
self.if_ambiguous_glosses = true
elseif msgtype == "error" then
table.insert(self.errors, text)
else return error("UserMessages:add(): unknown message type", 2)
end
end
function UserMessages:print_errors()
local out = ""
local namespace = mw.title.getCurrentTitle().namespace
if next(self.errors) or self.warnings[1] then
local err_span = mw.html.create("span")
err_span:attr("style", conf.style.ErrorMessage)
err_span:addClass(conf.class.ErrorMessage)
for _,v in pairs(self.errors) do
err_span:wikitext(" " .. v .. ";") end
if namespace % 2 == 0 and namespace ~= 2 -- non-talk namespaces, excluding user pages; if modifying please update the description on the category page
then err_span:wikitext(conf.ErrorCategory)
end
out = tostring(err_span)
mw.addWarning(conf.MessageGlossingError)
end
if self.if_ambiguous_glosses then
if namespace == 0 -- article namespace
then out = out .. conf.AmbiguousGlossCategory -- this category will only track articles
end
end
return out
end
function UserMessages:print_warnings()
local out = ""
-- Messages and warnings get displayed only if the page is being viewed in "preview" mode:
if displaying_messages and (next(self.gloss_messages) or next(self.warnings)) then
local div = mw.html.create("div")
div:addClass("interlinear-preview-warning")
:cssText('border: 1px solid #a2a9b1; background-color: #f8f9fa; width: 80%; padding: 0.2em;')
:wikitext("<i>This message box is shown only in preview:</i>")
:newline()
for _,v in ipairs(self.warnings) do
local p = div:tag("p")
p:addClass(conf.class.ErrorMessage)
p:attr("style", conf.style.ErrorMessage)
p:wikitext(v)
end
if self.gloss_messages then
div:wikitext("<p> To change any of the following default expansions, see [[Template:Interlinear/doc#Custom abbreviations|the template's documentation]]:</p>")
end
for _,v in pairs(self.gloss_messages) do
div:wikitext("<p>" .. v .. "</p>")
end
out = out .. "\n\n" .. tostring(div)
end
return out
end

---------------------
-- gloss_lookup() receives a gloss abbreviation and tries to uncover its meaning.
---------------------
local function gloss_lookup(a, label, wikilink)
local _label, _wikilink, _lookup, source = nil, nil, nil, nil
if gloss_override[a] then
_lookup = gloss_override[a]
source = "local"
elseif data.abbreviations[a] then _lookup = data.abbreviations[a] end
if _lookup and _lookup.expansion ~= "" then
_label, _wikilink = _lookup.expansion, _lookup.wikipage
else
local prefix = mw.ustring.sub(a,1,1)
local suffix = mw.ustring.sub(a,2)
if conf.combining_person[prefix] then -- is it of the form 1PL or 3FS?
_label = conf.combining_person[prefix]
local _suffix = conf.combining_number[suffix] or conf.combining_gender[suffix]
if _suffix then
_label = _label .. ", " .. _suffix
else
local suffix1 = mw.ustring.sub(suffix,1,1)
local suffix2 = mw.ustring.sub(suffix,2)
if conf.combining_gender[suffix1]
and conf.combining_number[suffix2] then
_label = _label .. ", " .. conf.combining_gender[suffix1] .. ", " .. conf.combining_number[suffix2]
else _label = nil end
end
elseif mw.ustring.match(suffix,conf.combining_gender_numbers) then -- cases like G4 = gender 4
local _i,_j = mw.ustring.find(a, conf.combining_gender_numbers)
local _pre = mw.ustring.sub(a, 1, _i - 1)
local _suff = mw.ustring.sub(a, _i)
if conf.combining_gender_prefixes[_pre] then
_label = conf.combining_gender_prefixes[_pre] .. " " .. _suff
end
elseif prefix == "N" then -- dealing with cases like NPST = non-past
local s = gloss_override[suffix] or data.abbreviations[suffix]
if s ~= nil and not s.ExcludeNegation then
_label = "non-" .. s.expansion
_wikilink = s.wikipage
end
s = nil
end
end
if _label == "" then _label = nil end
if _wikilink == "" then _wikilink = nil end
if not label then label = _label end
if not wikilink then wikilink = _wikilink end
return label, wikilink, source
end

---------------------
-- format_gloss() calls gloss_lookup() to find the meaning of a gloss
-- abbreviation, which it then proceeds to format
---------------------
local function format_gloss(gloss, label, wikilink)
if string.sub(gloss,1,3) == "000" then -- checks for a common component of exposed strip markers (see [[:mw:Strip marker]])
return gloss
end
local gloss2 = mw.ustring.gsub(gloss,"<.->","") -- remove any html fluff
gloss2 = mw.ustring.gsub(gloss2, "%'%'+", "") -- remove wiki bold/italic formatting
gloss2 = mw.text.trim(mw.ustring.upper(gloss2))
if not (label or wikilink)
or (not label and glossing_type == "label")
or (not wikilink and glossing_type == "wikilink")
then
if glossing_type ~= "no abbr"
then label, wikilink, source = gloss_lookup(gloss2, label, wikilink)
end
end
local gloss_node
if glossing_type == "no abbr"
then gloss_node = mw.html.create("span")
else gloss_node = mw.html.create("abbr") end
gloss_node:addClass(conf.class.GlossAbbr)
if label or wikilink then
if not mw.ustring.match(gloss, "%l") -- excluding glosses that contain lower-case characters
and not mw.ustring.match(gloss,conf.GlossSmallCapsExclude) -- and also excluding A, O etc. from rendering in small caps
then gloss_node:attr("style", conf.style.GlossAbbr)
end
local abbr_label
if label then abbr_label = label
else abbr_label = wikilink end
gloss_node:attr("title", abbr_label)
if source ~= "local" and data.abbreviations[gloss2] then
if data.abbreviations[gloss2].ambiguous then
gloss_node:addClass(conf.class.GlossAbbrAmb)
msg:add("ambiguous gloss")
end
end
if glossing_type == "wikilink" and wikilink
then gloss_node:wikitext("[[", wikilink, "|" , gloss, "]]")
else gloss_node:wikitext(gloss) end
if source ~= "local" and displaying_messages then -- logging gloss lookups:
local message = ""
if label then
message = "assuming " .. gloss2 .. " means \"" .. abbr_label .. "\";" end
if glossing_type == "wikilink" and wikilink then
message = message .. " linking to [[" .. wikilink .. "]];"
end
msg:add("gloss_message", message, gloss)
end
elseif glossing_type == "no abbr"
then gloss_node
:attr("style", conf.style.GlossAbbr)
:wikitext(gloss)
else
if displaying_messages then
msg:add("warning", "Gloss abbreviation " .. highlight(gloss2) .. " not recognised" .. help_link("gloss abbr"))
end
msg:add("non-repeating error", "Unknown glossing abbreviation(s)" .. help_link("gloss abbr"))
gloss_node
:addClass(conf.class.GlossAbbrError)
:addClass("error")
:css("font-size", "100%")
:attr("title", gloss2 .. ": glossing abbreviation not found")
:attr("style", conf.style.ErrorMessage)
:wikitext(gloss)
end
return tostring(gloss_node)
end

---------------------
-- find_gloss() parses a word into morphemes, and it calls format_gloss()
-- for anything that looks like a glossing abbreviation.
---------------------
local function find_gloss(word)
local function scan_gloss(boundary, gloss_abbr) -- checks a morpheme if it is a gloss abbreviation
if (mw.ustring.match(gloss_abbr, conf.GlossAbbrPattern)
or conf.LowerCaseGlosses[gloss_abbr])
and not (conf.GlossExcludeTable[gloss_abbr]
or mw.ustring.match(gloss_abbr, conf.GlossExcludePattern))
then gloss_abbr = format_gloss(gloss_abbr)
end
return boundary .. gloss_abbr
end
local word = mw.text.decode(word, true)
if word == "I" -- for the case of the English word "I", the 1SG pronoun
then return word end
local pattern = "([" .. conf.GlossAbbrBoundary .. "]?)([^" .. conf.GlossAbbrBoundary .. "]+)"
word = mw.ustring.gsub(word, pattern, scan_gloss) -- splits into morphemes
return word
end

---------------------
-- The main purpose of the bletcherous parse() is to split a line into words and and then for each eligible word
-- to call find_gloss(). The parser outputs the individual words (with any gloss abbreviation formatting applied).
-- The simple job of splitting at whitespaces has been made complicated by a) the fact that the input can contain
-- whitespaces inside the various html elements that are the result of the application of various formatting templates;
-- and b) the need to be able to recognise the output of the template that formats custom gloss abbreviations
-- (and hence skip passing it on to find_gloss). See talk for a suggestion about its future.
---------------------
local function parse(cline, i, tags_found,ifglossing)

local function issue_error(message, culprit)
UserMessages:add("error", message .. ": ''" .. mw.ustring.sub(cline.whole, 1, i-1) .. "'''" .. culprit .. "'''''")
end
if i > cline.length then return i end --this will only be triggered if the current line has less words than line 1
local next_step, j, _, chunk
local probe = mw.ustring.sub(cline.whole,i,i)
if mw.ustring.match(probe,"[" .. conf.WordSeparator .. "]") and tags_found == 0
then next_step = i-1
elseif probe == "[" then --Wikilink?
if mw.ustring.sub(cline.whole,i+1,i+1) == "[" then
_,j,chunk = mw.ustring.find(cline.whole,"(%[%[.-%]%])", i)
else chunk = "["; j = i end --not a wikilink then
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
elseif probe == "{" and tags_found == 0 then --curly brackets enclose a sequence of words to be treated as a single unit
_,j,chunk = mw.ustring.find(cline.whole,"(.-)(})", i+1)
if not chunk then
issue_error("Unclosed curly bracket", "{")
chunk = highlight("{"); j = i
elseif ifglossing==true then
chunk = find_gloss(chunk)
else
if cline.tone_sup then chunk = tone_sup(chunk) end
end
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
elseif probe == "<" then -- We've encountered an HTML tag. What do we do now?
local _,j,chunk = mw.ustring.find(cline.whole,"(<.->)",i)
if not chunk then
issue_error("Unclosed angle bracket", "<")
chunk = highlight("<"); j = i
elseif mw.ustring.sub(cline.whole,i,i+1) == "</" then -- It's a CLOSING tag
if cline.glossing
and ifglossing==false
and mw.ustring.match(chunk,"</abbr>")
then ifglossing=true end
tags_found = tags_found - 1
elseif not mw.ustring.match(chunk, "/>$") -- It's an OPENING tag, unless it opens a self-closing element (in which case the element is ignored)
then if ifglossing == true -- the following checks for the output of {{ggl}}:
and mw.ustring.find(chunk, conf.class.GlossAbbr, 1, true) -- it's important that the "find" function uses literal strings and not patterns
then ifglossing = false end
tags_found = tags_found + 1
end
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
else -- No HTML tags, so we only need to find where the word ends
local _,k,chunk = mw.ustring.find(cline.whole,"(..-)([ <[])",i)
if k then --ordinary text
if ifglossing==true then
buffer = buffer .. find_gloss(chunk)
else
if cline.tone_sup then chunk = tone_sup(chunk) end
buffer = buffer .. chunk
end
next_step = parse(cline, k, tags_found, ifglossing)
else -- reached end of string
if ifglossing == true then
chunk = find_gloss(mw.ustring.sub(cline.whole,i))
else
chunk = mw.ustring.sub(cline.whole,i)
if cline.tone_sup then chunk = tone_sup(chunk) end
end
buffer = buffer .. chunk
next_step = cline.length
end
end
return next_step
end
--------------------
-- The following function is called by Template:gcl and is used for formatting an individual glossing abbreviation
--------------------
function p.gcl(frame)
local args = getArgs(frame,{
trim = true,
removeBlanks = false,
parentOnly = true,
wrappers = {'Template:Gcl'},
})
msg = UserMessages
set_global_glossing_settings{style = args.style, underline = args.underline, small_caps = args['small-caps']}
if not args.glossing then
glossing_type = conf.GlossingType -- a global variable
else glossing_type = set_glossing_type(args.glossing)
end
local gloss, label, wikilink = args[1], args[2], args[3]
if not gloss then UserMessages:add("error", "No gloss supplied")
return UserMessages:print() end
if wikilink and not args.glossing then -- if a wikilink is supplied and glossing isn't set to 'label'...
glossing_type = 'wikilink' end -- .. then the wikilink will be formatted as such
if label == "" then label = nil end
if wikilink == "" then wikilink = nil end
local result = format_gloss(gloss, label, wikilink)
return result
end

--------------------
-- The following is the function called by Template:Interlinear.
-- It processes the template arguments, then calls parse() to split the input lines into words
-- and it then builds the output html.
--------------------
function p.interlinearise(frame)
---------------------
-- Prepare arguments
---------------------
local if_auto_translit = false
local args = getArgs(frame, { -- configuration for Module:Arguments
trim = true,
removeBlanks = false,
parentFirst = true,
wrappers = {'Template:Interlinear', 'Template:Fs interlinear'},
})
local template_name = frame:getParent():getTitle()
if template_name == 'Template:Fs interlinear' then
args.italics1 = args.italics1 or "no"
args.italics2 = args.italics2 or "yes"
args.glossing3 = args.glossing3 or "yes"
if args.lang and not args.lang2 then args.lang2 = args.lang .."-Latn" end
if args.transl and not args.transl2 then args.transl2 = args.transl end
if_auto_translit = true

end
local revid = frame:preprocess( "{{REVISIONID}}" )
if revid == "" then
if not args['display-messages'] or yesno(args['display-messages']) then
displaying_messages = true end-- messages will be displayed only in preview mode
end
msg = UserMessages
local line = {}

local function set_italics(n)
line[n].attr.style = line[n].attr.style .. "font-style: italic;"
line[n].tone_sup = true -- single digits are assumed to be tone markers and will hence be superscripted
if args['tone-superscripting'] and not yesno(args['tone-superscripting'])
then line[n].tone_sup = false end
end

if args.glossing then -- the glossing= parameter sets the default glossing type
local _gl = set_glossing_type(args.glossing)
if _gl then conf.GlossingType = _gl end
end
--this looks for a list of glossing abbreviations on the page that transcludes the template:
local _ablist_section = get_section(frame, 'list-of-glossing-abbreviations')
if _ablist_section and _ablist_section ~= "" then
local _a = mw.ustring.gsub(_ablist_section, '</?div [^\n]*>', '') -- strips off the div tags
set_custom_glosses(_a)
end
--and this looks looks for a list of abbreviations set within the template:
local _ablist = args.abbreviations
if _ablist and _ablist ~= ""
then set_custom_glosses(_ablist) end
local _ablist = args.ablist
if _ablist and _ablist ~= ""
then set_custom_glosses(_ablist) end

local _spacing = tonumber(args.spacing)
if _spacing and _spacing <= 20
then conf.style.WordDiv = conf.style.WordDiv .. 'margin-right: ' .. _spacing .. 'em;'
else conf.style.WordDiv = conf.style.WordDiv .. conf.style.WordMargin
end

local offset, last_line = 0, 0
for j,v in ipairs(args) do -- iterates over the unnamed parameters from the template
last_line = last_line +1
if is_empty(v)
then offset = offset + 1
else
local i = j - offset
line[i] = {}
v = normalise(v)

-- the following is part of a trial implementation of automatic transliteration:
if if_auto_translit and v == "auto" and i > 1 then
local source_line = line[i-1]
local src_lang = source_line.lang
if not src_lang then src_lang = args.lang end
if src_lang then
v = transliterate(source_line.whole, src_lang)
else v = ""; msg:add("error", "No language specified for automatic transliteration")
end
end -- end of trial block

line[i].whole = v
line[i].length = mw.ustring.len(v)

local _c = args["c" .. i]
if _c and _c ~= "" then
line.hasComments = true
line[i].c = _c
end

---prepare style arguments----
line[i].class = ""
local _style = args["style" .. i]
if not _style then _style = ""
else _style = tidyCss(_style) end
--line[i].attr holds the attributes for the <p> elements that enclose the words in line i
line[i].attr = {style = conf.style.WordP .. _style}

local _lang = args["lang" .. i]
if _lang and #_lang > 1 then
line[i].lang = _lang
else _lang = args.lang
if _lang and #_lang > 1 and i == 1 then -- if a lang= parameter is supplied, it's assumed to apply to line 1
line[i].lang = _lang
end
end
line[i].attr.lang = line[i].lang
--the following emulates the behaviour of {{Bo-textonly}} (see Template talk:Fs interlinear#Tibetan):
if template_name == 'Template:Fs interlinear' then
if _lang == "bo" and i == 1 then
line[1].class = line[1].class .. " uchen"
line[1].attr.style = line[1].attr.style .. "font-size:1.25em; word-wrap:break-word;"
end
end
--the following emulates the behaviour of {{Spell-nv}}:
if template_name == 'Template:Interlinear' then
if _lang == "nv" and i == 1 then
line[1].attr.style = line[1].attr.style .. "font-family: Aboriginal Sans, DejaVu Sans, Calibri, Arial Unicode MS, sans-serif;"
end
end

if yesno(args["italics" .. i]) then
set_italics(i)
end

local _transl = args["transl" .. i]
if _transl and #_transl > 1 then
_transl = mw.ustring.lower(_transl)
local _lookup = lang_data.translit_title_table[_transl]
if _lookup then
if _lang and _lookup[_lang] then
_transl = _lookup[_lang]
else _transl = _lookup.default
end
if _transl then
line[i].attr.title = _transl
end
else msg:add("error", "Transliteration scheme '" .. _transl .. "' not recognised")
end
end

local _glossing = args["glossing" .. i]
if _glossing then
line[i].glossing = set_glossing_type(_glossing)
-- Do not treat default glossing settings as custom.
if not ((i == 1 and not yesno(_glossing)) or (i == 2 and yesno(_glossing))) then
line.HasCustomGlossing = true
end
end

local _ipa = args['ipa' .. i]
if yesno(_ipa) then
line[i].class = "IPA"
end

local _class = args['class' .. i]
if _class then
line[i].class = line[i].class .. " " .. _class
end

if line[i].class == ""
then line[i].class = nil end
end -- ends the first if-statement in the loop
end -- ends the FOR cycle

local line_count = #line
if line_count == 0 then
msg:add("error", template_name .. ": no lines supplied.")
return msg:print_errors()
end

if line_count > 1 then
local _italics = args.italics
local n = tonumber(_italics)
if n and n > 0 then
set_italics(n)
elseif not (_italics and not yesno(_italics)) and not (args["italics1"] and not yesno(args["italics1"])) then
set_italics(1) -- by default, the first line will get italicised, unless italics=no or italics1=no
end
-- the last unnamed parameter is assumed to be the free translation:
free_translation = args[last_line]
if not is_empty(free_translation) then
line [line_count] = nil end --... and is thus excluded from interlinearising
end

-- If glossing isn't specified for any line, then it's chosen by default to occur
-- in the second line, unless only a single line has been supplied, in which case
-- the assumption is that it is the one containing grammatical glosses
if yesno(args.glossing) == false then
line.HasCustomGlossing = true
end
if not line.HasCustomGlossing then
if line_count == 1 then
line[1].glossing = conf.GlossingType
elseif line[2] then
line[2].glossing = conf.GlossingType
end
end
set_global_glossing_settings{style = args['glossing-style'], underline = args.underline, small_caps = args['small-caps']}

---------------------
-- Segment lines into words
---------------------
for i,v in ipairs(line) do
local ifglossing = false
if line[i].glossing then
ifglossing = true -- if true the parser will attempt to format gloss abbreviations in the current line
glossing_type = line[i].glossing -- neccessarily a global variable
end
local wc, n = 1, 1
line[i].words = {}
while n <= line[i].length do
buffer = ""
n = parse(line[i], n, 0, ifglossing)+2
line[i].words[wc] = buffer
wc = wc + 1
end
end

----Check for mismatches in number of words across lines----
local number_of_words, mismatch_found = 0, false
for i,v in ipairs(line) do -- find the maximum number of words in any line
local wc = #line[i].words
if wc ~= number_of_words then
if i ~= 1 and wc ~= 0 then
mismatch_found = true
end
if wc > number_of_words then
number_of_words = wc
end
end
end
----Deal with mismatches---
if mismatch_found then
local error_text = "Mismatch in the number of words between lines: "
for i,v in ipairs(line) do
local wc = #line[i].words
error_text = error_text .. wc .. " word(s) in line " .. i .. ", "
if wc ~= number_of_words then
for current_word = wc+1, number_of_words do
line[i].words[current_word] = " "
end
end
end
if string.sub(error_text, -2) == ", "
then error_text = string.sub(error_text, 1, #error_text - 2) .. " "
end
error_text = error_text .. help_link("mismatch")
UserMessages:add("error", error_text)
end

---------------------
-- Build the HTML
---------------------
---- If just a single line was supplied, format it as inline text
if line_count == 1 then
local span = mw.html.create('span')
span:attr(line[1].attr)
for wi = 1, number_of_words do
local space
if wi < number_of_words then space = " " else space = "" end
span:wikitext(line[1].words[wi] .. space)
end
return tostring(span)
end

---- More than one line supplied, so we'll produce interlinear display
local div = mw.html.create("div")
div:addClass(conf.class.Interlinear)

-- For stuff to be displayed in the left margin, like example numbering
local number, indent = nil, nil
if args.number and args.number ~= ""
then number = args.number end
if args.indent and args.indent ~=""
then indent = args.indent end
if indent or number then
if not indent then indent = "4" end --default value
div:css("margin-left", indent .. 'em')
if number then
div:tag("div")
:css("position", "absolute")
:css("left", "1em")
:wikitext(args.number)
end
end

if args.box and args.box ~= "" then
div:css("background-color", "#f8f9fa")
:css("border", "1px solid #eaecf0")
:css("padding", "1em") end
if args.top and args.top ~= "" then --lines to display above the interlinear block
div:tag("div")
:wikitext(args.top)
end

-- Producing the interlinear block
for wi = 1, number_of_words do
local div2 = div:tag("div")
:attr("style", conf.style.WordDiv)
for i,_ in ipairs (line) do
if line[i].whole ~= "" then -- skipping empty lines
local p = div2:tag("p")
p:attr(line[i].attr)
if line[i].class then
p:addClass(line[i].class)
end
local _text = line[i].words[wi]
if _text == "" or _text == " "
then _text = " " end -- <p> elements without content mess up the interlinear display
p:wikitext(_text)
end
end
end

--- If any "comments" have been specified, add them at the end of each line
if line.hasComments then
local divc = div:tag("div")
:attr("style", conf.style.WordDiv)
for i,_ in ipairs (line) do
local p = divc:tag("p")
p:attr("style", conf.style.WordP)
if line[i].c then
p:wikitext(line[i].c)
else p:wikitext(" ")
end
end
end

--Add hidden lines containing the content of each line of interlinear text: this is for accessibility
for i,v in ipairs(line) do
local hidden_line = div:tag("p")
hidden_line:attr("style", conf.style.HiddenText)
:wikitext(v.whole)
end

-- Format the free translation
local ft_line = div:tag("p")
if free_translation and free_translation ~= "" then
ft_line:attr("style", "clear: left;")
ft_line:wikitext(free_translation)
end
if args.bottom and args.bottom ~= ""
then local bottom = div:tag('p')
bottom:css('margin-top', '0')
bottom:wikitext(args.bottom)
end
ft_line:node(msg:print_errors()) -- for error messages

local end_div = div:tag("div")
end_div:attr("style", conf.style.EndDiv)
div:newline()
local temp_track = ""
if last_line == 2
then temp_track = "[[Category:Pages with interlinear glosses using two unnamed parameters]]"
end
if last_line > 3 and template_name ~= 'Template:Fs interlinear'
then temp_track = "[[Category:Pages with interlinear glosses using more than three unnamed parameters]]"
end
return tostring(div) .. temp_track .. msg:print_warnings()
end

return p

Module:Lang/data

2024-04-05T21:19:45Z

Vaxjedi: Created page with "local lang_obj = mw.language.getContentLanguage(); local this_wiki_lang_tag = lang_obj.code; -- get this wiki's language tag --[[--------------------------< L A N G _ N A M E _ T A B L E >------------------------------------------------ primary table of tables that decode: lang -> language tags and names script -> ISO 15924 script tags region -> ISO 3166 region tags variant -> iana registered variant tags suppressed -> map of scripts tags and their assoc..."

local lang_obj = mw.language.getContentLanguage();
local this_wiki_lang_tag = lang_obj.code; -- get this wiki's language tag

--[[--------------------------< L A N G _ N A M E _ T A B L E >------------------------------------------------

primary table of tables that decode:
lang -> language tags and names
script -> ISO 15924 script tags
region -> ISO 3166 region tags
variant -> iana registered variant tags
suppressed -> map of scripts tags and their associated language tags

all of these data come from separate modules that are derived from the IANA language-subtag-registry file

key_to_lower() avoids the metatable trap and sets all keys in the subtables to lowercase. Many language codes
have multiple associated names; Module:lang is only concerned with the first name so key_to_lower() only fetches
the first name.

]]

local function key_to_lower (module, src_type)
local out = {};
local source = (('var_sup' == src_type) and require (module)) or mw.loadData (module); -- fetch data from this module; require() avoids metatable trap for variant data
if 'var_sup' == src_type then
for k, v in pairs (source) do
out[k:lower()] = v; -- for variant and suppressed everything is needed
end

elseif 'lang' == src_type and source.active then -- for ~/iana_languages (active)
for k, v in pairs (source.active) do
out[k:lower()] = v[1]; -- ignore multiple names; take first name only
end

elseif 'lang_dep' == src_type and source.deprecated then -- for ~/iana_languages (deprecated)
for k, v in pairs (source.deprecated) do
out[k:lower()] = v[1]; -- ignore multiple names; take first name only
end

else -- here for all other sources
for k, v in pairs (source) do
out[k:lower()] = v[1]; -- ignore multiple names; take first name only
end
end
return out;
end

local lang_name_table_t = {
lang = key_to_lower ('Module:Language/data/iana languages', 'lang'),
lang_dep = key_to_lower ('Module:Language/data/iana languages', 'lang_dep'),
script = key_to_lower ('Module:Language/data/iana scripts'), -- script keys are capitalized; set to lower
region = key_to_lower ('Module:Language/data/iana regions'), -- region keys are uppercase; set to lower
variant = key_to_lower ('Module:Language/data/iana variants', 'var_sup'),
suppressed = key_to_lower ('Module:Language/data/iana suppressed scripts', 'var_sup'), -- script keys are capitalized; set to lower
}

--[[--------------------------< I 1 8 N M E D I A W I K I O V E R R I D E >--------------------------------

For internationalization; not used at en.wiki

The language names taken from the IANA language-subtag-registry file are given in English. That may not be ideal.
Translating ~8,000 language names is also not ideal. MediaWiki maintains (much) shorter lists of language names
in most languages for which there is a Wikipedia edition. When desired, Module:Lang can use the MediaWiki
language list for the local language.

Caveat lector: the list of MediaWiki language names for your language may not be complete or may not exist at all.
When incomplete, MediaWiki's list will 'fall back' to another language (typically English). When that happens
add an appropriate entry to the override table below.

Caveat lector: the list of MediaWiki language names for your language may not be correct. At en.wiki, the
MediaWiki language names do not agree with the IANA language names for these ISO 639-1 tags. Often it is simply
spelling differences:
bh: IANA: Bihari languages MW: Bhojpuri – the ISO 639-3 tag for Bhojpuri is bho
bn: IANA: Bengali MW: Bangla – Bengali is the exonym, Bangla is the endonym
dv: IANA: Dhivehi MW: Divehi
el: IANA: Modern Greek MW: Greek
ht: IANA: Haitian MW: Haitian Creole
ky: IANA: Kirghiz MW: Kyrgyz
li: IANA: Limburgan MW: Limburgish
or: IANA: Oriya MW: Odia
os: IANA: Ossetian MW: Ossetic
"pa: IANA: Panjabi MW: Punjabi
"ps: IANA: Pushto MW: Pashto
"to: IANA: Tonga MW: Tongan
"ug: IANA: Uighur MW: Uyghur
use the override table to override language names that are incorrect for your project

To see the list of names that MediaWiki has for your language, enter this in the Debug colsole:
=mw.dumpObject (mw.language.fetchLanguageNames ('<tag>', 'all'))
(replacing <tag> with the language tag for your language)

Use of the MediaWiki language names lists is enabled when media_wiki_override_enable is set to boolean true.

]]

local media_wiki_override_enable = false; -- set to true to override IANA names with MediaWiki names; always false at en.wiki
-- caveat lector: the list of MediaWiki language names for your language may not be complete or may not exist at all
if true == media_wiki_override_enable then
local mw_languages_by_tag_t = mw.language.fetchLanguageNames (this_wiki_lang_tag, 'all'); -- get a table of language tag/name pairs known to MediaWiki
for tag, name in pairs (mw_languages_by_tag_t) do -- loop through each tag/name pair in the MediaWiki list
if lang_name_table_t.lang[tag] then -- if the tag is in the main list
lang_name_table_t.lang[tag] = name; -- overwrite exisiting name with the name from MediaWiki
end
end
end

--[[--------------------------< O V E R R I D E >--------------------------------------------------------------

Language codes and names in this table override the BCP47 names in lang_name_table.

indexes in this table shall always be lower case

]]

local override = {
------------------------------< I S O _ 6 3 9 - 1 >------------------------------------------------------------

["ab"] = "Abkhaz", -- to match en.wiki article name
["ca-valencia"] = "Valencian",
["cu"] = "Church Slavonic", -- 2nd IANA name;
["de-at"] = "Austrian German", -- these code-region and code-variant tags to match en.wiki article names
["de-ch"] = "Swiss Standard German",
["en-au"] = "Australian English",
["en-ca"] = "Canadian English",
["en-emodeng"] = "Early Modern English",
["en-gb"] = "British English",
["en-ie"] = "Irish English",
["en-in"] = "Indian English",
["en-nz"] = "New Zealand English",
["en-us"] = "American English",
["en-za"] = "South African English",
["fy"] = "West Frisian", -- Western Frisian
["mo"] = "Moldovan", -- Moldavian (deprecated code); to match en.wiki article title
["nl-be"] = "Flemish", -- match MediaWiki
["oc-provenc"] = "Provençal",
["ps"] = "Pashto", -- Pushto
["pt-br"] = "Brazilian Portuguese", -- match MediaWiki
["tw-asante"] = "Asante Twi",
["ug"] = "Uyghur", -- 2nd IANA name; to match en.wiki article name

-- these ISO 639-1 language-name overrides imported from Module:Language/data/wp_languages (since deleted)
--<begin do-not-edit except to comment out>--
["av"] = "Avar", -- Avaric
["bo"] = "Standard Tibetan", -- Tibetan
["el"] = "Greek", -- Modern Greek
-- ["en-SA"] = "South African English", -- English; no; SA is not South Africa it Saudi Arabia; ZA is South Africa
["ff"] = "Fula", -- Fulah
["ht"] = "Haitian Creole", -- Haitian
["hz"] = "Otjiherero", -- Herero
["ii"] = "Yi", -- Sichuan Yi
["ki"] = "Gikuyu", -- Kikuyu
["kl"] = "Greenlandic", -- Kalaallisut
["ky"] = "Kyrgyz", -- Kirghiz
["lg"] = "Luganda", -- Ganda
["li"] = "Limburgish", -- Limburgan
["mi"] = "Māori", -- Maori
["na"] = "Nauruan", -- Nauru
["nb"] = "Bokmål", -- Norwegian Bokmål
["nd"] = "Northern Ndebele", -- North Ndebele
["nn"] = "Nynorsk", -- Norwegian Nynorsk
["nr"] = "Southern Ndebele", -- South Ndebele
["ny"] = "Chichewa", -- Nyanja
["oj"] = "Ojibwe", -- Ojibwa
["or"] = "Odia", -- Oriya
["pa"] = "Punjabi", -- Panjabi
["rn"] = "Kirundi", -- Rundi
["sl"] = "Slovene", -- Slovenian
["ss"] = "Swazi", -- Swati
["st"] = "Sotho", -- Southern Sotho
["to"] = "Tongan", -- Tonga
--<end do-not-edit except to comment out>--

------------------------------< I S O _ 6 3 9 - 2, - 3, - 5 >----------------------------------------------

["alv"] = "Atlantic–Congo languages", -- to match en.wiki article title (endash)
["arc"] = "Imperial Aramaic (700-300 BCE)", -- Official Aramaic (700-300 BCE), Imperial Aramaic (700-300 BCE); to match en.wiki article title uses ISO639-2 'preferred' name
["art"] = "constructed", -- to match en.wiki article; lowercase for category name
["bhd"] = "Bhadarwahi", -- Bhadrawahi; to match en.wiki article title
["bla"] = "Blackfoot", -- Siksika; to match en.wiki article title
["bua"] = "Buryat", -- Buriat; this is a macro language; these four use wp preferred transliteration;
["bxm"] = "Mongolian Buryat", -- Mongolia Buriat; these three all redirect to Buryat
["bxr"] = "Russian Buryat", -- Russia Buriat;
["bxu"] = "Chinese Buryat", -- China Buriat;
["byr"] = "Yipma", -- Baruya, Yipma
["egy"] = "Ancient Egyptian", -- Egyptian (Ancient); distinguish from contemporary arz: Egyptian Arabic
["ems"] = "Alutiiq", -- Pacific Gulf Yupik; to match en.wiki article title
["esx"] = "Eskimo–Aleut languages", -- to match en.wiki article title (endash)
["frr"] = "North Frisian", -- Northern Frisian
["frs"] = "East Frisian Low Saxon", -- Eastern Frisian
["gsw-fr"] = "Alsatian", -- match MediaWiki
["haa"] = "Hän", -- Han; to match en.wiki article title
["hmx"] = "Hmong–Mien languages", -- to match en.wiki article title (endash)
["ilo"] = "Ilocano", -- Iloko; to match en.wiki article title
["jam"] = "Jamaican Patois", -- Jamaican Creole English
["lij-mc"] = "Monégasque", -- Ligurian as spoken in Monaco
["luo"] = "Dholuo", -- IANA (primary) /ISO 639-3: Luo (Kenya and Tanzania); IANA (secondary): Dholuo
["mhr"] = "Meadow Mari", -- Eastern Mari
["mid"] = "Modern Mandaic", -- Mandaic
['mis'] = "uncoded", -- Uncoded languages; capitalization; special scope, not collective scope;
["mkh"] = "Mon–Khmer languages", -- to match en.wiki article title (endash)
["mla"] = "Tamambo", -- Malo
['mte'] = "Mono-Alu", -- Mono (Solomon Islands)
['mul'] = "multiple", -- Multiple languages; capitalization; special scope, not collective scope;
["nan-tw"] = "Taiwanese Hokkien", -- make room for IANA / 639-3 nan Min Nan Chinese; match en.wiki article title
["new"] = "Newar", -- Newari, Nepal Bhasa; to match en,wiki article title
["ngf"] = "Trans–New Guinea languages", -- to match en.wiki article title (endash)
["nic"] = "Niger–Congo languages", -- Niger-Kordofanian languages; to match en,wiki article title
["nrf"] = "Norman", -- not quite a collective - IANA name: Jèrriais + Guernésiais; categorizes to Norman-language text
["nrf-gg"] = "Guernésiais", -- match MediaWiki
["nrf-je"] = "Jèrriais", -- match MediaWiki
["nzi"] = "Nzema", -- Nzima; to match en.wiki article title
["oma"] = "Omaha–Ponca", -- to match en.wiki article title (endash)
["orv"] = "Old East Slavic", -- Old Russian
["pfl"] = "Palatine German", -- Pfaelzisch; to match en.wiki article
["pie"] = "Piro Pueblo", -- Piro; to match en.wiki article
["pms"] = "Piedmontese", -- Piemontese; to match en.wiki article title
["pnb"] = "Punjabi (Western)", -- Western Panjabi; dab added to override import from ~/wp languages and distinguish pnb from pa in reverse look up tag_from_name()
["rop"] = "Australian Kriol", -- Kriol; en.wiki article is a dab; point to correct en.wiki article
["sdo"] = "Bukar–Sadong", -- Bukar-Sadung Bidayuh; to match en.wiki article title
["smp"] = "Samaritan Hebrew", -- to match en.wiki article title
["stq"] = "Saterland Frisian", -- Saterfriesisch
["und"] = "undetermined", -- capitalization to match existing category
["wrg"] = "Warrongo", -- Warungu
["xal-ru"] = "Kalmyk", -- to match en.wiki article title
["xgf"] = "Tongva", -- ISO 639-3 is Gabrielino-Fernandeño
["yuf"] = "Havasupai–Hualapai", -- Havasupai-Walapai-Yavapai; to match en.wiki article title
["zxx"] = "no linguistic content", -- capitalization

-- these ISO 639-2, -3 language-name overrides imported from Module:Language/data/wp_languages (since deleted)
--<begin do-not-edit except to comment out>--
["ace"] = "Acehnese", -- Achinese
["aec"] = "Sa'idi Arabic", -- Saidi Arabic
["akl"] = "Aklan", -- Aklanon
["alt"] = "Altay", -- Southern Altai
["apm"] = "Mescalero-Chiricahua", -- Mescalero-Chiricahua Apache
["bal"] = "Balochi", -- Baluchi
-- ["bcl"] = "Central Bicolano", -- Central Bikol
["bin"] = "Edo", -- Bini
["bpy"] = "Bishnupriya Manipuri", -- Bishnupriya
["chg"] = "Chagatay", -- Chagatai
["ckb"] = "Sorani Kurdish", -- Central Kurdish
["cnu"] = "Shenwa", -- Chenoua
["coc"] = "Cocopah", -- Cocopa
["diq"] = "Zazaki", -- Dimli
["fit"] = "Meänkieli", -- Tornedalen Finnish
["fkv"] = "Kven", -- Kven Finnish
["frk"] = "Old Frankish", -- Frankish
["gez"] = "Ge'ez", -- Geez
["gju"] = "Gujari", -- Gujari
["gsw"] = "Alemannic German", -- Swiss German
["gul"] = "Gullah", -- Sea Island Creole English
["hak"] = "Hakka", -- Hakka Chinese
["hbo"] = "Biblical Hebrew", -- Ancient Hebrew
["hnd"] = "Hindko", -- Southern Hindko
-- ["ikt"] = "Inuvialuk", -- Inuinnaqtun
["kaa"] = "Karakalpak", -- Kara-Kalpak
["khb"] = "Tai Lü", -- Lü
["kmr"] = "Kurmanji Kurdish", -- Northern Kurdish
["kpo"] = "Kposo", -- Ikposo
["krj"] = "Kinaray-a", -- Kinaray-A
-- ["ktz"] = "Juǀ'hoan", -- Juǀʼhoan
["lez"] = "Lezgian", -- Lezghian
["liv"] = "Livonian", -- Liv
["lng"] = "Lombardic", -- Langobardic
["mia"] = "Miami-Illinois", -- Miami
["miq"] = "Miskito", -- Mískito
["mix"] = "Mixtec", -- Mixtepec Mixtec
["mni"] = "Meitei", -- Manipuri
["mrj"] = "Hill Mari", -- Western Mari
["mww"] = "White Hmong", -- Hmong Daw
["nds-nl"] = "Dutch Low Saxon", -- Low German
-- ["new"] = "Nepal Bhasa", -- Newari
["nso"] = "Northern Sotho", -- Pedi
-- ["nwc"] = "Classical Nepal Bhasa", -- Classical Newari, Classical Nepal Bhasa, Old Newari
["ood"] = "O'odham", -- Tohono O'odham
["otk"] = "Old Turkic", -- Old Turkish
["pal"] = "Middle Persian", -- Pahlavi
["pam"] = "Kapampangan", -- Pampanga
["phr"] = "Potwari", -- Pahari-Potwari
["pka"] = "Jain Prakrit", -- Ardhamāgadhī Prākrit
-- ["pnb"] = "Punjabi", -- Western Panjabi
["psu"] = "Shauraseni", -- Sauraseni Prākrit
["rap"] = "Rapa Nui", -- Rapanui
["rar"] = "Cook Islands Māori", -- Rarotongan
["rmu"] = "Scandoromani", -- Tavringer Romani
["rom"] = "Romani", -- Romany
["rup"] = "Aromanian", -- Macedo-Romanian
["ryu"] = "Okinawan", -- Central Okinawan
["sdc"] = "Sassarese", -- Sassarese Sardinian
["sdn"] = "Gallurese", -- Gallurese Sardinian
["shp"] = "Shipibo", -- Shipibo-Conibo
["src"] = "Logudorese", -- Logudorese Sardinian
["sro"] = "Campidanese", -- Campidanese Sardinian
["tkl"] = "Tokelauan", -- Tokelau
["tvl"] = "Tuvaluan", -- Tuvalu
["tyv"] = "Tuvan", -- Tuvinian
["vls"] = "West Flemish", -- Vlaams
["wep"] = "Westphalian", -- Westphalien
["xal"] = "Oirat", -- Kalmyk
["xcl"] = "Old Armenian", -- Classical Armenian
["yua"] = "Yucatec Maya", -- Yucateco
--<end do-not-edit except to comment out>--

------------------------------< P R I V A T E _ U S E _ T A G S >----------------------------------------------

["akk-x-latbabyl"] = "Late Babylonian",
["akk-x-midassyr"] = "Middle Assyrian Akkadian",
["akk-x-midbabyl"] = "Middle Babylonian Akkadian",
["akk-x-neoassyr"] = "Neo-Assyrian Akkadian",
["akk-x-neobabyl"] = "Neo-Babylonian Akkadian",
["akk-x-old"] = "Old Akkadian",
["akk-x-oldassyr"] = "Old Assyrian Akkadian",
["akk-x-oldbabyl"] = "Old Babylonian Akkadian",
["alg-x-proto"] = "Proto-Algonquian", -- alg in IANA is Algonquian languages
["ca-x-old"] = "Old Catalan",
["cel-x-combrit"] = "Common Brittonic", -- cel in IANA is Celtic languages
["cel-x-proto"] = "Proto-Celtic",
["egy-x-demotic"] = "Demotic Egyptian",
["egy-x-late"] = "Late Egyptian",
["egy-x-middle"] = "Middle Egyptian",
["egy-x-old"] = "Old Egyptian",
["gem-x-proto"] = "Proto-Germanic", -- gem in IANA is Germanic languages
["gmw-x-ecg"] = "East Central German",
["grc-x-aeolic"] = "Aeolic Greek", -- these grc-x-... codes are preferred alternates to the non-standard catchall code grc-gre
["grc-x-attic"] = "Attic Greek",
["grc-x-biblical"] = "Biblical Greek",
["grc-x-byzant"] = "Byzantine Greek",
["grc-x-classic"] = "Classical Greek",
["grc-x-doric"] = "Doric Greek",
["grc-x-hellen"] = "Hellenistic Greek",
["grc-x-ionic"] = "Ionic Greek",
["grc-x-koine"] = "Koinē Greek",
["grc-x-medieval"] = "Medieval Greek",
["grc-x-patris"] = "Patristic Greek",
["grk-x-proto"] = "Proto-Greek", -- grk in IANA is Greek languages
["iir-x-proto"] = "Proto-Indo-Iranian", -- iir in IANA is Indo-Iranian Languages
["inc-x-mitanni"] = "Mitanni-Aryan", -- inc in IANA is Indic languages
["inc-x-proto"] = "Proto-Indo-Aryan",
["ine-x-proto"] = "Proto-Indo-European",
["ira-x-proto"] = "Proto-Iranian", -- ira in IANA is Iranian languages
["itc-x-proto"] = "Proto-Italic", -- itc in IANA is Italic languages
["ksh-x-colog"] = "Colognian", -- en.wiki article is Colognian; ksh (Kölsch) redirects there
["la-x-medieval"] = "Medieval Latin",
["la-x-new"] = "New Latin",
["lmo-x-milanese"] = "Milanese", -- lmo in IANA is Lombard; Milanese is a dialect
["mis-x-ripuar"] = "Ripuarian", -- replaces improper use of ksh in wp_languages
["prg-x-old"] = "Old Prussian",
["sem-x-ammonite"] = "Ammonite",
["sem-x-aramaic"] = "Aramaic",
["sem-x-canaan"] = "Canaanite languages",
["sem-x-dumaitic"] = "Dumaitic",
["sem-x-egurage"] = "Eastern Gurage",
["sem-x-hatran"] = "Hatran Aramaic",
["sem-x-oldsoara"] = "Old South Arabian",
["sem-x-palmyren"] = "Palmyrene Aramaic",
["sem-x-proto"] = "Proto-Semitic",
["sem-x-taymanit"] = "Taymanitic",
["sla-x-proto"] = "Proto-Slavic", -- sla in IANA is Slavic languages
["yuf-x-hav"] = "Havasupai", -- IANA name for these three is Havasupai-Walapai-Yavapai
["yuf-x-wal"] = "Walapai",
["yuf-x-yav"] = "Yavapai",
["xsc-x-pontic"] = "Pontic Scythian", -- xsc in IANA is Scythian
["xsc-x-saka"] = "Saka",
["xsc-x-sarmat"] = "Sarmatian",
}

--[[--------------------------< A R T I C L E _ L I N K >------------------------------------------------------

for those rare occasions when article titles don't fit with the normal '<language name>-language', this table
maps language code to article title. Use of this table should be avoided and the use of redirects preferred as
that is the long-standing method of handling article names that don't fit with the normal pattern

]]

local article_name = {
['kue'] = "Kuman language (New Guinea)", -- Kuman (Papua New Guinea); to avoid Kuman dab page
["lij"] = "Ligurian (Romance language)", -- Ligurian; see Template_talk:Lang#Ligurian_dab
['mbo'] = "Mbo language (Cameroon)", -- Mbo (Cameroon)
['mnh'] = "Mono language (Congo)", -- Mono (Democratic Republic of Congo); see Template_talk:Lang#Mono_languages
['mnr'] = "Mono language (California)", -- Mono (USA)
['mru'] = "Mono language (Cameroon)", -- Mono (Cameroon)
['qwm'] = "Kuman (Russia)", -- Kuman (Russia); to avoid Kuman dab page
["snq"] = "Sangu language (Gabon)", -- Sangu (Gabon)
["toi"] = "Tonga language (Zambia and Zimbabwe)", -- Tonga (Zambia and Zimbabwe); to avoid Tonga language dab page
["vwa"] = "Awa language (China)", -- Awa (China); to avoid Awa dab page
["xlg"] = "Ligurian (ancient language)", -- see Template_talk:Lang#Ligurian_dab
["zmw"] = "Mbo language (Congo)", -- Mbo (Democratic Republic of Congo)
}

--[=[-------------------------< R T L _ S C R I P T S >--------------------------------------------------------

ISO 15924 scripts that are written right-to-left. Data in this table taken from [[ISO 15924#List of codes]]

last update to this list: 2017-12-24

]=]

local rtl_scripts = {
'adlm', 'arab', 'aran', 'armi', 'avst', 'cprt', 'egyd', 'egyh', 'hatr', 'hebr',
'hung', 'inds', 'khar', 'lydi', 'mand', 'mani', 'mend', 'merc', 'mero', 'narb',
'nbat', 'nkoo', 'orkh', 'palm', 'phli', 'phlp', 'phlv', 'phnx', 'prti', 'rohg',
'samr', 'sarb', 'sogd', 'sogo', 'syrc', 'syre', 'syrj', 'syrn', 'thaa', 'wole',
};

--[[--------------------------< T R A N S L I T _ T I T L E S >------------------------------------------------

This is a table of tables of transliteration standards and the language codes or language scripts that apply to
those standards. This table is used to create the tool-tip text associated with the transliterated text displayed
by some of the {{lang-??}} templates.

These tables are more-or-less copied directly from {{transl}}. The standard 'NO_STD' is a construct to allow for
the cases when no |std= parameter value is provided.

]]

local translit_title_table = {
['ahl'] = {
['default'] = 'Academy of the Hebrew Language transliteration',
},

['ala'] = {
['default'] = 'American Library Association – Library of Congress transliteration',
},

['ala-lc'] = {
['default'] = 'American Library Association – Library of Congress transliteration',
},

['batr'] = {
['default'] = 'Bikdash Arabic Transliteration Rules',
},

['bgn/pcgn'] = {
['default'] = 'Board on Geographic Names / Permanent Committee on Geographical Names transliteration',
},

['din'] = {
['ar'] = 'DIN 31635 Arabic',
['fa'] = 'DIN 31635 Arabic',
['ku'] = 'DIN 31635 Arabic',
['ps'] = 'DIN 31635 Arabic',
['tg'] = 'DIN 31635 Arabic',
['ug'] = 'DIN 31635 Arabic',
['ur'] = 'DIN 31635 Arabic',
['arab'] = 'DIN 31635 Arabic',

['default'] = 'DIN transliteration',
},

['eae'] = {
['default'] = 'Encyclopaedia Aethiopica transliteration',
},

['hepburn'] = {
['default'] = 'Hepburn transliteration',
},

['hunterian'] = {
['default'] = 'Hunterian transliteration',
},

['iast'] = {
['default'] = 'International Alphabet of Sanskrit transliteration',
},

['iso'] = { -- when a transliteration standard is supplied
['ab'] = 'ISO 9 Cyrillic',
['ba'] = 'ISO 9 Cyrillic',
['be'] = 'ISO 9 Cyrillic',
['bg'] = 'ISO 9 Cyrillic',
['kk'] = 'ISO 9 Cyrillic',
['ky'] = 'ISO 9 Cyrillic',
['mn'] = 'ISO 9 Cyrillic',
['ru'] = 'ISO 9 Cyrillic',
['tg'] = 'ISO 9 Cyrillic',
['uk'] = 'ISO 9 Cyrillic',
['bua'] = 'ISO 9 Cyrillic',
['sah'] = 'ISO 9 Cyrillic',
['tut'] = 'ISO 9 Cyrillic',
['xal'] = 'ISO 9 Cyrillic',
['cyrl'] = 'ISO 9 Cyrillic',

['ar'] = 'ISO 233 Arabic',
['ku'] = 'ISO 233 Arabic',
['ps'] = 'ISO 233 Arabic',
['ug'] = 'ISO 233 Arabic',
['ur'] = 'ISO 233 Arabic',
['arab'] = 'ISO 233 Arabic',

['he'] = 'ISO 259 Hebrew',
['yi'] = 'ISO 259 Hebrew',
['hebr'] = 'ISO 259 Hebrew',

['el'] = 'ISO 843 Greek',
['grc'] = 'ISO 843 Greek',

['ja'] = 'ISO 3602 Japanese',
['hira'] = 'ISO 3602 Japanese',
['hrkt'] = 'ISO 3602 Japanese',
['jpan'] = 'ISO 3602 Japanese',
['kana'] = 'ISO 3602 Japanese',

['zh'] = 'ISO 7098 Chinese',
['chi'] = 'ISO 7098 Chinese',
['cmn'] = 'ISO 7098 Chinese',
['zho'] = 'ISO 7098 Chinese',
-- ['han'] = 'ISO 7098 Chinese', -- unicode alias of Hani? doesn't belong here? should be Hani?
['hans'] = 'ISO 7098 Chinese',
['hant'] = 'ISO 7098 Chinese',

['ka'] = 'ISO 9984 Georgian',
['kat'] = 'ISO 9984 Georgian',

['arm'] = 'ISO 9985 Armenian',
['hy'] = 'ISO 9985 Armenian',

['th'] = 'ISO 11940 Thai',
['tha'] = 'ISO 11940 Thai',

['ko'] = 'ISO 11941 Korean',
['kor'] = 'ISO 11941 Korean',

['awa'] = 'ISO 15919 Indic',
['bho'] = 'ISO 15919 Indic',
['bn'] = 'ISO 15919 Indic',
['bra'] = 'ISO 15919 Indic',
['doi'] = 'ISO 15919 Indic',
['dra'] = 'ISO 15919 Indic',
['gon'] = 'ISO 15919 Indic',
['gu'] = 'ISO 15919 Indic',
['hi'] = 'ISO 15919 Indic',
['hno'] = 'ISO 15919 Indic',
['inc'] = 'ISO 15919 Indic',
['kn'] = 'ISO 15919 Indic',
['kok'] = 'ISO 15919 Indic',
['ks'] = 'ISO 15919 Indic',
['mag'] = 'ISO 15919 Indic',
['mai'] = 'ISO 15919 Indic',
['ml'] = 'ISO 15919 Indic',
['mr'] = 'ISO 15919 Indic',
['ne'] = 'ISO 15919 Indic',
['new'] = 'ISO 15919 Indic',
['or'] = 'ISO 15919 Indic',
['pa'] = 'ISO 15919 Indic',
['pnb'] = 'ISO 15919 Indic',
['raj'] = 'ISO 15919 Indic',
['sa'] = 'ISO 15919 Indic',
['sat'] = 'ISO 15919 Indic',
['sd'] = 'ISO 15919 Indic',
['si'] = 'ISO 15919 Indic',
['skr'] = 'ISO 15919 Indic',
['ta'] = 'ISO 15919 Indic',
['tcy'] = 'ISO 15919 Indic',
['te'] = 'ISO 15919 Indic',
['beng'] = 'ISO 15919 Indic',
['brah'] = 'ISO 15919 Indic',
['deva'] = 'ISO 15919 Indic',
['gujr'] = 'ISO 15919 Indic',
['guru'] = 'ISO 15919 Indic',
['knda'] = 'ISO 15919 Indic',
['mlym'] = 'ISO 15919 Indic',
['orya'] = 'ISO 15919 Indic',
['sinh'] = 'ISO 15919 Indic',
['taml'] = 'ISO 15919 Indic',
['telu'] = 'ISO 15919 Indic',

['default'] = 'ISO transliteration',
},

['jyutping'] = {
['default'] = 'Jyutping transliteration',
},

['mlcts'] = {
['default'] = 'Myanmar Language Commission Transcription System',
},

['mr'] = {
['default'] = 'McCune–Reischauer transliteration',
},

['nihon-shiki'] = {
['default'] = 'Nihon-shiki transliteration',
},

['no_std'] = { -- when no transliteration standard is supplied
['akk'] = 'Semitic transliteration',
['sem'] = 'Semitic transliteration',
['phnx'] = 'Semitic transliteration',
['xsux'] = 'Cuneiform transliteration',
},

['pinyin'] = {
['default'] = 'Pinyin transliteration',
},

['rr'] = {
['default'] = 'Revised Romanization of Korean transliteration',
},

['rtgs'] = {
['default'] = 'Royal Thai General System of Transcription',
},

['satts'] = {
['default'] = 'Standard Arabic Technical Transliteration System transliteration',
},

['scientific'] = {
['default'] = 'scientific transliteration',
},

['ukrainian'] = {
['default'] = 'Ukrainian National system of romanization',
},

['ungegn'] = {
['default'] = 'United Nations Group of Experts on Geographical Names transliteration',
},

['wadegile'] = {
['default'] = 'Wade–Giles transliteration',
},

['wehr'] = {
['default'] = 'Hans Wehr transliteration',
},
};

return
{
this_wiki_lang_tag = this_wiki_lang_tag,
this_wiki_lang_dir = lang_obj:getDir(), -- wiki's language direction

article_name = article_name,
lang_name_table = lang_name_table_t,
override = override,
rtl_scripts = rtl_scripts,
special_tags_table = special_tags_table,
translit_title_table = translit_title_table,
};

Template:Interlinear

2024-04-05T21:17:31Z

Vaxjedi:

<includeonly><templatestyles src="Interlinear/styles.css" />{{#invoke:Interlinear|interlinearise}}</includeonly><noinclude>


== Basic usage ==
This template formats a linguistic [[Interlinear gloss|interlinear glossed text]]:
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear
|Nginda-rni ngaja-mi jurliji-rdarra diyim ka-rdu
|DEM(M)-FOC see-IRR bird-PL fly 3SG-go
|'Look at all the birds flying!'}}</nowiki>}}</div>

{{red|Important}}: On lines to be interlinearised, any [[Help:Wiki markup|wiki markup]] or [[Help:Template|templates]] should never span word boundaries. Мarkup or templates that apply to a sequence of words must be repeated for each word: (It is also possible to apply formatting to an entire line, see [[#Line formatting|below]])
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear
|Te ni-ke'''koo''' '''te̱e''' '''ún'''
|And past-arrived.PL man he
|"The men arrived"}}</nowiki>}}</div>

The characters {{code|<}}, {{code|>}} and {{code|{{=}}}} should not be used directly. They can be substituted as follows:
{|class="wikitable"
|-
! Character
! Substitute
|-
| <
| &lt;
|-
| >
| &gt;
|-
| =
| <nowiki>{{=}}</nowiki>
|}

To let a multi-word expression be treated as a single word, surround it in {curly brackets}. Similarly, use {{code|{} }} for an empty word:<ref>An alternative in each case is to use a [[Template:nbsp|non-breaking space]]: the example sentence would then be: ''This is a little&nbsp;example in &nbsp; Dutch.''</ref>
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear
|Dit is een voorbeeldje in het Nederlands
|This is a {little example} in {} Dutch.|}}</nowiki>}}</div>

The template can be invoked with any number of unnamed parameters, which are interpreted as lines of text. If there is only one unnamed parameter, then it will be rendered in-line and treated as a gloss line: <code><nowiki>{{interlinear|house-ATTR master-ABS}}</nowiki></code> gives: {{interlinear|house-ATTR master-ABS}}. If there are more than one, then all will be interlinearised except the last one, which is assumed to be the free translation. To force the interlinearisation of ''all'' lines, supply an empty last unnamed parameter:
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear
|Ù-dììny Juáàny bèʔcw.
|COMPL-hit Juan dog|}}</nowiki>}}</div>

== Layout ==
A line of text to be displayed '''above''' the interlinear block is given using {{para|top}}, one to be displayed immediately '''below''' the free translation is set using {{para|bottom}}. If any of these need to contain more than a singe line, then line breaks can be introduced using {{tl|br}}.
'''Example numbering''' can be set using {{para|number}}. The parameter consists of one or more characters to be displayed in the left margin.
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear|number=(15a)|top=Potential mood: {{br}} ''Kʼetʼuq ɣˤay ħaƛułxo.''
|kʼetʼu-q ɣˤay ħaƛu-'''ł'''-xo
|cat-POSS:ESS milk:ABS drink-'''POT'''-PRS
|"The cat can drink milk."}}</nowiki>}}</div>

The '''indentation''' of the interlinear block (measured in [[Em (CSS)|ems]]) can be modified using {{para|indent}}.
Currently, the default value is 3 if {{para|number}} is set, and 0 otherwise. This behaviour is set to change: the next version of the template will apply indentation by default.

The '''spacing''' between consecutive word stacks can be adjusted using {{para|spacing}}; it is measured in [[Em (CSS)|ems]] and its default value is ''1''.
To '''visually set off''' the interlinear display from surrounding text, the {{para|box|yes}} parameter can be used. It surrounds the whole interlinear text in a box with a wikitable-like background colour.
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear|lang=jig|spacing = 3| box = yes
|Nyama-baji imimikin-bili-rni-rni ardalakbi-wurru-ju
|DEM-PL old.woman-ANIM.DU-F-ERG hot-3PL-do
|'The two old women feel hot.'}}</nowiki>}}</div>

To add a comment after a given line, use {{para|c''N''}} (where ''N'' is the sequence of the line: the content of {{para|c1}} will be appended at the end of first line, {{para|c2}} – at the end of the second line etc.):
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear
|Shte da e vidiyal
|FUT COMPL AUX see.PTC.M.SG
|'He must have seen it.'
|c1 = (rare in spoken usage)}}

</nowiki>}}</div>

== <span id="Line formatting">Line formatting</span> ==
Formatting can be set for an entire line using the {{para|style''N''}} parameter, which applies CSS style properties<ref name="CSSnote"/> to line ''N'' ({{para|style1}} for the first line, {{para|style2}} for the second one, etc):
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear|style1 = font-size:120%|style2 = color:DarkMagenta;
|Įxę̀ę eya ı̨-lè
|yesterday sick/painful PFV.3.SBJ-COP.PFV
|'Yesterday he was sick.'}}</nowiki>}}</div>

Similarly, CSS '''classes'''<ref>See [[WP:CLASS]] for a list of available classes. See also [[Help:User style]] for setting up customised display of classes.</ref> can be specified for line ''N'' using {{para|class''N''}}. Classes should be given ''without'' any quotation marks.

'''Italics''' are by default applied to the first line, unless disabled by {{para|italics1|no}}. Any line can be italicised using {{para|italics''N''|yes}} (where ''N'' is the number of the line). On italicised lines, '''tone numbers'''<ref>Any single digit following an alphabetical character is treated as a tone number.</ref> will be formatted as superscripts, unless {{para|tone-superscripting}} is set to {{code|no}}. To turn off italics for a particular word within an italicised line, use {{tl|noitalic}}.

To specify the '''language''' of a given line, you can use {{para|lang''N''}} (with ''N'' being ''1'' for the first line, ''2'' for the second one etc.).<ref>At this stage, the resulting behaviour does not necessarily match that of the {{tl|lang}} template/s.</ref> The parameter should be the ISO code of the language, as in the familiar [[Template:Lang]]. If the unnumbered {{para|lang}} is given, then it is applied to the first line. If line ''N'' employs '''IPA''', then the effect of [[Template:IPA]] can be mimicked by setting {{para|ipa''N''|yes}}.<ref>This only applies the IPA CSS class.</ref> If transliteration has been used, then the transliteration scheme can be specified with the {{para|transl''N''}} parameter (similarly to [[Template:Transl]]).

== Glossing abbreviations ==
Linguistic glosses typically abbreviate grammatical category labels, like this: {{gcl|ACC}}, instead of the full name 'accusative'. The line containing such glosses is specified using {{para|glossing''N''|yes}} (where ''N'' is the number of the line within the interlinear text). If no line is specified, then it is assumed such glosses are found in the second line (this can be bypassed with {{para|glossing2|no}}). Within the lines so specified, any sequence of upper case letters will be interpreted as a grammar gloss and formatted in {{small caps|small caps}}.

Additionally, the template will attempt to recognise the meaning of each abbreviation by looking it up in several places (more details [[#Custom abbreviations|below]]), and if the abbreviation is found, it will be formatted with a dotted underline and the "label" of this abbreviation will be displayed in a tooltip, like this: {{gcl|DAT}}. Alternatively, the abbreviation can be turned into a link to the wikipedia article about the corresponding grammatical category, like this: {{gcl|DAT|glossing=link}}. To choose the latter behvaiour, use the following parameter: {{para|glossing|link}}. It is possible for separate lines to employ different styles, in this case the parameters used will be {{para|glossing2}}, {{para|glossing3}}, etc.

{{anchor|gcl}}
If a particular glossing abbreviation is to be treated differently from the rest, then {{tl|gcl}} can be used:
<div style="margin-left:1.5em;">
<syntaxhighlight lang="wikitext">{{interlinear|ngagun-yi nga-nanda-yi nung
|{{gcl|1sg}}.NOM-{{gcl|ERG||}} {{gcl|1sgA|1st-person singular "agent"}}.3sgO-see-{{gcl|'''P'''ST}} {{gcl|3sg}}.ACC
|'I saw him/her.'}}</syntaxhighlight></div>
{{interlinear|ngagun-yi nga-nanda-yi nung
|1sg.NOM-{{gcl|ERG||}} {{gcl|1sgA|1st-person singular "agent"}}.3sgO-see-{{gcl|'''P'''ST}} {{gcl|3sg}}.{{gcl|acc}}
|'I saw him/her.'}}
In this example, {{tlc|gcl|acc}} marks up ''acc'' as a glossing abbreviation (it wouldn't have otherwise been interpreted as such because it is lower-case). {{tlc|gcl|1sgA|1st-person singular "agent"}} is used to define the meaning of the unusual abbreviation ''1sgA'', which wouldn't be recognised even in upper case. {{tlc|gcl|ERG||}} displays the abbreviation as a link to the Wikipedia article. {{tlc|gcl|<nowiki>'''P'''ST</nowiki>}} applies formatting to a part of a glossing abbreviation; if {{tlc|gcl}} weren't used here then the wikimarkup would have forced ''P'' to be treated as a separate abbreviation from ''ST''.

If the grammatical category labels are not abbreviated but written out in full (like that: {{gcl|ACCUSATIVE|glossing=no abbr}}) then {{para|glossing}} should be set to {{code|no abbr}}, which will only apply small-caps formatting:
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear|glossing=no abbr
|wǒ yǐjing jiàn-guò {Zhāng Sān} le.
|I already see-EXPERIENTIAL {Zhang San} RESULTATIVE.|}}</nowiki>}}</div>

Additional style<ref name="CSSnote">See https://www.w3schools.com/html/html_styles.asp, with the caveat that not all html features are available in wikitext, see [[Help:HTML in wikitext]].</ref> parameters can be applied to all gloss abbreviations using {{para|glossing-style}}. The default formatting using small caps can be disabled with {{para|small-caps|no}}, and the default underlining can be turned off using {{para|underline|no}}. To exempt a particular abbreviation from being treated as a grammatical gloss, use {{tl|no gloss}}.

The pesky boxes with glossing messages that are shown in preview mode can be turned off with {{para|display-messages|no}}.

=== <span id="Custom abbreviations">Custom abbreviations</span> ===
The template recognises some of the most commonly used abbreviations. However, it is recommended to always specify the meaning of each abbreviation used. There are several ways to do that:
*Defining '''at the article level'''. If an article uses a number of interlinearised examples and they share a set of abbreviations, then these can be defined once for the whole article using the following format:
*<syntaxhighlight lang="html">
<section begin="list-of-glossing-abbreviations"/><div style="display:none;">
ABBR1:meaning1
ABBR2:meaning2</div><section end="list-of-glossing-abbreviations"/>
</syntaxhighlight>
The list can contain any number of abbreviations; if a wikipedia article needs to be specified, it is added after a colon, for example: {{code|NEG:negator:Negation (linguistics)}}. This whole code can be placed anywhere in the article, but it is customary to put it at the end, after the references but before any categories. It is visible only in edit mode, it is not displayed in the article.
*Defining '''at the level of a single instance of the template'''. This is done using {{para|abbreviations}} (or {{para|ablist}}). The list of custom abbreviations takes the same format as above: {{code|ABBREVIATION1:meaning1:wikipedia_article1; ABBREVIATION2:meaning2:wikipedia_article2}}... (specifying a Wikipedia article is optional and has no effect unless {{para|glossing|link}}):
<div style="margin-left:1.5em;">
{{demo|br=0|<nowiki>{{interlinear|abbreviations=RES:resultative; EXP:experiential aspect
|wǒ yǐjing jiàn-guò {Zhāng Sān} le.
|I already see-EXP {Zhang San} RES.|}}</nowiki>}}</div>
*Defining '''a single instance of an abbreviation'''. This is done using {{tl|gcl}}, as seen [[#gcl|above]]
*Defining an abbreviation '''globally'''. This is done by the addition of an entry to [[Module:Interlinear/data|the module's data page]]. The abbreviation will be recognised by any use of the templates, anywhere on the English wikipedia. This should be done only for completely unambiguous abbreviations.

== Troubleshooting ==
This is a list of problems that are likely to be encountered:
* One of the lines went missing.
*:Does this line contain anywhere an equals sign? If yes, then all instances of the equals sign should be replaced with {{tlx|1==}}.

*I've applied bolding/italics to a phrase and now the formatting is all over the place.
*:Any formatting should be applied separately to each word.

* {{anchor|mismatch}} I receive the error "Mismatch in the number of words".
*:Interlinearised lines don't contain the same number of words. If this is intended, then consider filling the empty slots with {{code|{} }}. If this is not intended, then the following points might help track down the cause:
*:*if formatting or a template is applied to a piece of text then this text is treated as a single word:
*:*non-breaking spaces are not treated as word separators;
*:*if a sequence of words is enclosed in {curly brackets} then it's treated as a single word.

* {{anchor|gloss abbr}} I receive the error "Unknown glossing abbreviation(s)".
*:See [[#Glossing abbreviations|above]] for details, but in short:
*:*If this was not intended as a glossing abbreviation, enclose it in {{tl|no gloss}}.
*:*To set the meaning of one instance of a glossing abbreviation, format that instance with {{tl|gcl}}, for example {{tlc|gcl|PF|perfective aspect}}.
*:*If the abbreviation occurs several times within the same example then it might be easier to use the {{para|abbreviations}} parameter, for example: {{para|abbreviations|PF:perfective aspect}}.

==Tracking categories==
*{{clc|Pages using interlinear with unknown parameters}}
*{{clc|Pages with interlinear glosses using two unnamed parameters}}
*{{clc|Pages with interlinear glosses using more than three unnamed parameters}}
*{{clc|Pages with errors in interlinear text}}
*{{clc|Articles with ambiguous glossing abbreviations}}

== Notes ==
{{Reflist}}

== See also ==
* {{tl|fs interlinear}}, a version of this template which makes it easier to set up glosses with separate lines for a '''f'''oreign-'''s'''cript text and a transliteration
* {{tl|gcl}}, for formatting individual glossing abbreviations

==TemplateData==
{{Format TemplateData|1=
<templatedata>
{
"params": {
"1": {
"label": "First line of interlinear text",
"type": "string",
"required": true,
"description": "It is italicised by default (unless the parameter \"italics1\" is set to \"no\")."
},
"2": {
"label": "Second line of interlinear text",
"type": "string",
"suggested": true,
"description": "By default, this is expected to contain the glosses. If there are any glossing abbreviations, they will be expanded (unless the parameter \"glossing2\" is set to \"no\")."
},
"3": {
"label": "Third line of text",
"type": "string",
"suggested": true,
"description": "If it is the last line, it is assumed to be the translation and so will not be interlinearised. To force the last line to be interlinearised, then add a new, empty, line after it."
},
"4": {
"label": "Fourth line of text.",
"type": "string"
},
"5": {
"label": "Fifth line of text",
"type": "string"
},
"lang": {
"label": "Language of the text",
"description": "ISO 639 code of the language.",
"type": "string"
},
"indent": {
"description": "Indentation amount, in units of em.",
"type": "number"
},
"italics1": {
"description": "Whether to italicize |1=",
"type": "boolean",
"label": "Italicize line 1"
},
"italics2": {
"description": "Whether to italicize |2=",
"type": "boolean",
"label": "Italicize line 2"
},
"italics3": {
"description": "Whether to italicize |3=",
"type": "boolean",
"label": "Italicize line 3"
},
"class1": {
"label": "CSS class for |1=",
"type": "string"
},
"class2": {
"label": "CSS class for |2=",
"type": "string"
},
"class3": {
"label": "CSS class for |3=",
"type": "string"
},
"lang1": {
"description": "Language code for |1=",
"type": "string"
},
"lang2": {
"description": "Language code for |2=",
"type": "string"
},
"lang3": {
"description": "Language code for |3=",
"type": "string"
},
"ipa1": {
"description": "Whether |1= is IPA",
"type": "boolean",
"label": "Line 1 is IPA"
},
"ipa2": {
"description": "Whether |2= is IPA",
"type": "boolean",
"label": "Line 2 is IPA"
},
"ipa3": {
"description": "Whether |3= is IPA",
"type": "boolean",
"label": "Line 3 is IPA"
},
"transl1": {
"description": "Whether |1= is transliteration",
"type": "boolean",
"label": "Line 1 is transliteration"
},
"transl2": {
"description": "Whether |2= is transliteration",
"type": "boolean",
"label": "Line 2 is transliteration"
},
"transl3": {
"description": "Whether |3= is transliteration",
"type": "boolean",
"label": "Line 3 is transliteration"
},
"glossing1": {
"description": "Whether |1= is gloss",
"type": "boolean",
"label": "Line 1 is glossing"
},
"glossing2": {
"description": "Whether |2= is gloss",
"type": "boolean",
"label": "Line 2 is glossing"
},
"glossing3": {
"description": "Whether |3= is gloss",
"type": "boolean",
"label": "Line 3 is glossing"
},
"glossing-style": {
"label": "CSS style for glossing abbreviations",
"type": "string"
},
"top": {
"type": "content",
"label": "Text to place on top"
},
"bottom": {
"type": "content",
"label": "Text to place on bottom"
},
"number": {
"type": "string",
"label": "Example number",
"suggestedvalues": [
"(1)",
"(21a)"
]
},
"spacing": {
"description": "spacing between consecutive word stacks, set in em",
"default": "1",
"type": "number"
},
"box": {
"description": "Whether to add a box border",
"type": "boolean"
},
"c1": {
"label": "Comment after line 1",
"type": "content"
},
"c2": {
"label": "Comment after line 2",
"type": "content"
},
"c3": {
"label": "Comment after line 3",
"type": "content"
},
"tone-superscripting": {
"label": "Tone superscripting",
"description": "Whether to format tone numbers as superscripts on italicized lines",
"type": "boolean"
},
"glossing": {
"label": "Glossing display behavior",
"description": "Glossing behavior. \"link\" to create links to articles. \"no abbr\" to turn off attempts at translating of abbreviations. These parameters can also apply individually in glossing1/2/3.",
"type": "string",
"suggestedvalues": [
"link",
"no abbr"
]
},
"small-caps": {
"label": "Use small capitals for glossing abbreviations",
"type": "boolean",
"default": "yes"
},
"underline": {
"label": "Underline glossing abbreviations",
"type": "boolean",
"default": "yes"
},
"display-messages": {
"label": "Display glossing-related messages in preview",
"type": "boolean",
"default": "yes"
},
"abbreviations": {
"aliases": [
"ablist"
],
"label": "Custom abbreviations",
"type": "content"
}
},
"description": "This template formats interlinear glossed text.\nOnly a few of the capabilities of this template are documented here. For all options, see its documentation. Alignment is automatic, so there is no need to add padding either inside or around the template.",
"paramOrder": [
"1",
"2",
"3",
"4",
"5",
"lang",
"top",
"number",
"indent",
"bottom",
"spacing",
"glossing-style",
"box",
"lang1",
"lang2",
"lang3",
"italics1",
"italics2",
"italics3",
"class1",
"class2",
"class3",
"ipa1",
"ipa2",
"ipa3",
"transl1",
"transl2",
"transl3",
"glossing1",
"glossing2",
"glossing3",
"c1",
"c2",
"c3",
"tone-superscripting",
"glossing",
"small-caps",
"underline",
"display-messages",
"abbreviations"
],
"format": "block"
}
</templatedata>
}}
<includeonly>{{Sandbox other||
[[Category:Linguistics templates]]
[[Category:Language formatting and function templates]]
[[Category:Layout templates]]
[[Category:Translation templates]]
}}</includeonly>

</noinclude>

Template:Interlinear

2024-04-05T21:16:19Z

Vaxjedi:

Template:Interlinear

2024-04-05T21:15:08Z

Vaxjedi: Created page with "<includeonly><templatestyles src="Interlinear/styles.css" />{{#invoke:Interlinear|interlinearise}}</includeonly>{{#invoke:Check for unknown parameters|check|unknown={{main other|_VALUE_{{PAGENAME}}}}|preview=Page using Template:Interlinear with unknown parameter "_VALUE_"|ignoreblank=y| 1 | 2 | 3 | 4 | 5 | abbreviations | bottom | box | c1 | c2 | c3 | c..."

<includeonly><templatestyles src="Interlinear/styles.css" />{{#invoke:Interlinear|interlinearise}}</includeonly>{{#invoke:Check for unknown parameters|check|unknown={{main other|[[Category:Pages using interlinear with unknown parameters|_VALUE_{{PAGENAME}}]]}}|preview=Page using [[Template:Interlinear]] with unknown parameter "_VALUE_"|ignoreblank=y| 1 | 2 | 3 | 4 | 5 | abbreviations | bottom | box | c1 | c2 | c3 | c4 | c5 | class1 | class2 | class3 | class4 | class5 | display-messages | glossing-style | glossing | glossing1 | glossing2 | glossing3 | glossing4 | glossing5 | indent | ipa1 | ipa2 | ipa3 | italics1 | italics2 | italics3 | italics4 | italics5 | lang | lang1 | lang2 | lang3 | number | small-caps | spacing | style1 | style2 | style3 | tone-superscripting | top | transl1 | transl2 | transl3 | underline }}<noinclude>

{{Documentation}}
</noinclude>

Module:Interlinear/doc

2024-04-05T21:14:04Z

Vaxjedi: Created page with " {{Lua|Module:Interlinear/data|Module:Ancient Greek|Module:Lang/data|Module:Yesno|Module:Arguments}} This is the module for Template:Interlinear and Template:gcl. The function invoked by the first one is {{code|p.interlinearise}} and the one invoked by the latter is {{code|p.gcl}}. See those templates' documentation for usage instructions. Most of the glossing abbreviations are loaded from the data subpage. <includeonly>{{#ifeq:{{SUB..."

{{Lua|Module:Interlinear/data|Module:Ancient Greek|Module:Lang/data|Module:Yesno|Module:Arguments}}
This is the module for [[Template:Interlinear]] and [[Template:gcl]]. The function invoked by the first one is {{code|p.interlinearise}} and the one invoked by the latter is {{code|p.gcl}}. See those templates' documentation for usage instructions.

Most of the glossing abbreviations are loaded from [[Module:Interlinear/data|the data subpage]].

<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox | |

[[Category:Language-related modules]]
}}</includeonly>

Module:Arguments/doc

2024-04-05T21:13:08Z

Vaxjedi: Created page with " This module provides easy processing of arguments passed from <code>#invoke</code>. It is a meta-module, meant for use by other modules, and should not be called from <code>#invoke</code> directly (for a module directly invocable by templates you might want to have a look at {{ml|params|}}). Its features include: * Easy trimming of arguments and removal of blank arguments. * Arguments can be passed by both the current frame and by the parent frame at the same time. (Mo..."

This module provides easy processing of arguments passed from <code>#invoke</code>. It is a meta-module, meant for use by other modules, and should not be called from <code>#invoke</code> directly (for a module directly invocable by templates you might want to have a look at {{ml|params|}}). Its features include:
* Easy trimming of arguments and removal of blank arguments.
* Arguments can be passed by both the current frame and by the parent frame at the same time. (More details below.)
* Arguments can be passed in directly from another Lua module or from the debug console.
* Most features can be customized.

== Basic use ==

First, you need to load the module. It contains one function, named <code>getArgs</code>.

<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
</syntaxhighlight>

In the most basic scenario, you can use getArgs inside your main function. The variable <code>args</code> is a table containing the arguments from #invoke. (See below for details.)

<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
local args = getArgs(frame)
-- Main module code goes here.
end

return p
</syntaxhighlight>

=== Recommended practice ===
However, the recommended practice is to use a function just for processing arguments from #invoke. This means that if someone calls your module from another Lua module you don't have to have a frame object available, which improves performance.

<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
local args = getArgs(frame)
return p._main(args)
end

function p._main(args)
-- Main module code goes here.
end

return p
</syntaxhighlight>

The way this is called from a template is <code><nowiki>{{#invoke:Example|main}}</nowiki></code> (optionally with some parameters like <code><nowiki>{{#invoke:Example|main|arg1=value1|arg2=value2}}</nowiki></code>), and the way this is called from a module is <syntaxhighlight lang=lua inline>require('Module:Example')._main({arg1 = 'value1', arg2 = value2, 'spaced arg3' = 'value3'})</syntaxhighlight>. What this second one does is construct a table with the arguments in it, then gives that table to the p._main(args) function, which uses it natively.

=== Multiple functions ===
If you want multiple functions to use the arguments, and you also want them to be accessible from #invoke, you can use a wrapper function.

<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs

local p = {}

local function makeInvokeFunc(funcName)
return function (frame)
local args = getArgs(frame)
return p[funcName](args)
end
end

p.func1 = makeInvokeFunc('_func1')

function p._func1(args)
-- Code for the first function goes here.
end

p.func2 = makeInvokeFunc('_func2')

function p._func2(args)
-- Code for the second function goes here.
end

return p
</syntaxhighlight>

=== Options ===

The following options are available. They are explained in the sections below.

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
trim = false,
removeBlanks = false,
valueFunc = function (key, value)
-- Code for processing one argument
end,
frameOnly = true,
parentOnly = true,
parentFirst = true,
wrappers = {
'Template:A wrapper template',
'Template:Another wrapper template'
},
readOnly = true,
noOverwrite = true
})
</syntaxhighlight>

=== Trimming and removing blanks ===

Blank arguments often trip up coders new to converting MediaWiki templates to Lua. In template syntax, blank strings and strings consisting only of whitespace are considered false. However, in Lua, blank strings and strings consisting of whitespace are considered true. This means that if you don't pay attention to such arguments when you write your Lua modules, you might treat something as true that should actually be treated as false. To avoid this, by default this module removes all blank arguments.

Similarly, whitespace can cause problems when dealing with positional arguments. Although whitespace is trimmed for named arguments coming from #invoke, it is preserved for positional arguments. Most of the time this additional whitespace is not desired, so this module trims it off by default.

However, sometimes you want to use blank arguments as input, and sometimes you want to keep additional whitespace. This can be necessary to convert some templates exactly as they were written. If you want to do this, you can set the <code>trim</code> and <code>removeBlanks</code> arguments to <code>false</code>.

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
trim = false,
removeBlanks = false
})
</syntaxhighlight>

=== Custom formatting of arguments ===

Sometimes you want to remove some blank arguments but not others, or perhaps you might want to put all of the positional arguments in lower case. To do things like this you can use the <code>valueFunc</code> option. The input to this option must be a function that takes two parameters, <code>key</code> and <code>value</code>, and returns a single value. This value is what you will get when you access the field <code>key</code> in the <code>args</code> table.

Example 1: this function preserves whitespace for the first positional argument's value, but trims all other arguments' value and removes all other blank arguments.
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
if key == 1 then
return value
elseif value then
value = mw.text.trim(value)
if value ~= '' then
return value
end
end
return nil
end
})
</syntaxhighlight>

Example 2: this function removes blank arguments and converts all argument values to lower case, but doesn't trim whitespace from positional parameters.
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
if not value then
return nil
end
value = mw.ustring.lower(value)
if mw.ustring.find(value, '%S') then
return value
end
return nil
end
})
</syntaxhighlight>

Note: the above functions will fail if passed input that is not of type <code>string</code> or <code>nil</code>. This might be the case if you use the <code>getArgs</code> function in the main function of your module, and that function is called by another Lua module. In this case, you will need to check the type of your input. This is not a problem if you are using a function specially for arguments from #invoke (i.e. you have <code>p.main</code> and <code>p._main</code> functions, or something similar).

{{cot|Examples 1 and 2 with type checking}}
Example 1:
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
if key == 1 then
return value
elseif type(value) == 'string' then
value = mw.text.trim(value)
if value ~= '' then
return value
else
return nil
end
else
return value
end
end
})
</syntaxhighlight>

Example 2:
<syntaxhighlight lang="lua">
local args = getArgs(frame, {
valueFunc = function (key, value)
if type(value) == 'string' then
value = mw.ustring.lower(value)
if mw.ustring.find(value, '%S') then
return value
else
return nil
end
else
return value
end
end
})
</syntaxhighlight>
{{cob}}

Also, please note that the <code>valueFunc</code> function is called more or less every time an argument is requested from the <code>args</code> table, so if you care about performance you should make sure you aren't doing anything inefficient with your code.

=== Frames and parent frames ===

Arguments in the <code>args</code> table can be passed from the current frame or from its parent frame at the same time. To understand what this means, it is easiest to give an example. Let's say that we have a module called <code>Module:ExampleArgs</code>. This module prints the first two positional arguments that it is passed.

{{cot|Module:ExampleArgs code}}
<syntaxhighlight lang="lua">
local getArgs = require('Module:Arguments').getArgs
local p = {}

function p.main(frame)
local args = getArgs(frame)
return p._main(args)
end

function p._main(args)
local first = args[1] or ''
local second = args[2] or ''
return first .. ' ' .. second
end

return p
</syntaxhighlight>
{{cob}}

<code>Module:ExampleArgs</code> is then called by <code>Template:ExampleArgs</code>, which contains the code <code><nowiki>{{#invoke:ExampleArgs|main|firstInvokeArg}}</nowiki></code>. This produces the result "firstInvokeArg".

Now if we were to call <code>Template:ExampleArgs</code>, the following would happen:

{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | Code
! style="width: 40%;" | Result
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstInvokeArg secondTemplateArg
|}

There are three options you can set to change this behaviour: <code>frameOnly</code>, <code>parentOnly</code> and <code>parentFirst</code>. If you set <code>frameOnly</code> then only arguments passed from the current frame will be accepted; if you set <code>parentOnly</code> then only arguments passed from the parent frame will be accepted; and if you set <code>parentFirst</code> then arguments will be passed from both the current and parent frames, but the parent frame will have priority over the current frame. Here are the results in terms of <code>Template:ExampleArgs</code>:

; frameOnly
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | Code
! style="width: 40%;" | Result
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstInvokeArg
|}

; parentOnly
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | Code
! style="width: 40%;" | Result
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
|
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstTemplateArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstTemplateArg secondTemplateArg
|}

; parentFirst
{| class="wikitable" style="width: 50em; max-width: 100%;"
|-
! style="width: 60%;" | Code
! style="width: 40%;" | Result
|-
| <code><nowiki>{{ExampleArgs}}</nowiki></code>
| firstInvokeArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg}}</nowiki></code>
| firstTemplateArg
|-
| <code><nowiki>{{ExampleArgs|firstTemplateArg|secondTemplateArg}}</nowiki></code>
| firstTemplateArg secondTemplateArg
|}

Notes:
# If you set both the <code>frameOnly</code> and <code>parentOnly</code> options, the module won't fetch any arguments at all from #invoke. This is probably not what you want.
# In some situations a parent frame may not be available, e.g. if getArgs is passed the parent frame rather than the current frame. In this case, only the frame arguments will be used (unless parentOnly is set, in which case no arguments will be used) and the <code>parentFirst</code> and <code>frameOnly</code> options will have no effect.

=== Wrappers ===

The ''wrappers'' option is used to specify a limited number of templates as ''wrapper templates'', that is, templates whose only purpose is to call a module. If the module detects that it is being called from a wrapper template, it will only check for arguments in the parent frame; otherwise it will only check for arguments in the frame passed to getArgs. This allows modules to be called by either #invoke or through a wrapper template without the loss of performance associated with having to check both the frame and the parent frame for each argument lookup.

For example, the only content of [[Template:Side box]] (excluding content in {{tag|noinclude}} tags) is <code><nowiki>{{#invoke:Side box|main}}</nowiki></code>. There is no point in checking the arguments passed directly to the #invoke statement for this template, as no arguments will ever be specified there. We can avoid checking arguments passed to #invoke by using the ''parentOnly'' option, but if we do this then #invoke will not work from other pages either. If this were the case, the {{para|text|Some text}} in the code <code><nowiki>{{#invoke:Side box|main|text=Some text}}</nowiki></code> would be ignored completely, no matter what page it was used from. By using the <code>wrappers</code> option to specify 'Template:Side box' as a wrapper, we can make <code><nowiki>{{#invoke:Side box|main|text=Some text}}</nowiki></code> work from most pages, while still not requiring that the module check for arguments on the [[Template:Side box]] page itself.

Wrappers can be specified either as a string, or as an array of strings.

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
wrappers = 'Template:Wrapper template'
})
</syntaxhighlight>

<syntaxhighlight lang="lua">
local args = getArgs(frame, {
wrappers = {
'Template:Wrapper 1',
'Template:Wrapper 2',
-- Any number of wrapper templates can be added here.
}
})
</syntaxhighlight>

Notes:
# The module will automatically detect if it is being called from a wrapper template's /sandbox subpage, so there is no need to specify sandbox pages explicitly.
# The ''wrappers'' option effectively changes the default of the ''frameOnly'' and ''parentOnly'' options. If, for example, ''parentOnly'' were explicitly set to 0 with ''wrappers'' set, calls via wrapper templates would result in both frame and parent arguments being loaded, though calls not via wrapper templates would result in only frame arguments being loaded.
# If the ''wrappers'' option is set and no parent frame is available, the module will always get the arguments from the frame passed to <code>getArgs</code>.

=== Writing to the args table ===

Sometimes it can be useful to write new values to the args table. This is possible with the default settings of this module. (However, bear in mind that it is usually better coding style to create a new table with your new values and copy arguments from the args table as needed.)

<syntaxhighlight lang="lua">
args.foo = 'some value'
</syntaxhighlight>

It is possible to alter this behaviour with the <code>readOnly</code> and <code>noOverwrite</code> options. If <code>readOnly</code> is set then it is not possible to write any values to the args table at all. If <code>noOverwrite</code> is set, then it is possible to add new values to the table, but it is not possible to add a value if it would overwrite any arguments that are passed from #invoke.

=== Ref tags ===

This module uses [[mw:Extension:Scribunto/Lua reference manual#Metatables|metatables]] to fetch arguments from #invoke. This allows access to both the frame arguments and the parent frame arguments without using the <code>pairs()</code> function. This can help if your module might be passed {{tag|ref}} tags as input.

As soon as {{tag|ref}} tags are accessed from Lua, they are processed by the MediaWiki software and the reference will appear in the reference list at the bottom of the article. If your module proceeds to omit the reference tag from the output, you will end up with a phantom reference – a reference that appears in the reference list but without any number linking to it. This has been a problem with modules that use <code>pairs()</code> to detect whether to use the arguments from the frame or the parent frame, as those modules automatically process every available argument.

This module solves this problem by allowing access to both frame and parent frame arguments, while still only fetching those arguments when it is necessary. The problem will still occur if you use <code>pairs(args)</code> elsewhere in your module, however.

=== Known limitations ===

The use of metatables also has its downsides. Most of the normal Lua table tools won't work properly on the args table, including the <code>#</code> operator, the <code>next()</code> function, and the functions in the table library. If using these is important for your module, you should use your own argument processing function instead of this module.<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
[[Category:Lua metamodules]]
}}</includeonly>

== See also ==
* [[Module:Params]]

<includeonly>{{Sandbox other||

[[Category:Wikipedia utility modules]]
}}</includeonly>

Module:Arguments

2024-04-05T21:12:23Z

Vaxjedi: Created page with "-- This module provides easy processing of arguments passed to Scribunto from -- #invoke. It is intended for use by other Lua modules, and should not be -- called from #invoke directly. local libraryUtil = require('libraryUtil') local checkType = libraryUtil.checkType local arguments = {} -- Generate four different tidyVal functions, so that we don't have to check the -- options every time we call it. local function tidyValDefault(key, val) if type(val) == 'string'..."

-- This module provides easy processing of arguments passed to Scribunto from
-- #invoke. It is intended for use by other Lua modules, and should not be
-- called from #invoke directly.

local libraryUtil = require('libraryUtil')
local checkType = libraryUtil.checkType

local arguments = {}

-- Generate four different tidyVal functions, so that we don't have to check the
-- options every time we call it.

local function tidyValDefault(key, val)
if type(val) == 'string' then
val = val:match('^%s*(.-)%s*$')
if val == '' then
return nil
else
return val
end
else
return val
end
end

local function tidyValTrimOnly(key, val)
if type(val) == 'string' then
return val:match('^%s*(.-)%s*$')
else
return val
end
end

local function tidyValRemoveBlanksOnly(key, val)
if type(val) == 'string' then
if val:find('%S') then
return val
else
return nil
end
else
return val
end
end

local function tidyValNoChange(key, val)
return val
end

local function matchesTitle(given, title)
local tp = type( given )
return (tp == 'string' or tp == 'number') and mw.title.new( given ).prefixedText == title
end

local translate_mt = { __index = function(t, k) return k end }

function arguments.getArgs(frame, options)
checkType('getArgs', 1, frame, 'table', true)
checkType('getArgs', 2, options, 'table', true)
frame = frame or {}
options = options or {}

--[[
-- Set up argument translation.
--]]
options.translate = options.translate or {}
if getmetatable(options.translate) == nil then
setmetatable(options.translate, translate_mt)
end
if options.backtranslate == nil then
options.backtranslate = {}
for k,v in pairs(options.translate) do
options.backtranslate[v] = k
end
end
if options.backtranslate and getmetatable(options.backtranslate) == nil then
setmetatable(options.backtranslate, {
__index = function(t, k)
if options.translate[k] ~= k then
return nil
else
return k
end
end
})
end

--[[
-- Get the argument tables. If we were passed a valid frame object, get the
-- frame arguments (fargs) and the parent frame arguments (pargs), depending
-- on the options set and on the parent frame's availability. If we weren't
-- passed a valid frame object, we are being called from another Lua module
-- or from the debug console, so assume that we were passed a table of args
-- directly, and assign it to a new variable (luaArgs).
--]]
local fargs, pargs, luaArgs
if type(frame.args) == 'table' and type(frame.getParent) == 'function' then
if options.wrappers then
--[[
-- The wrappers option makes Module:Arguments look up arguments in
-- either the frame argument table or the parent argument table, but
-- not both. This means that users can use either the #invoke syntax
-- or a wrapper template without the loss of performance associated
-- with looking arguments up in both the frame and the parent frame.
-- Module:Arguments will look up arguments in the parent frame
-- if it finds the parent frame's title in options.wrapper;
-- otherwise it will look up arguments in the frame object passed
-- to getArgs.
--]]
local parent = frame:getParent()
if not parent then
fargs = frame.args
else
local title = parent:getTitle():gsub('/sandbox$', '')
local found = false
if matchesTitle(options.wrappers, title) then
found = true
elseif type(options.wrappers) == 'table' then
for _,v in pairs(options.wrappers) do
if matchesTitle(v, title) then
found = true
break
end
end
end

-- We test for false specifically here so that nil (the default) acts like true.
if found or options.frameOnly == false then
pargs = parent.args
end
if not found or options.parentOnly == false then
fargs = frame.args
end
end
else
-- options.wrapper isn't set, so check the other options.
if not options.parentOnly then
fargs = frame.args
end
if not options.frameOnly then
local parent = frame:getParent()
pargs = parent and parent.args or nil
end
end
if options.parentFirst then
fargs, pargs = pargs, fargs
end
else
luaArgs = frame
end

-- Set the order of precedence of the argument tables. If the variables are
-- nil, nothing will be added to the table, which is how we avoid clashes
-- between the frame/parent args and the Lua args.
local argTables = {fargs}
argTables[#argTables + 1] = pargs
argTables[#argTables + 1] = luaArgs

--[[
-- Generate the tidyVal function. If it has been specified by the user, we
-- use that; if not, we choose one of four functions depending on the
-- options chosen. This is so that we don't have to call the options table
-- every time the function is called.
--]]
local tidyVal = options.valueFunc
if tidyVal then
if type(tidyVal) ~= 'function' then
error(
"bad value assigned to option 'valueFunc'"
.. '(function expected, got '
.. type(tidyVal)
.. ')',
2
)
end
elseif options.trim ~= false then
if options.removeBlanks ~= false then
tidyVal = tidyValDefault
else
tidyVal = tidyValTrimOnly
end
else
if options.removeBlanks ~= false then
tidyVal = tidyValRemoveBlanksOnly
else
tidyVal = tidyValNoChange
end
end

--[[
-- Set up the args, metaArgs and nilArgs tables. args will be the one
-- accessed from functions, and metaArgs will hold the actual arguments. Nil
-- arguments are memoized in nilArgs, and the metatable connects all of them
-- together.
--]]
local args, metaArgs, nilArgs, metatable = {}, {}, {}, {}
setmetatable(args, metatable)

local function mergeArgs(tables)
--[[
-- Accepts multiple tables as input and merges their keys and values
-- into one table. If a value is already present it is not overwritten;
-- tables listed earlier have precedence. We are also memoizing nil
-- values, which can be overwritten if they are 's' (soft).
--]]
for _, t in ipairs(tables) do
for key, val in pairs(t) do
if metaArgs[key] == nil and nilArgs[key] ~= 'h' then
local tidiedVal = tidyVal(key, val)
if tidiedVal == nil then
nilArgs[key] = 's'
else
metaArgs[key] = tidiedVal
end
end
end
end
end

--[[
-- Define metatable behaviour. Arguments are memoized in the metaArgs table,
-- and are only fetched from the argument tables once. Fetching arguments
-- from the argument tables is the most resource-intensive step in this
-- module, so we try and avoid it where possible. For this reason, nil
-- arguments are also memoized, in the nilArgs table. Also, we keep a record
-- in the metatable of when pairs and ipairs have been called, so we do not
-- run pairs and ipairs on the argument tables more than once. We also do
-- not run ipairs on fargs and pargs if pairs has already been run, as all
-- the arguments will already have been copied over.
--]]

metatable.__index = function (t, key)
--[[
-- Fetches an argument when the args table is indexed. First we check
-- to see if the value is memoized, and if not we try and fetch it from
-- the argument tables. When we check memoization, we need to check
-- metaArgs before nilArgs, as both can be non-nil at the same time.
-- If the argument is not present in metaArgs, we also check whether
-- pairs has been run yet. If pairs has already been run, we return nil.
-- This is because all the arguments will have already been copied into
-- metaArgs by the mergeArgs function, meaning that any other arguments
-- must be nil.
--]]
if type(key) == 'string' then
key = options.translate[key]
end
local val = metaArgs[key]
if val ~= nil then
return val
elseif metatable.donePairs or nilArgs[key] then
return nil
end
for _, argTable in ipairs(argTables) do
local argTableVal = tidyVal(key, argTable[key])
if argTableVal ~= nil then
metaArgs[key] = argTableVal
return argTableVal
end
end
nilArgs[key] = 'h'
return nil
end

metatable.__newindex = function (t, key, val)
-- This function is called when a module tries to add a new value to the
-- args table, or tries to change an existing value.
if type(key) == 'string' then
key = options.translate[key]
end
if options.readOnly then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; the table is read-only',
2
)
elseif options.noOverwrite and args[key] ~= nil then
error(
'could not write to argument table key "'
.. tostring(key)
.. '"; overwriting existing arguments is not permitted',
2
)
elseif val == nil then
--[[
-- If the argument is to be overwritten with nil, we need to erase
-- the value in metaArgs, so that __index, __pairs and __ipairs do
-- not use a previous existing value, if present; and we also need
-- to memoize the nil in nilArgs, so that the value isn't looked
-- up in the argument tables if it is accessed again.
--]]
metaArgs[key] = nil
nilArgs[key] = 'h'
else
metaArgs[key] = val
end
end

local function translatenext(invariant)
local k, v = next(invariant.t, invariant.k)
invariant.k = k
if k == nil then
return nil
elseif type(k) ~= 'string' or not options.backtranslate then
return k, v
else
local backtranslate = options.backtranslate[k]
if backtranslate == nil then
-- Skip this one. This is a tail call, so this won't cause stack overflow
return translatenext(invariant)
else
return backtranslate, v
end
end
end

metatable.__pairs = function ()
-- Called when pairs is run on the args table.
if not metatable.donePairs then
mergeArgs(argTables)
metatable.donePairs = true
end
return translatenext, { t = metaArgs }
end

local function inext(t, i)
-- This uses our __index metamethod
local v = t[i + 1]
if v ~= nil then
return i + 1, v
end
end

metatable.__ipairs = function (t)
-- Called when ipairs is run on the args table.
return inext, t, 0
end

return args
end

return arguments

Module:Yesno/doc

2024-04-05T21:11:31Z

Vaxjedi: Created page with " This module provides a consistent interface for processing boolean or boolean-style string input. While Lua allows the <code>true</code> and <code>false</code> boolean values, wikicode templates can only express boolean values through strings such as "yes", "no", etc. This module processes these kinds of strings and turns them into boolean input for Lua to process. It also returns <code>nil</code> values as <code>nil</code>, to allow for distinctions between <code>nil</..."

This module provides a consistent interface for processing boolean or boolean-style string input. While Lua allows the <code>true</code> and <code>false</code> boolean values, wikicode templates can only express boolean values through strings such as "yes", "no", etc. This module processes these kinds of strings and turns them into boolean input for Lua to process. It also returns <code>nil</code> values as <code>nil</code>, to allow for distinctions between <code>nil</code> and <code>false</code>. The module also accepts other Lua structures as input, i.e. booleans, numbers, tables, and functions. If it is passed input that it does not recognise as boolean or <code>nil</code>, it is possible to specify a default value to return.

== Syntax ==

<syntaxhighlight lang="lua">yesno(value, default)</syntaxhighlight>

<code>value</code> is the value to be tested. Boolean input or boolean-style input (see below) always evaluates to either <code>true</code> or <code>false</code>, and <code>nil</code> always evaluates to <code>nil</code>. Other values evaluate to <code>default</code>.

== Usage ==

First, load the module. Note that it can only be loaded from other Lua modules, not from normal wiki pages. For normal wiki pages you can use {{tl|yesno}} instead.

<syntaxhighlight lang="lua">
local yesno = require('Module:Yesno')
</syntaxhighlight>

Some input values always return <code>true</code>, and some always return <code>false</code>. <code>nil</code> values always return <code>nil</code>.

<syntaxhighlight lang="lua">
-- These always return true:
yesno('yes')
yesno('y')
yesno('true')
yesno('t')
yesno('on')
yesno('1')
yesno(1)
yesno(true)

-- These always return false:
yesno('no')
yesno('n')
yesno('false')
yesno('f')
yesno('off')
yesno('0')
yesno(0)
yesno(false)

-- A nil value always returns nil:
yesno(nil)
yesno()
</syntaxhighlight>

String values are converted to lower case before they are matched:

<syntaxhighlight lang="lua">
-- These always return true:
yesno('Yes')
yesno('YES')
yesno('yEs')
yesno('Y')
yesno('tRuE')

-- These always return false:
yesno('No')
yesno('NO')
yesno('nO')
yesno('N')
yesno('fALsE')
</syntaxhighlight>

===Undefined input ('foo')===
You can specify a default value if yesno receives input other than that listed above. If you don't supply a default, the module will return <code>nil</code> for these inputs.

<syntaxhighlight lang="lua">
-- These return nil:
yesno(nil)
yesno('foo')
yesno({})
yesno(5)
yesno('')
yesno(function() return 'This is a function.' end)
yesno(nil, true)
yesno(nil, 'bar')

-- These return true:
yesno('foo', true)
yesno({}, true)
yesno(5, true)
yesno('', true)
yesno(function() return 'This is a function.' end, true)

-- These return "bar":
yesno('foo', 'bar')
yesno({}, 'bar')
yesno(5, 'bar')
yesno('', 'bar')
yesno(function() return 'This is a function.' end, 'bar')
</syntaxhighlight>

Although the empty string usually evaluates to false in wikitext, it evaluates to true in Lua. This module prefers the Lua behaviour over the wikitext behaviour. If treating the empty string as false is important for your module, you will need to convert empty strings to a value that evaluates to false before passing them to this module. In the case of arguments received from wikitext, this can be done by using [[Module:Arguments]].

===Handling nil results===
By definition:
<syntaxhighlight lang="lua">
yesno(nil) -- Returns nil.
yesno('foo') -- Returns nil.
yesno(nil, true) -- Returns nil.
yesno(nil, false) -- Returns nil.
yesno('foo', true) -- Returns true.
</syntaxhighlight>

To get the binary <syntaxhighlight lang="lua" inline>true/false</syntaxhighlight>-only values, use code like:
<syntaxhighlight lang="lua">
myvariable = yesno(value or false) -- When value is nil, result is false.
myvariable = yesno(value or true) -- When value is nil, result is true.
myvariable = yesno('foo') or false -- Unknown string returns nil, result is false.
myvariable = yesno('foo', true) or false -- Default value (here: true) applies, result is true.
</syntaxhighlight><includeonly>{{sandbox other||
[[Category:Lua metamodules]]
}}</includeonly>

Module:Yesno

2024-04-05T21:11:00Z

Vaxjedi: Created page with "-- Function allowing for consistent treatment of boolean-like wikitext input. -- It works similarly to the template {{yesno}}. return function (val, default) -- If your wiki uses non-ascii characters for any of "yes", "no", etc., you -- should replace "val:lower()" with "mw.ustring.lower(val)" in the -- following line. val = type(val) == 'string' and val:lower() or val if val == nil then return nil elseif val == true or val == 'yes' or val == 'y' or val =..."

-- Function allowing for consistent treatment of boolean-like wikitext input.
-- It works similarly to the template {{yesno}}.

return function (val, default)
-- If your wiki uses non-ascii characters for any of "yes", "no", etc., you
-- should replace "val:lower()" with "mw.ustring.lower(val)" in the
-- following line.
val = type(val) == 'string' and val:lower() or val
if val == nil then
return nil
elseif val == true
or val == 'yes'
or val == 'y'
or val == 'true'
or val == 't'
or val == 'on'
or tonumber(val) == 1
then
return true
elseif val == false
or val == 'no'
or val == 'n'
or val == 'false'
or val == 'f'
or val == 'off'
or tonumber(val) == 0
then
return false
else
return default
end
end

Module:Interlinear/data

2024-04-05T21:10:24Z

Vaxjedi: Created page with "--The table here is traversed by the function that expands glossing abbreviations. If the abbreviation isn't found in this list and it begins with an "N" then the function will discard the "N" and search again, returning the result prefixed with "non-" (ex. "NFUT" is not found, so it will search for "FUT" and return "non-future"). A few abbreviations are exempt from this behaviour and they're marked by the ExcludeNegation key.-- local abbreviations = { ["0"] = {expan..."

--[[The table here is traversed by the function that expands glossing abbreviations.
If the abbreviation isn't found in this list and it begins with an "N" then the function
will discard the "N" and search again, returning the result prefixed with "non-" (ex. "NFUT"
is not found, so it will search for "FUT" and return "non-future"). A few abbreviations
are exempt from this behaviour and they're marked by the ExcludeNegation key.]]--
local abbreviations = {
["0"] = {expansion = "", wikipage = ""},
["1"] = {expansion = "first person", wikipage = "Grammatical person"},
["2"] = {expansion = "second person", wikipage = "Grammatical person"},
["3"] = {expansion = "third person", wikipage = "grammatical person"},
["3OBV"] = {expansion = "third person obviative", wikipage = "Obviative"},
["A"] = {expansion = "agent-like argument of canonical transitive verb", wikipage = "A (glossing abbreviation)", ExcludeNegation = true},
["ABE"] = {expansion = "abessive case ('without')", wikipage = "abessive case"},
["ABL"] = {expansion = "ablative case", wikipage = "ablative case"},
["ABS"] = {expansion = "absolutive case", wikipage = "absolutive case"},
["ACC"] = {expansion = "accusative case", wikipage = "accusative case"},
["ACCOM"] = {expansion = "accompanier", wikipage = ""},
["ACT"] = {expansion = "active/actor", wikipage = "active voice", ambiguous = true},
["ADJ"] = {expansion = "adjective", wikipage = "adjective"},
["ADE"] = {expansion = "adessive case", wikipage = "adessive case"},
["ADM"] = {expansion = "admonitive mood (warning)", wikipage = "admonitive mood"},
["ADV"] = {expansion = "adverb(ial)", wikipage = "adverbial", ambiguous = true},
["AFF"] = {expansion = "affirmative", wikipage = "affirmative (linguistics)"},
["AG"] = {expansion = "agentive case", wikipage = "agent (grammar)"},
["AGT"] = {expansion = "agentive case", wikipage = "agentive case"},
["AGR"] = {expansion = "agreement", wikipage = "agreement (grammar)"},
["ALL"] = {expansion = "allative case ('to')", wikipage = "allative case"},
["AL"] = {expansion = "allocutive agreement", wikipage = "allocutive agreement"},
["ALLOC"] = {expansion = "allocutive agreement", wikipage = "allocutive agreement"},
["ALIEN"] = {expansion = "alienable possession", wikipage = "alienable possession"},
["AN"] = {expansion = "animate", wikipage = "animacy"},
["ANAPH"] = {expansion = "anaphora/anaphoric", wikipage = "Anaphora (linguistics)"},
["AND"] = {expansion = "andative ('going towards')", wikipage = "andative"},
["ANIM"] = {expansion = "animate", wikipage = "animacy"},
["ANT"] = {expansion = "anterior tense", wikipage = "anterior tense"},
["ANTE"] = {expansion = "antessive case ('before')", wikipage = "antessive case"},
["ANTIC"] = {expansion = "anticausative", wikipage = "anticausative"},
["ANTIP"] = {expansion = "antipassive voice", wikipage = "antipassive voice"},
["AP"] = {expansion = "antipassive voice", wikipage = "antipassive voice"},
["AOR"] = {expansion = "aorist", wikipage = "aorist"},
["APP"] = {expansion = "apposition", wikipage = "apposition"},
["APL"] = {expansion = "applicative voice", wikipage = "applicative voice"},
["APPL"] = {expansion = "applicative voice", wikipage = "applicative voice"},
["APPR"] = {expansion = "apprehensive mood", wikipage = "apprehensive mood"},
["APRX"] = {expansion = "approximative", wikipage = "approximative"},
["ART"] = {expansion = "article", wikipage = "article (grammar)"},
["ASP"] = {expansion = "aspect", wikipage = "aspect (grammar)"},
["ASS"] = {expansion = "associative case", wikipage = "associative case", ambiguous = true},
["AT"] = {expansion = "agent trigger", wikipage = "austronesian alignment"},
["ATTR"] = {expansion = "attributive", wikipage = "Attributive"},
["ATT"] = {expansion = "attenuative", wikipage = "attenuative", ambiguous = true},
["AUD"] = {expansion = "auditory evidential", wikipage = "evidentiality"},
["AUG"] = {expansion = "augmentative", wikipage = "augmentative"},
["AUX"] = {expansion = "auxiliary verb", wikipage = "auxiliary verb"},
["AV"] = {expansion = "agent voice", wikipage = "agent voice"},
["B"] = {expansion = "core benefactive", wikipage = "benefactive case"},
["BE"] = {expansion = "'be' verb", wikipage = "be verb"},
["BEN"] = {expansion = "benefactive case ('for')", wikipage = "benefactive case"},
["C"] = {expansion = "common gender", wikipage = "common gender", ambiguous = true},
["CAP"] = {expansion = "capability", wikipage = ""},
["CAU"] = {expansion = "causative", wikipage = "causative"},
["CAUS"] = {expansion = "causative", wikipage = "causative"},
["CENT"] = {expansion = "centric case", wikipage = "centric case"},
["CF"] = {expansion = "counterfactual conditional", wikipage = "counterfactual conditional"},
["CIRC"] = {expansion = "circumfix", wikipage = "circumfix"},
["CIT"] = {expansion = "citation form", wikipage = "citation form"},
["CL"] = {expansion = "classifier", wikipage = "classifier (linguistics)"},
["CLF"] = {expansion = "classifier", wikipage = "classifier (linguistics)"},
["CNJ"] = {expansion = "conjunction", wikipage = "conjunction (grammar)"},
["CNSQ"] = {expansion = "consequential mood", wikipage = "consequential mood"},
["COL"] = {expansion = "collective number", wikipage = "collective number"},
["COM"] = {expansion = "comitative case ('together with')", wikipage = "comitative case"},
["COMP"] = {expansion = "comparative", wikipage = "comparative", ambiguous = true},
["COMPL"] = {expansion = "completive aspect", wikipage = "completive aspect"},
["CPL"] = {expansion = "completive aspect", wikipage = "completive aspect"},
["CONC"] = {expansion = "concessive", wikipage = "concessive"},
["COND"] = {expansion = "conditional mood", wikipage = "conditional mood"},
["CONJ"] = {expansion = "conjunction", wikipage = "conjunction (grammar)"},
["CONN"] = {expansion = "connective", wikipage = "connective particle"},
["CONT"] = {expansion = "continuous aspect", wikipage = "continuous aspect", ambiguous = true},
["CTN"] = {expansion = "continuous aspect", wikipage = "continuous aspect", ambiguous = true},
["CNTR"] = {expansion = "contrastive", wikipage = "contrast (linguistics)"},
["COP"] = {expansion = "copula", wikipage = "copula (linguistics)"},
["COR"] = {expansion = "coreference", wikipage = "coreference"},
["CRAS"] = {expansion = "crastinal tense ('tomorrow')", wikipage = "crastinal tense"},
["CRS"] = {expansion = "current relevance marker", wikipage = "current relevance (grammar)"},
["CVB"] = {expansion = "converb", wikipage = "converb"},
["D"] = {expansion = "core dative case", wikipage = "dative case"},
["DAT"] = {expansion = "dative case", wikipage = "dative case"},
["DE"] = {expansion = "different event", wikipage = ""},
["DEC"] = {expansion = "declarative mood", wikipage = "declarative mood"},
["DECL"] = {expansion = "declarative mood", wikipage = "declarative mood"},
["DEF"] = {expansion = "definite", wikipage = "definite"},
["DEI"] = {expansion = "deictic", wikipage = "deictic"},
["DEIX"] = {expansion = "deictic", wikipage = "deictic"},
["DEL"] = {expansion = "delative case ('off of')", wikipage = "delative case", ambiguous = true},
["DEM"] = {expansion = "demonstrative", wikipage = "demonstrative"},
["DEO"] = {expansion = "deontic mood", wikipage = "deontic mood"},
["DEP"] = {expansion = "dependent", wikipage = ""},
["DES"] = {expansion = "desiderative mood", wikipage = "desiderative mood"},
["DESI"] = {expansion = "desiderative mood", wikipage = "desiderative mood"},
["DEST"] = {expansion = "destinative aspect", wikipage = "destinative aspect"},
["DET"] = {expansion = "determiner", wikipage = "determiner"},
["DETR"] = {expansion = "detransitive", wikipage = "detransitive"},
["DH"] = {expansion = "motion downhill, seaward", wikipage = ""},
["DIM"] = {expansion = "diminutive", wikipage = "diminutive"},
["DIR"] = { ambiguous = true}, --direct case? direct speech? directional?
["DISJ"] = {expansion = "disjunction", wikipage = "disjunction"},
["DIST"] = {expansion = "distal", wikipage = "distal demonstrative"},
["DISTR"] = {expansion = "distributive case", wikipage = "distributive case"},
["DITR"] = {expansion = "ditransitive", wikipage = "ditransitive"},
["DLM"] = {expansion = "delimited", wikipage = ""},
["DM"] = {expansion = "discourse marker", wikipage = "discourse marker"},
["DO"] = {expansion = "direct object", wikipage = "direct object"},
["DR"] = {expansion = "motion downriver", wikipage = ""},
["DS"] = {expansion = "different-subject", wikipage = "switch-reference"},
["DU"] = {expansion = "dual number", wikipage = "Dual (grammatical number)"},
["DUB"] = {expansion = "dubitative mood", wikipage = "dubitative mood"},
["DUR"] = {expansion = "durative aspect", wikipage = "durative aspect"},
["DY"] = {expansion = "dyadic", wikipage = "dyadic kinship term"},
["DYAD"] = {expansion = "dyadic", wikipage = "dyadic kinship term"},
["DYN"] = {expansion = "dynamic aspect", wikipage = "dynamic aspect"},
["E"] = {expansion = "epenthetic morpheme", wikipage = "epenthesis"},
["ELA"] = {expansion = "elative case ('out of')", wikipage = "elative case"},
["EMP"] = {expansion = "emphatic", wikipage = ""},
["EMPH"] = {expansion = "emphatic", wikipage = ""},
["EPIS"] = {expansion = "epistemic mood/modality", wikipage = "epistemic modality"},
["ERG"] = {expansion = "ergative case", wikipage = "ergative case"},
["ESS"] = {expansion = "essive case", wikipage = "essive case"},
["EV"] = {expansion = "evidential", wikipage = "evidential"},
["EVID"] = {expansion = "evidential", wikipage = "evidential"},
["EVIT"] = {expansion = "evitative case", wikipage = "evitative case"},
["EX"] = {expansion = "exclusive person", wikipage = "clusivity"},
["EXCL"] = {expansion = "exclusive person", wikipage = "clusivity"},
["EXCLAM"] = {expansion = "exclamative", wikipage = "exclamative"},
["EXESS"] = {expansion = "exessive case", wikipage = "exessive case"},
["EXH"] = {expansion = "exhortative", wikipage = "exhortative"},
["EXIST"] = {expansion = "existential ('there is')", wikipage = "existential clause"},
["EXO"] = {expansion = "exocentric", wikipage = "exocentric case"},
["EXP"] = {expansion = "experiential, or experiencer", wikipage = "", ambiguous = true}, --experiental evidential, experiential aspect, experiencer
--["EXPER"] = {expansion = "experiential evidential", wikipage = "evidentiality"},
["EXPL"] = {expansion = "expletive/dummy", wikipage = "Syntactic expletive"},
["F"] = {expansion = "feminine gender", wikipage = "feminine gender"},
["FEM"] = {expansion = "feminine gender", wikipage = "feminine gender"},
["FACT"] = {expansion = "factive evidential", wikipage = "evidentiality"},
["FAM"] = {expansion = "familiar register", wikipage = ""},
["FIN"] = {expansion = "finite", wikipage = "finite verb"},
["FOC"] = {expansion = "focus", wikipage = "focus (grammar)"},
["FORM"] = {expansion = "formal register", wikipage = ""},
["FP"] = {expansion = "final particle", wikipage = ""},
["FR"] = {expansion = "frequentative", wikipage = "frequentative"},
["FREQ"] = {expansion = "frequentative", wikipage = "frequentative"},
["FMR"] = {expansion = "former, deceased", wikipage = ""},
["FPL"] = {expansion = "feminine plural", wikipage = ""},
["FSG"] = {expansion = "feminine singular", wikipage = ""},
["FUT"] = {expansion = "future tense", wikipage = "future tense"},
["GEN"] = {expansion = "genitive case", wikipage = "genitive case"},
["GER"] = {expansion = "gerund", wikipage = "gerund"},
["GNO"] = {expansion = "gnomic", wikipage = "Gnomic aspect"},
["GT"] = {expansion = "goal trigger", wikipage = "austronesian alignment"},
["HAB"] = {expansion = "habitual aspect", wikipage = "habitual aspect"},
["HBL"] = {expansion = "humble register", wikipage = ""},
["HEST"] = {expansion = "hesternal tense ('yesterday')", wikipage = "hesternal tense"},
["HIST"] = {expansion = "hitorical", wikipage = ""},
["HOD"] = {expansion = "hodiernal tense ('today')", wikipage = "hodiernal tense"},
["HON"] = {expansion = "honorific", wikipage = "honorifics (linguistics)"},
["HORT"] = {expansion = "hortative", wikipage = "hortative"},
["HSY"] = {expansion = "hearsay", wikipage = ""},
["HUM"] = {expansion = "human/anthropic gender", wikipage = "", ambiguous = true},
["HYP"] = {expansion = "hypothetical mood", wikipage = "hypothetical mood"},
["I"] = {expansion = "", wikipage = "", ambiguous = true}, -- "inflected" or "class I"?
["ID"] = {expansion = "identical", wikipage = ""},
["IDENTIF"] = {expansion = "identifiable", wikipage = ""},
["IDEO"] = {expansion = "ideophone", wikipage = "ideophone"},
["IGNOR"] = {expansion = "ignorative", wikipage = "ignorative"},
["II"] = {expansion = "class II", wikipage = "Noun class"},
["III"] = {expansion = "class III", wikipage = "Noun class"},
["ILL"] = {expansion = "illative case ('into')", wikipage = "illative case"},
["IMM"] = {expansion = "immediate", wikipage = ""},
["IMP"] = {expansion = "imperative mood", wikipage = "imperative mood"},
["IMPERF"] = {expansion = "imperfect", wikipage = "imperfect"},
["IMPR"] = {expansion = "imprecative mood", wikipage = "imprecative mood"},
["IMPREC"] = {expansion = "imprecative mood", wikipage = "imprecative mood"},
["IMPRS"] = {expansion = "impersonal", wikipage = "impersonal"},
["IN"] = {expansion = "inclusive person", wikipage = "clusivity"},
["INCL"] = {expansion = "inclusive person", wikipage = "clusivity"},
["INAL"] = {expansion = "inalienable possession", wikipage = "inalienable possession"},
["INAN"] = {expansion = "inanimate gender", wikipage = "inanimate gender"},
["INCH"] = {expansion = "inchoative aspect", wikipage = "inchoative aspect"},
["INCHO"] = {expansion = "inchoative aspect", wikipage = "inchoative aspect"},
["INCEP"] = {expansion = "inceptive aspect", wikipage = "inceptive aspect"},
["INCL"] = {expansion = "inclusive person", wikipage = "clusivity"},
["IND"] = {expansion = "indicative mood", wikipage = "indicative mood"},
["INDF"] = {expansion = "indefinite", wikipage = "definiteness"},
["INDEF"] = {expansion = "indefinite", wikipage = "definiteness"},
["INE"] = {expansion = "inessive case ('in')", wikipage = "inessive case"},
["INF"] = {expansion = "infinitive", wikipage = "infinitive"},
["INFER"] = {expansion = "inferential", wikipage = "inferential mood"},
["INFR"] = {expansion = "inferential", wikipage = "inferential mood"},
["INEL"] = {expansion = "inelative case ('from within')", wikipage = "inelative case"},
["INS"] = {expansion = "instrument(al)", wikipage = ""}, --instrument, instrumental case, instrumental marking on verb?
["INST"] = {expansion = "instrument(al)", wikipage = ""},
["INSTR"] = {expansion = "instrument(al)", wikipage = ""},
["INT"] = {expansion = "intensifier", wikipage = "intensifier", ambiguous = true},
["INTEN"] = {expansion = "intentional", wikipage = ""},
["INTERR"] = {expansion = "interrogative", wikipage = "interrogative"},
["INTR"] = {expansion = "intransitive", wikipage = "intransitive", ambiguous = true},
["NTR"] = {expansion = "intransitive", wikipage = "intransitive", ambiguous = true},
["INV"] = {expansion = "inverse", wikipage = "inversion (linguistics)"},
["IO"] = {expansion = "indirect object", wikipage = "indirect object"},
["IPFV"] = {expansion = "imperfective aspect", wikipage = "imperfective aspect"},
["IRR"] = {expansion = "irrealis mood", wikipage = "irrealis mood"},
["IS"] = {expansion = "indirect speech", wikipage = "indirect speech"},
["IT"] = {expansion = "instrument trigger", wikipage = "Austronesian alignment"},
["ITER"] = {expansion = "iterative aspect", wikipage = "iterative aspect"},
["IV"] = {expansion = "class IV", wikipage = "Noun class"},
["IX"] = {expansion = "class IX", wikipage = "Noun class"},
["JUS"] = {expansion = "jussive mood", wikipage = "jussive mood"},
["L2"] = {expansion = "second language", wikipage = ""},
["LAT"] = {expansion = "lative case", wikipage = "lative case"},
["LD"] = {expansion = "locative case + directional", wikipage = ""},
["LK"] = {expansion = "linker", wikipage = ""},
["LOC"] = {expansion = "locative case", wikipage = "locative case"},
["LOG"] = {expansion = "logophoric", wikipage = "logophoric"},
["LT"] = {expansion = "locative trigger", wikipage = "Austronesian alignment"},
["M"] = {expansion = "masculine gender", wikipage = "masculine gender"},
["MASC"] = {expansion = "masculine gender", wikipage = "masculine gender"},
["MAN"] = {expansion = "manner", wikipage = ""},
["MID"] = {expansion = "middle voice", wikipage = "middle voice"},
["MIM"] = {expansion = "mimetic", wikipage = "Linguistic mimesis"},
["MIR"] = {expansion = "mirative", wikipage = "mirative"},
["MLT"] = {expansion = "multiplicative case", wikipage = "multiplicative case"},
["MLTP"] = {expansion = "multiplicative case", wikipage = "multiplicative case"},
["MOD"] = {expansion = "mood/modal(ity)", wikipage = "Linguistic modality", ambiguous = true},
["MOM"] = {expansion = "single action verb", wikipage = ""},
["MPL"] = {expansion = "masculine plural", wikipage = ""},
["MSG"] = {expansion = "masculine singular", wikipage = ""},
["MVMT"] = {expansion = "movement", wikipage = ""},
["MVT"] = {expansion = "movement", wikipage = ""},
["MW"] = {expansion = "measure word", wikipage = "Measure word"},
["N"] = {expansion = "neuter gender", wikipage = "neuter gender"},
["NARR"] = {expansion = "narrative tense", wikipage = ""},
["NEUT"] = {expansion = "neuter gender", wikipage = "neuter gender"},
["NEG"] = {expansion = "negation/negative", wikipage = "Negative (linguistics)"},
["NF"] = {expansion = "non-finite", wikipage = "nonfinite verb"},
["NH"] = {expansion = "non-human", wikipage = "grammatical gender"},
["NMLZ"] = {expansion = "nominalizer/nominalization", wikipage = "nominalization"},
["NMZ"] = {expansion = "nominalizer/nominalization", wikipage = "nominalization"},
["NZ"] = {expansion = "nominalizer/nominalization", wikipage = "nominalization"},
["NOMI"] = {expansion = "nominalizer/nominalization", wikipage = "nominalization"},
["NOM"] = {expansion = "nominative case", wikipage = "nominative case"},
["NS"] = {expansion = "non-subject", wikipage = "", ambiguous = true}, --can also mean "neuter, singular"
["NTR"] = {expansion = "intransitive", wikipage = "intransitive (disambiguation)"},
["INTR"] = {expansion = "intransitive", wikipage = "intransitive (disambiguation)"},
["NUM"] = {expansion = "numeral", wikipage = "numeral (linguistics)"},
["O"] = {expansion = "patient-like argument (object) of canonical transitive verb", wikipage = "O (grammar)", ExcludeNegation = true},
["OBJ"] = {expansion = "object(ive)", wikipage = "object (grammar)", ambiguous = true},
["OB"] = {expansion = "object(ive)", wikipage = "object (grammar)", ambiguous = true},
["OBL"] = {expansion = "oblique case", wikipage = "oblique case"},
["OBV"] = {expansion = "obviative", wikipage = "obviative"},
["OPT"] = {expansion = "optative mood", wikipage = "optative mood"},
["P"] = {expansion = "patient-like argument of canonical transitive verb", wikipage = "P (grammar)", ExcludeNegation = true},
["PAS"] = {expansion = "passive voice", wikipage = "passive voice"},
["PASS"] = {expansion = "passive voice", wikipage = "passive voice"},
["PAST"] = {expansion = "past tense", wikipage = "past tense"},
["PAT"] = {expansion = "patient(ive)", wikipage = "Patient (grammar)"},
["PA"] = {expansion = "paucal number", wikipage = "paucal number"},
["PAU"] = {expansion = "paucal number", wikipage = "paucal number"},
["PEG"] = {expansion = "pegative case", wikipage = "pegative case"},
["PER"] = {expansion = "perlative case ('per', 'using')", wikipage = "perlative case"},
["PERF"] = {expansion = "perfect", wikipage = "perfect (grammar)"},
["PRF"] = {expansion = "perfect", wikipage = "perfect (grammar)"},
["PERS"] = {expansion = "personal", wikipage = ""},
["PFV"] = {expansion = "perfective aspect", wikipage = "perfective aspect"},
["PL"] = {expansion = "plural number", wikipage = "plural number"},
["PN"] = {expansion = "pronoun", wikipage = "pronoun"},
["PRO"] = {expansion = "pronoun", wikipage = "pronoun"},
["PO"] = {expansion = "primary object", wikipage = "primary object"},
["POL"] = {expansion = "polite register", wikipage = ""},
["POS"] = {expansion = "possessive marker", wikipage = "possessive"},
["POSS"] = {expansion = "possessive marker", wikipage = "possessive"},
["POST"] = {expansion = "postposition, postpositional case", wikipage = ""},
["POSTE"] = {expansion = "postessive case ('after')", wikipage = "postessive case"},
["POT"] = {expansion = "potential mood", wikipage = "potential mood"},
["PP"] = {expansion = "past/passive participle", wikipage = "participle"},
["PPP"] = {expansion = "past passive participle", wikipage = "past passive participle"},
["PPFV"] = {expansion = "past perfective", wikipage = "past perfective"},
["PR"] = {expansion = "proper noun", wikipage = "proper noun"},
["PRED"] = {expansion = "predicate/predicative", wikipage = "predicate (grammar)"},
["PREC"] = {expansion = "precative mood", wikipage = "precative mood"},
["PREP"] = {expansion = "preposition, prepositional case", wikipage = ""},
["PRESP"] = {expansion = "present participle", wikipage = "present participle"},
["PRET"] = {expansion = "preterite", wikipage = "preterite"},
["PRT"] = {expansion = "preterite", wikipage = "preterite"},
["PRIV"] = {expansion = "privative case", wikipage = "privative case"},
["PRS"] = {expansion = "present tense", wikipage = "present tense"},
["PRES"] = {expansion = "present tense", wikipage = "present tense"},
["PROB"] = {expansion = "probability", wikipage = ""},
["PROG"] = {expansion = "progressive aspect", wikipage = "progressive aspect"},
["PROH"] = {expansion = "prohibitive mood", wikipage = "prohibitive mood"},
["PROL"] = {expansion = "prolative case ('via')", wikipage = "prolative case"},
["PROP"] = {expansion = "propositive mood", wikipage = "propositive mood"},
["PROS"] = {expansion = "prosecutive case", wikipage = "prosecutive case"},
["PROSP"] = {expansion = "prospective aspect", wikipage = "prospective aspect"},
["PRSP"] = {expansion = "prospective aspect", wikipage = "prospective aspect"},
["PROT"] = {expansion = "protasis", wikipage = "protasis (linguistics)"},
["PROX"] = {expansion = "", wikipage = "", ambiguous = true}, --proximal or proximative?
["PST"] = {expansion = "past tense", wikipage = "past tense"},
["PT"] = {expansion = "patient trigger", wikipage = "Austronesian alignment"},
["PTCL"] = {expansion = "particle", wikipage = "particle (grammar)"},
["PTC"] = {expansion = "particle", wikipage = "particle (grammar)"},
["PTCP"] = {expansion = "participle", wikipage = "participle"},
["PCP"] = {expansion = "participle", wikipage = "participle"},
["PRTC"] = {expansion = "participle", wikipage = "participle"},
["PTV"] = {expansion = "partitive case ('some of')", wikipage = "partitive case"},
["PURP"] = {expansion = "purposive", wikipage = "Purposive case"},
["PV"] = {expansion = "patient voice", wikipage = "Patient voice"},
["Q"] = {expansion = "question word", wikipage = "question word"},
["QUOT"] = {expansion = "quotative", wikipage = "quotative"},
["R"] = {expansion = "", wikipage = "", ambiguous = true},
["REAL"] = {expansion = "realis mood", wikipage = "realis mood"},
["REC"] = {expansion = "recent past tense", wikipage = "recent past tense"},
["RECP"] = {expansion = "reciprocal voice", wikipage = "reciprocal voice"},
["REDUP"] = {expansion = "reduplication", wikipage = "Reduplication"},
["REF"] = {expansion = "referential", wikipage = "referential"},
["REFL"] = {expansion = "reflexive", wikipage = "reflexive pronoun", ambiguous = true},
["REL"] = {expansion = "relative(izer)", wikipage = "relativizer"},
["REM"] = {expansion = "remote past tense", wikipage = "remote past tense"},
["RES"] = {expansion = "", wikipage = "", ambiguous = true}, -- resultative. resumptive
["RET"] = {expansion = "retrospective", wikipage = "Retrospective (grammar)"},
["RFR"] = {expansion = "referential", wikipage = "referential"},
["S"] = {expansion = "single argument of canonical intransitive verb", wikipage = "S (grammar)"},
["SBJ"] = {expansion = "subject", wikipage = "subject (grammar)"},
["SUB"] = {expansion = "subject", wikipage = "subject (grammar)"},
["SU"] = {expansion = "subject", wikipage = "subject (grammar)"},
["SBJV"] = {expansion = "subjunctive mood", wikipage = "subjunctive mood"},
["SUBJ"] = {expansion = "subject", wikipage = "subject (grammar)"},
["SJV"] = {expansion = "subjunctive mood", wikipage = "subjunctive mood"},
["SE"] = {expansion = "same event", wikipage = ""},
["SEM"] = {expansion = "semelfactive aspect ('once')", wikipage = "semelfactive aspect"},
["SENS"] = {expansion = "sensory evidential", wikipage = "Sensory evidential"},
["SEQ"] = {expansion = "sequential", wikipage = ""},
["SG"] = {expansion = "singular number", wikipage = "Singular number", ExcludeNegation = true},
["SGV"] = {expansion = "singulative number", wikipage = "singulative number"},
["SS"] = {expansion = "same subject", wikipage = "Switch-reference"},
["STAT"] = {expansion = "stative", wikipage = "stative"},
["STV"] = {expansion = "stative", wikipage = "stative"},
["SUBR"] = {expansion = "subordinator", wikipage = "subordination (linguistics)"},
["SUBORD"] = {expansion = "subordinator", wikipage = "subordination (linguistics)"},
["SBRD"] = {expansion = "subordinator", wikipage = "subordination (linguistics)"},
["SR"] = {ambiguous = true}, -- ambiguous between "subordinator" and "switch reference"
["SUBE"] = {expansion = "subessive case ('under')", wikipage = "subessive case"},
["SUBL"] = {expansion = "sublative case ('onto', 'down onto')", wikipage = "sublative case"},
["SUC"] = {expansion = "successive", wikipage = ""},
["SUPE"] = {expansion = "superessive case ('on')", wikipage = "superessive case"},
["TAM"] = {expansion = "tense, aspect, or mood", wikipage = "tense–aspect–mood"},
["TEL"] = {expansion = "telic aspect", wikipage = "telic aspect"},
["TEMP"] = {expansion = "temporal case", wikipage = "temporal case"},
["TERM"] = {expansion = "terminative case", wikipage = "terminative case"},
["TNS"] = {expansion = "tense", wikipage = "Grammatical tense"},
["TOP"] = {expansion = "topic", wikipage = "topic (linguistics)"},
["TOT"] = {expansion = "totalitive", wikipage = "totalitive"},
["TR"] = {expansion = "transitive", wikipage = "Transitivity (grammar)"},
["TRANSL"] = {expansion = "translative case ('becoming')", wikipage = "translative case"},
["TRI"] = {expansion = "trial number", wikipage = "trial number"},
["TRN"] = {expansion = "transnumeral", wikipage = "transnumeral"},
["TVF"] = {expansion = "truth-value focus", wikipage = "truth-value focus"},
["U"] = {ambiguous = true}, -- uninflected, unmarked, undergoer, etc.
["UH"] = {expansion = "motion uphill, inland ", wikipage = ""},
["UND"] = {expansion = "undergoer", wikipage = ""},
["UR"] = {expansion = "motion upriver", wikipage = ""},
["USIT"] = {expansion = "usitative (for usual or typical events)", wikipage = ""},
["V"] = {expansion = "verb(al)", wikipage = ""},
["VB"] = {expansion = "verb(al)", wikipage = ""},
["VBZ"] = {expansion = "verbalizer", wikipage = "verbalizer"},
["VBLZ"] = {expansion = "verbalizer", wikipage = "verbalizer"},
["VD"] = {expansion = "verb, ditransitive", wikipage = "ditransitive verb"},
["VEN"] = {expansion = "venitive (coming towards)", wikipage = "andative and venitive"},
["VER"] = {expansion = "veridical", wikipage = "veridical", ambiguous = true},
["VIA"] = {expansion = "vialis case", wikipage = "vialis case"},
["VIS"] = {expansion = "visible, visual", wikipage = ""},
["VI"] = {expansion = "verb, intransitive", wikipage = "intransitive verb"},
["VII"] = {expansion = "class VII", wikipage = "Noun class"},
["VIII"] = {expansion = "class VIII", wikipage = "Noun class"},
["VN"] = {expansion = "verbal noun", wikipage = "verbal noun"},
["VOC"] = {expansion = "vocative case", wikipage = "vocative case"},
["VOL"] = {expansion = "volitive mood", wikipage = "volitive mood"},
["VT"] = {expansion = "verb, transitive", wikipage = "transitive verb"},
["WH.Q"] = {expansion = "wh-question", wikipage = "wh-question"},
["WH"] = {expansion = "wh-question", wikipage = "wh-question"},
["ZO"] = {expansion = "zoic gender", wikipage = "zoic gender"},
}
return {abbreviations = abbreviations}

Module:Interlinear

2024-04-05T21:09:41Z

Vaxjedi: Created page with "local p = {} local data = mw.loadData( 'Module:Interlinear/data' ) local gloss_override = {} -- for custom gloss abbreviations local getArgs = require('Module:Arguments').getArgs local yesno = require('Module:Yesno') local lang_data = mw.loadData( 'Module:Lang/data' ) -------------------------- -- Almost-global variables -------------------------- local glossing_type, displaying_messages, free_translation, msg, buffer ------------------- -- General settings -----------..."

local p = {}
local data = mw.loadData( 'Module:Interlinear/data' )
local gloss_override = {} -- for custom gloss abbreviations
local getArgs = require('Module:Arguments').getArgs
local yesno = require('Module:Yesno')
local lang_data = mw.loadData( 'Module:Lang/data' )

--------------------------
-- Almost-global variables
--------------------------
local glossing_type, displaying_messages, free_translation, msg, buffer

-------------------
-- General settings
-------------------
local conf = { --settings
WordSeparator = " \n\r\t", -- Don't replace with %s as this would include non-breaking spaces
GlossAbbrPattern = "^([Ø0-9A-Z]+)$", -- this isn't a full regex, but a Lua pattern
-- NOTE: The following characters must be formatted for use in a pattern set.
GlossAbbrBoundary = "-.,;:<>‹›/\\~+=%?%s%[%]()%_\127'",
GlossExcludeTable = {I = true,}, --strings not be treated as glossing abbreviations
GlossExcludePattern = '^[0-9][0-9]+$', -- excludes strings consisting entirely of digits
GlossSmallCapsExclude = "^[AOPS]$", -- glossing abbreviations matching this pattern will not be rendered in small caps
GlossingType = "label", -- if set to "label" gloss abbreviations are formatted as an <abbr> with the "label" appearing in a tooltip
-- if set to "wikilink" the abbreviation is formatted as a wikilink to the relevant wikipedia article
-- if set to "none" abbreviations aren't formatted at all
ErrorCategory = "[[Category:Pages with errors in interlinear text]]",
AmbiguousGlossCategory = "[[Category:Articles with ambiguous glossing abbreviations]]",
MessageGlossingError = "Error(s) in interlinear glossing",
combining_gender_numbers = "[0-9][0-9]?$", --e.g. G4 '4th gender' or CL7 'class 7'
combining_gender_prefixes = {G = "gender", CL = "class"},
combining_person = {["1"] = "first person", ["2"] = "second person", ["3"] = "third person"},
combining_number = {S = "singular", SG = "singular", P = "plural", PL = "plural", D = "dual", DU = "dual", TRI = "trial"},
combining_gender = {F = "feminine", M = "masculine", N = "neuter"},
LowerCaseGlosses = {["1sg"] = true, ["2sg"] = true, ["3sg"] = true, ["1du"] = true, ["2du"] = true, ["3du"] = true, ["1pl"] = true, ["2pl"] = true,
["3pl"] = true, ["Fsg"] = true, ["Fpl"] = true, ["Msg"] = true, ["Mpl"] = true,}, -- these are the non-all-upper-case strings that will be recognised as glossing abbreviations
ErrorHelpLocation = "Template:Interlinear",
}

---------------------
-- CSS styles and classes
---------------------
conf.style = { --CSS styles
WordDiv = "float: left; margin-bottom: 0.3em;",
WordMargin = "margin-right: 1em;",
WordP = "margin: 0px;", -- the style for the word <p> elements
GlossAbbr = "font-variant: small-caps; font-variant-numeric: oldstyle-nums; text-transform: lowercase; ", -- won't be applied to gloss abbreviations containing lower-case characters
HiddenText = "display: none;",
EndDiv = "clear: left; display: block;", -- style of the <div> element at the end of the interlinear display
ErrorMessage = "font-size: inherit",
}
conf.class = { --CSS classes
Interlinear = "interlinear",
GlossAbbr = "gloss-abbr",
GlossAbbrAmb = "gloss-abbr-ambiguous",
GlossAbbrError = "gloss-abbr-error",
ErrorMessage = "error",
}
---------------------
-- Section transclusion
---------------------
local page_content = nil -- lazy initilization
local function get_section(frame, section_name)
if page_content == nil then
local current_title = mw.title.getCurrentTitle()
page_content = current_title:getContent()
end
if page_content then
if mw.ustring.find(page_content, section_name, 1, true) then
return frame:preprocess('{{#section:{{FULLPAGENAME}}|' .. section_name .. '}}')
end
end
return ''
end
---------------------
-- Sundry small functions
---------------------
local function normalise(str)
return mw.ustring.gsub(str,"[" .. conf.WordSeparator .. "]+"," ")
end

local function tidyCss(str)
str = mw.ustring.gsub(str, '^[\"\']*(.-)[\"\']*$', "%1") -- trims quotation marks
if mw.ustring.sub(str, -1) ~= ";" then str = str .. ";" end -- appends ";" if missing
return str
end

local function highlight(text)
if text then
return '<span style="color:#C00;font-weight:bold;">' .. text .. '</span>'
else return "" end
end

local function tone_sup(str)
return mw.ustring.gsub(str, "([^%p%s0-9])([0-9]+)", "%1<sup>%2</sup>")
end

local function is_empty(str) -- returns "false" if its argument is a string containing chars other than spaces &c.
if not str then return true end
if mw.ustring.find(str, "[^" .. conf.WordSeparator .. "]")
then return false
else return true end
end

local function help_link (anchor)
if anchor then
return " ([[" .. conf.ErrorHelpLocation .. "#" .. anchor .. "|help]])"
else return "" end
end

-- the following is part of a trial implementation of automatic transliteration:
local function transliterate (str, lang_from, lang_to, scheme)
local lookup = {grc = {module = 'Module:Ancient Greek', funct = "transliterate", } }
if not lang_from then
msg:add("error", "Source language for transliteration is not set")
else
local t = lookup[lang_from]
if t then
local module = require(t.module)
return module[t.funct](str)
else msg:add("error", "Can't find transliterator for language '" .. lang_from .. "'")
end
end
return ""
end -- end of trial block

--------------------
-- The following two functions update the glossing settings based on the received
-- template arguments. set_global_glossing_settings() updates the global settings
-- that are valid for all gloss abbreviations. set_glossing_type()
-- returns the glossing type, which can vary between the different lines.
--------------------
local function set_global_glossing_settings(a)
local style = ""
if a.style then style = tidyCss(a.style) end
if a.underline == "no" then
style = style .. "text-decoration: none;" end
if a.small_caps == "no" then
style = style .. "font-variant:normal; text-transform: none;" end
if style ~= "" then conf.style.GlossAbbr = conf.style.GlossAbbr .. style end
end

local function set_glossing_type(glossing)
if glossing then
local GlossingType
glossing = mw.ustring.lower(mw.text.trim(glossing))
if mw.ustring.find(glossing, 'link') then
GlossingType = "wikilink"
elseif mw.ustring.find(glossing, 'label')
or mw.ustring.find(glossing, 'no link') then
GlossingType = 'label'
elseif mw.ustring.find(glossing, 'no abbr') then
GlossingType = "no abbr"
elseif yesno(glossing) == false then
GlossingType = nil
elseif yesno(glossing) then
GlossingType = conf.GlossingType
else
msg:add('error', 'Glossing type "' .. glossing .. '" not recognised') end
return GlossingType
else error("set_glossing_type: 'glossing' is nil or false", 2)
end
end

local function set_custom_glosses(list)
local abbs = mw.text.split(list, '[;\n\t]')
for _,v in pairs(abbs) do
local gloss = mw.text.split(v, ':')
local a = mw.text.trim(gloss[1])
if a and a ~= "" then
gloss_override[a] = {}
gloss_override[a].expansion = gloss[2]
gloss_override[a].wikipage = gloss[3]
end
end
end

---------------------
-- The UserMessages object contains and processes error messages and warnings
---------------------
local UserMessages = {errors = {}, warnings = {}, gloss_messages = {}}
function UserMessages:add(msgtype, text, gloss)
if msgtype == "gloss_message" then
self.gloss_messages[gloss] = text
elseif msgtype == "warning" then
table.insert(self.warnings, text)
elseif msgtype == "non-repeating error" then
self.errors.nre = text
elseif msgtype == "ambiguous gloss" then
self.if_ambiguous_glosses = true
elseif msgtype == "error" then
table.insert(self.errors, text)
else return error("UserMessages:add(): unknown message type", 2)
end
end
function UserMessages:print_errors()
local out = ""
local namespace = mw.title.getCurrentTitle().namespace
if next(self.errors) or self.warnings[1] then
local err_span = mw.html.create("span")
err_span:attr("style", conf.style.ErrorMessage)
err_span:addClass(conf.class.ErrorMessage)
for _,v in pairs(self.errors) do
err_span:wikitext(" " .. v .. ";") end
if namespace % 2 == 0 and namespace ~= 2 -- non-talk namespaces, excluding user pages; if modifying please update the description on the category page
then err_span:wikitext(conf.ErrorCategory)
end
out = tostring(err_span)
mw.addWarning(conf.MessageGlossingError)
end
if self.if_ambiguous_glosses then
if namespace == 0 -- article namespace
then out = out .. conf.AmbiguousGlossCategory -- this category will only track articles
end
end
return out
end
function UserMessages:print_warnings()
local out = ""
-- Messages and warnings get displayed only if the page is being viewed in "preview" mode:
if displaying_messages and (next(self.gloss_messages) or next(self.warnings)) then
local div = mw.html.create("div")
div:addClass("interlinear-preview-warning")
:cssText('border: 1px solid #a2a9b1; background-color: #f8f9fa; width: 80%; padding: 0.2em;')
:wikitext("<i>This message box is shown only in preview:</i>")
:newline()
for _,v in ipairs(self.warnings) do
local p = div:tag("p")
p:addClass(conf.class.ErrorMessage)
p:attr("style", conf.style.ErrorMessage)
p:wikitext(v)
end
if self.gloss_messages then
div:wikitext("<p> To change any of the following default expansions, see [[Template:Interlinear/doc#Custom abbreviations|the template's documentation]]:</p>")
end
for _,v in pairs(self.gloss_messages) do
div:wikitext("<p>" .. v .. "</p>")
end
out = out .. "\n\n" .. tostring(div)
end
return out
end

---------------------
-- gloss_lookup() receives a gloss abbreviation and tries to uncover its meaning.
---------------------
local function gloss_lookup(a, label, wikilink)
local _label, _wikilink, _lookup, source = nil, nil, nil, nil
if gloss_override[a] then
_lookup = gloss_override[a]
source = "local"
elseif data.abbreviations[a] then _lookup = data.abbreviations[a] end
if _lookup and _lookup.expansion ~= "" then
_label, _wikilink = _lookup.expansion, _lookup.wikipage
else
local prefix = mw.ustring.sub(a,1,1)
local suffix = mw.ustring.sub(a,2)
if conf.combining_person[prefix] then -- is it of the form 1PL or 3FS?
_label = conf.combining_person[prefix]
local _suffix = conf.combining_number[suffix] or conf.combining_gender[suffix]
if _suffix then
_label = _label .. ", " .. _suffix
else
local suffix1 = mw.ustring.sub(suffix,1,1)
local suffix2 = mw.ustring.sub(suffix,2)
if conf.combining_gender[suffix1]
and conf.combining_number[suffix2] then
_label = _label .. ", " .. conf.combining_gender[suffix1] .. ", " .. conf.combining_number[suffix2]
else _label = nil end
end
elseif mw.ustring.match(suffix,conf.combining_gender_numbers) then -- cases like G4 = gender 4
local _i,_j = mw.ustring.find(a, conf.combining_gender_numbers)
local _pre = mw.ustring.sub(a, 1, _i - 1)
local _suff = mw.ustring.sub(a, _i)
if conf.combining_gender_prefixes[_pre] then
_label = conf.combining_gender_prefixes[_pre] .. " " .. _suff
end
elseif prefix == "N" then -- dealing with cases like NPST = non-past
local s = gloss_override[suffix] or data.abbreviations[suffix]
if s ~= nil and not s.ExcludeNegation then
_label = "non-" .. s.expansion
_wikilink = s.wikipage
end
s = nil
end
end
if _label == "" then _label = nil end
if _wikilink == "" then _wikilink = nil end
if not label then label = _label end
if not wikilink then wikilink = _wikilink end
return label, wikilink, source
end

---------------------
-- format_gloss() calls gloss_lookup() to find the meaning of a gloss
-- abbreviation, which it then proceeds to format
---------------------
local function format_gloss(gloss, label, wikilink)
if string.sub(gloss,1,3) == "000" then -- checks for a common component of exposed strip markers (see [[:mw:Strip marker]])
return gloss
end
local gloss2 = mw.ustring.gsub(gloss,"<.->","") -- remove any html fluff
gloss2 = mw.ustring.gsub(gloss2, "%'%'+", "") -- remove wiki bold/italic formatting
gloss2 = mw.text.trim(mw.ustring.upper(gloss2))
if not (label or wikilink)
or (not label and glossing_type == "label")
or (not wikilink and glossing_type == "wikilink")
then
if glossing_type ~= "no abbr"
then label, wikilink, source = gloss_lookup(gloss2, label, wikilink)
end
end
local gloss_node
if glossing_type == "no abbr"
then gloss_node = mw.html.create("span")
else gloss_node = mw.html.create("abbr") end
gloss_node:addClass(conf.class.GlossAbbr)
if label or wikilink then
if not mw.ustring.match(gloss, "%l") -- excluding glosses that contain lower-case characters
and not mw.ustring.match(gloss,conf.GlossSmallCapsExclude) -- and also excluding A, O etc. from rendering in small caps
then gloss_node:attr("style", conf.style.GlossAbbr)
end
local abbr_label
if label then abbr_label = label
else abbr_label = wikilink end
gloss_node:attr("title", abbr_label)
if source ~= "local" and data.abbreviations[gloss2] then
if data.abbreviations[gloss2].ambiguous then
gloss_node:addClass(conf.class.GlossAbbrAmb)
msg:add("ambiguous gloss")
end
end
if glossing_type == "wikilink" and wikilink
then gloss_node:wikitext("[[", wikilink, "|" , gloss, "]]")
else gloss_node:wikitext(gloss) end
if source ~= "local" and displaying_messages then -- logging gloss lookups:
local message = ""
if label then
message = "assuming " .. gloss2 .. " means \"" .. abbr_label .. "\";" end
if glossing_type == "wikilink" and wikilink then
message = message .. " linking to [[" .. wikilink .. "]];"
end
msg:add("gloss_message", message, gloss)
end
elseif glossing_type == "no abbr"
then gloss_node
:attr("style", conf.style.GlossAbbr)
:wikitext(gloss)
else
if displaying_messages then
msg:add("warning", "Gloss abbreviation " .. highlight(gloss2) .. " not recognised" .. help_link("gloss abbr"))
end
msg:add("non-repeating error", "Unknown glossing abbreviation(s)" .. help_link("gloss abbr"))
gloss_node
:addClass(conf.class.GlossAbbrError)
:addClass("error")
:css("font-size", "100%")
:attr("title", gloss2 .. ": glossing abbreviation not found")
:attr("style", conf.style.ErrorMessage)
:wikitext(gloss)
end
return tostring(gloss_node)
end

---------------------
-- find_gloss() parses a word into morphemes, and it calls format_gloss()
-- for anything that looks like a glossing abbreviation.
---------------------
local function find_gloss(word)
local function scan_gloss(boundary, gloss_abbr) -- checks a morpheme if it is a gloss abbreviation
if (mw.ustring.match(gloss_abbr, conf.GlossAbbrPattern)
or conf.LowerCaseGlosses[gloss_abbr])
and not (conf.GlossExcludeTable[gloss_abbr]
or mw.ustring.match(gloss_abbr, conf.GlossExcludePattern))
then gloss_abbr = format_gloss(gloss_abbr)
end
return boundary .. gloss_abbr
end
local word = mw.text.decode(word, true)
if word == "I" -- for the case of the English word "I", the 1SG pronoun
then return word end
local pattern = "([" .. conf.GlossAbbrBoundary .. "]?)([^" .. conf.GlossAbbrBoundary .. "]+)"
word = mw.ustring.gsub(word, pattern, scan_gloss) -- splits into morphemes
return word
end

---------------------
-- The main purpose of the bletcherous parse() is to split a line into words and and then for each eligible word
-- to call find_gloss(). The parser outputs the individual words (with any gloss abbreviation formatting applied).
-- The simple job of splitting at whitespaces has been made complicated by a) the fact that the input can contain
-- whitespaces inside the various html elements that are the result of the application of various formatting templates;
-- and b) the need to be able to recognise the output of the template that formats custom gloss abbreviations
-- (and hence skip passing it on to find_gloss). See talk for a suggestion about its future.
---------------------
local function parse(cline, i, tags_found,ifglossing)

local function issue_error(message, culprit)
UserMessages:add("error", message .. ": ''" .. mw.ustring.sub(cline.whole, 1, i-1) .. "'''" .. culprit .. "'''''")
end
if i > cline.length then return i end --this will only be triggered if the current line has less words than line 1
local next_step, j, _, chunk
local probe = mw.ustring.sub(cline.whole,i,i)
if mw.ustring.match(probe,"[" .. conf.WordSeparator .. "]") and tags_found == 0
then next_step = i-1
elseif probe == "[" then --Wikilink?
if mw.ustring.sub(cline.whole,i+1,i+1) == "[" then
_,j,chunk = mw.ustring.find(cline.whole,"(%[%[.-%]%])", i)
else chunk = "["; j = i end --not a wikilink then
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
elseif probe == "{" and tags_found == 0 then --curly brackets enclose a sequence of words to be treated as a single unit
_,j,chunk = mw.ustring.find(cline.whole,"(.-)(})", i+1)
if not chunk then
issue_error("Unclosed curly bracket", "{")
chunk = highlight("{"); j = i
elseif ifglossing==true then
chunk = find_gloss(chunk)
else
if cline.tone_sup then chunk = tone_sup(chunk) end
end
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
elseif probe == "<" then -- We've encountered an HTML tag. What do we do now?
local _,j,chunk = mw.ustring.find(cline.whole,"(<.->)",i)
if not chunk then
issue_error("Unclosed angle bracket", "<")
chunk = highlight("<"); j = i
elseif mw.ustring.sub(cline.whole,i,i+1) == "</" then -- It's a CLOSING tag
if cline.glossing
and ifglossing==false
and mw.ustring.match(chunk,"</abbr>")
then ifglossing=true end
tags_found = tags_found - 1
elseif not mw.ustring.match(chunk, "/>$") -- It's an OPENING tag, unless it opens a self-closing element (in which case the element is ignored)
then if ifglossing == true -- the following checks for the output of {{ggl}}:
and mw.ustring.find(chunk, conf.class.GlossAbbr, 1, true) -- it's important that the "find" function uses literal strings and not patterns
then ifglossing = false end
tags_found = tags_found + 1
end
buffer = buffer .. chunk
next_step = parse(cline, j+1,tags_found,ifglossing)
else -- No HTML tags, so we only need to find where the word ends
local _,k,chunk = mw.ustring.find(cline.whole,"(..-)([ <[])",i)
if k then --ordinary text
if ifglossing==true then
buffer = buffer .. find_gloss(chunk)
else
if cline.tone_sup then chunk = tone_sup(chunk) end
buffer = buffer .. chunk
end
next_step = parse(cline, k, tags_found, ifglossing)
else -- reached end of string
if ifglossing == true then
chunk = find_gloss(mw.ustring.sub(cline.whole,i))
else
chunk = mw.ustring.sub(cline.whole,i)
if cline.tone_sup then chunk = tone_sup(chunk) end
end
buffer = buffer .. chunk
next_step = cline.length
end
end
return next_step
end
--------------------
-- The following function is called by Template:gcl and is used for formatting an individual glossing abbreviation
--------------------
function p.gcl(frame)
local args = getArgs(frame,{
trim = true,
removeBlanks = false,
parentOnly = true,
wrappers = {'Template:Gcl'},
})
msg = UserMessages
set_global_glossing_settings{style = args.style, underline = args.underline, small_caps = args['small-caps']}
if not args.glossing then
glossing_type = conf.GlossingType -- a global variable
else glossing_type = set_glossing_type(args.glossing)
end
local gloss, label, wikilink = args[1], args[2], args[3]
if not gloss then UserMessages:add("error", "No gloss supplied")
return UserMessages:print() end
if wikilink and not args.glossing then -- if a wikilink is supplied and glossing isn't set to 'label'...
glossing_type = 'wikilink' end -- .. then the wikilink will be formatted as such
if label == "" then label = nil end
if wikilink == "" then wikilink = nil end
local result = format_gloss(gloss, label, wikilink)
return result
end

--------------------
-- The following is the function called by Template:Interlinear.
-- It processes the template arguments, then calls parse() to split the input lines into words
-- and it then builds the output html.
--------------------
function p.interlinearise(frame)
---------------------
-- Prepare arguments
---------------------
local if_auto_translit = false
local args = getArgs(frame, { -- configuration for Module:Arguments
trim = true,
removeBlanks = false,
parentFirst = true,
wrappers = {'Template:Interlinear', 'Template:Fs interlinear'},
})
local template_name = frame:getParent():getTitle()
if template_name == 'Template:Fs interlinear' then
args.italics1 = args.italics1 or "no"
args.italics2 = args.italics2 or "yes"
args.glossing3 = args.glossing3 or "yes"
if args.lang and not args.lang2 then args.lang2 = args.lang .."-Latn" end
if args.transl and not args.transl2 then args.transl2 = args.transl end
if_auto_translit = true

end
local revid = frame:preprocess( "{{REVISIONID}}" )
if revid == "" then
if not args['display-messages'] or yesno(args['display-messages']) then
displaying_messages = true end-- messages will be displayed only in preview mode
end
msg = UserMessages
local line = {}

local function set_italics(n)
line[n].attr.style = line[n].attr.style .. "font-style: italic;"
line[n].tone_sup = true -- single digits are assumed to be tone markers and will hence be superscripted
if args['tone-superscripting'] and not yesno(args['tone-superscripting'])
then line[n].tone_sup = false end
end

if args.glossing then -- the glossing= parameter sets the default glossing type
local _gl = set_glossing_type(args.glossing)
if _gl then conf.GlossingType = _gl end
end
--this looks for a list of glossing abbreviations on the page that transcludes the template:
local _ablist_section = get_section(frame, 'list-of-glossing-abbreviations')
if _ablist_section and _ablist_section ~= "" then
local _a = mw.ustring.gsub(_ablist_section, '</?div [^\n]*>', '') -- strips off the div tags
set_custom_glosses(_a)
end
--and this looks looks for a list of abbreviations set within the template:
local _ablist = args.abbreviations
if _ablist and _ablist ~= ""
then set_custom_glosses(_ablist) end
local _ablist = args.ablist
if _ablist and _ablist ~= ""
then set_custom_glosses(_ablist) end

local _spacing = tonumber(args.spacing)
if _spacing and _spacing <= 20
then conf.style.WordDiv = conf.style.WordDiv .. 'margin-right: ' .. _spacing .. 'em;'
else conf.style.WordDiv = conf.style.WordDiv .. conf.style.WordMargin
end

local offset, last_line = 0, 0
for j,v in ipairs(args) do -- iterates over the unnamed parameters from the template
last_line = last_line +1
if is_empty(v)
then offset = offset + 1
else
local i = j - offset
line[i] = {}
v = normalise(v)

-- the following is part of a trial implementation of automatic transliteration:
if if_auto_translit and v == "auto" and i > 1 then
local source_line = line[i-1]
local src_lang = source_line.lang
if not src_lang then src_lang = args.lang end
if src_lang then
v = transliterate(source_line.whole, src_lang)
else v = ""; msg:add("error", "No language specified for automatic transliteration")
end
end -- end of trial block

line[i].whole = v
line[i].length = mw.ustring.len(v)

local _c = args["c" .. i]
if _c and _c ~= "" then
line.hasComments = true
line[i].c = _c
end

---prepare style arguments----
line[i].class = ""
local _style = args["style" .. i]
if not _style then _style = ""
else _style = tidyCss(_style) end
--line[i].attr holds the attributes for the <p> elements that enclose the words in line i
line[i].attr = {style = conf.style.WordP .. _style}

local _lang = args["lang" .. i]
if _lang and #_lang > 1 then
line[i].lang = _lang
else _lang = args.lang
if _lang and #_lang > 1 and i == 1 then -- if a lang= parameter is supplied, it's assumed to apply to line 1
line[i].lang = _lang
end
end
line[i].attr.lang = line[i].lang
--the following emulates the behaviour of {{Bo-textonly}} (see Template talk:Fs interlinear#Tibetan):
if template_name == 'Template:Fs interlinear' then
if _lang == "bo" and i == 1 then
line[1].class = line[1].class .. " uchen"
line[1].attr.style = line[1].attr.style .. "font-size:1.25em; word-wrap:break-word;"
end
end
--the following emulates the behaviour of {{Spell-nv}}:
if template_name == 'Template:Interlinear' then
if _lang == "nv" and i == 1 then
line[1].attr.style = line[1].attr.style .. "font-family: Aboriginal Sans, DejaVu Sans, Calibri, Arial Unicode MS, sans-serif;"
end
end

if yesno(args["italics" .. i]) then
set_italics(i)
end

local _transl = args["transl" .. i]
if _transl and #_transl > 1 then
_transl = mw.ustring.lower(_transl)
local _lookup = lang_data.translit_title_table[_transl]
if _lookup then
if _lang and _lookup[_lang] then
_transl = _lookup[_lang]
else _transl = _lookup.default
end
if _transl then
line[i].attr.title = _transl
end
else msg:add("error", "Transliteration scheme '" .. _transl .. "' not recognised")
end
end

local _glossing = args["glossing" .. i]
if _glossing then
line[i].glossing = set_glossing_type(_glossing)
-- Do not treat default glossing settings as custom.
if not ((i == 1 and not yesno(_glossing)) or (i == 2 and yesno(_glossing))) then
line.HasCustomGlossing = true
end
end

local _ipa = args['ipa' .. i]
if yesno(_ipa) then
line[i].class = "IPA"
end

local _class = args['class' .. i]
if _class then
line[i].class = line[i].class .. " " .. _class
end

if line[i].class == ""
then line[i].class = nil end
end -- ends the first if-statement in the loop
end -- ends the FOR cycle

local line_count = #line
if line_count == 0 then
msg:add("error", template_name .. ": no lines supplied.")
return msg:print_errors()
end

if line_count > 1 then
local _italics = args.italics
local n = tonumber(_italics)
if n and n > 0 then
set_italics(n)
elseif not (_italics and not yesno(_italics)) and not (args["italics1"] and not yesno(args["italics1"])) then
set_italics(1) -- by default, the first line will get italicised, unless italics=no or italics1=no
end
-- the last unnamed parameter is assumed to be the free translation:
free_translation = args[last_line]
if not is_empty(free_translation) then
line [line_count] = nil end --... and is thus excluded from interlinearising
end

-- If glossing isn't specified for any line, then it's chosen by default to occur
-- in the second line, unless only a single line has been supplied, in which case
-- the assumption is that it is the one containing grammatical glosses
if yesno(args.glossing) == false then
line.HasCustomGlossing = true
end
if not line.HasCustomGlossing then
if line_count == 1 then
line[1].glossing = conf.GlossingType
elseif line[2] then
line[2].glossing = conf.GlossingType
end
end
set_global_glossing_settings{style = args['glossing-style'], underline = args.underline, small_caps = args['small-caps']}

---------------------
-- Segment lines into words
---------------------
for i,v in ipairs(line) do
local ifglossing = false
if line[i].glossing then
ifglossing = true -- if true the parser will attempt to format gloss abbreviations in the current line
glossing_type = line[i].glossing -- neccessarily a global variable
end
local wc, n = 1, 1
line[i].words = {}
while n <= line[i].length do
buffer = ""
n = parse(line[i], n, 0, ifglossing)+2
line[i].words[wc] = buffer
wc = wc + 1
end
end

----Check for mismatches in number of words across lines----
local number_of_words, mismatch_found = 0, false
for i,v in ipairs(line) do -- find the maximum number of words in any line
local wc = #line[i].words
if wc ~= number_of_words then
if i ~= 1 and wc ~= 0 then
mismatch_found = true
end
if wc > number_of_words then
number_of_words = wc
end
end
end
----Deal with mismatches---
if mismatch_found then
local error_text = "Mismatch in the number of words between lines: "
for i,v in ipairs(line) do
local wc = #line[i].words
error_text = error_text .. wc .. " word(s) in line " .. i .. ", "
if wc ~= number_of_words then
for current_word = wc+1, number_of_words do
line[i].words[current_word] = " "
end
end
end
if string.sub(error_text, -2) == ", "
then error_text = string.sub(error_text, 1, #error_text - 2) .. " "
end
error_text = error_text .. help_link("mismatch")
UserMessages:add("error", error_text)
end

---------------------
-- Build the HTML
---------------------
---- If just a single line was supplied, format it as inline text
if line_count == 1 then
local span = mw.html.create('span')
span:attr(line[1].attr)
for wi = 1, number_of_words do
local space
if wi < number_of_words then space = " " else space = "" end
span:wikitext(line[1].words[wi] .. space)
end
return tostring(span)
end

---- More than one line supplied, so we'll produce interlinear display
local div = mw.html.create("div")
div:addClass(conf.class.Interlinear)

-- For stuff to be displayed in the left margin, like example numbering
local number, indent = nil, nil
if args.number and args.number ~= ""
then number = args.number end
if args.indent and args.indent ~=""
then indent = args.indent end
if indent or number then
if not indent then indent = "4" end --default value
div:css("margin-left", indent .. 'em')
if number then
div:tag("div")
:css("position", "absolute")
:css("left", "1em")
:wikitext(args.number)
end
end

if args.box and args.box ~= "" then
div:css("background-color", "#f8f9fa")
:css("border", "1px solid #eaecf0")
:css("padding", "1em") end
if args.top and args.top ~= "" then --lines to display above the interlinear block
div:tag("div")
:wikitext(args.top)
end

-- Producing the interlinear block
for wi = 1, number_of_words do
local div2 = div:tag("div")
:attr("style", conf.style.WordDiv)
for i,_ in ipairs (line) do
if line[i].whole ~= "" then -- skipping empty lines
local p = div2:tag("p")
p:attr(line[i].attr)
if line[i].class then
p:addClass(line[i].class)
end
local _text = line[i].words[wi]
if _text == "" or _text == " "
then _text = " " end -- <p> elements without content mess up the interlinear display
p:wikitext(_text)
end
end
end

--- If any "comments" have been specified, add them at the end of each line
if line.hasComments then
local divc = div:tag("div")
:attr("style", conf.style.WordDiv)
for i,_ in ipairs (line) do
local p = divc:tag("p")
p:attr("style", conf.style.WordP)
if line[i].c then
p:wikitext(line[i].c)
else p:wikitext(" ")
end
end
end

--Add hidden lines containing the content of each line of interlinear text: this is for accessibility
for i,v in ipairs(line) do
local hidden_line = div:tag("p")
hidden_line:attr("style", conf.style.HiddenText)
:wikitext(v.whole)
end

-- Format the free translation
local ft_line = div:tag("p")
if free_translation and free_translation ~= "" then
ft_line:attr("style", "clear: left;")
ft_line:wikitext(free_translation)
end
if args.bottom and args.bottom ~= ""
then local bottom = div:tag('p')
bottom:css('margin-top', '0')
bottom:wikitext(args.bottom)
end
ft_line:node(msg:print_errors()) -- for error messages

local end_div = div:tag("div")
end_div:attr("style", conf.style.EndDiv)
div:newline()
local temp_track = ""
if last_line == 2
then temp_track = "[[Category:Pages with interlinear glosses using two unnamed parameters]]"
end
if last_line > 3 and template_name ~= 'Template:Fs interlinear'
then temp_track = "[[Category:Pages with interlinear glosses using more than three unnamed parameters]]"
end
return tostring(div) .. temp_track .. msg:print_warnings()
end

return p

Module:Sond-roots/data

2024-03-17T21:12:35Z

Vaxjedi:

opers = {
["ini-basic"] = {
{ ["bh"] = "p",
["bs"] = "ps",
["dh"] = "t",
["ds"] = "ts",
["gh"] = "k",
["gs"] = "ks",
["hb"] = "hp",
["hd"] = "ht",
["hg"] = "hk",
["hz"] = "hs",
["kh"] = "k",
["lh"] = "l",
["mv"] = "mb",
["nv"] = "mb",
["nr"] = "nd",
["nl"] = "nd",
["ns"] = "nd",
["nz"] = "nd",
["ph"] = "p",
["rh"] = "r",
["sh"] = "s",
["th"] = "t",
["tz"] = "ts",
["vh"] = "f",
["zh"] = "s",
},
"12"},

["fin-basic"] = {
{ ["bh"] = "p",
["bs"] = "ps",
["dh"] = "t",
["ds"] = "ts",
["gh"] = "k",
["gs"] = "ks",
["hb"] = "hp",
["hd"] = "ht",
["hg"] = "hk",
["hz"] = "hs",
["kh"] = "k",
["lh"] = "l",
["mv"] = "mb",
["nv"] = "mb",
["nr"] = "nd",
["nl"] = "nd",
["ns"] = "nd",
["nz"] = "nd",
["ph"] = "p",
["rh"] = "r",
["rz"] = "rs",
["sh"] = "s",
["th"] = "t",
["tz"] = "ts",
["vh"] = "f",
["zh"] = "s",
},
"12"},

["fin-e-1"] = {
{ ["m"]="en",
["w"]="u",
["y"]="i",
},
"e1"},

["fin-e-n"] = {
{ ["h"]="e",
["m"]="en",
["w"]="u",
["y"]="i",
["z"]="es",
},
"e1"},

["fin-e-23"] = {
{ ["im"] = "en",
["in"] = "en",
["ym"] = "en",
["yn"] = "en",
["iz"] = "is",
["yz"] = "is",
["i2"] = "i2",
["y2"] = "i2",
["um"] = "on",
["un"] = "on",
["wm"] = "on",
["wn"] = "on",
["uz"] = "us",
["wz"] = "us",
["u2"] = "u2",
["w2"] = "u2",
},
function (str1,str2) return "e"..export.replace("fin-basic",str1,str2) end },

["fin-e-12"] = {
{ ["a2"] = "a2",
["im"] = "en",
["in"] = "en",
["ym"] = "en",
["yn"] = "en",
["iz"] = "is",
["yz"] = "is",
["i2"] = "i2",
["y2"] = "i2",
["um"] = "on",
["un"] = "on",
["wm"] = "on",
["wn"] = "on",
["uz"] = "us",
["wz"] = "us",
["u2"] = "u2",
["w2"] = "u2",
},
function (str1,str2) return "e"..export.replace("fin-basic",str1,str2) end },

["fin-o"] = {
{["h"] = "o",
["m"] = "on",
["w"] = "u",
["y"] = "e",
["z"] = "os",
},
"o1"},

["fin-a"] = {
{ ["a"] = "a",
["h"] = "a",
["m"] = "an",
["u"] = "o",
["w"] = "o",
["i"] = "e",
["y"] = "e",
["z"] = "as",
},
"a1"},

["fin-u"] = {
{ ["a"] = "aw",
["h"] = "u",
["m"] = "on",
["n"] = "on",
["u"] = "u",
["w"] = "u",
["i"] = "wi",
["y"] = "wi",
["z"] = "us",
},
"u1"},

["fin-ia"] = {
{ ["a"] = "a",
["h"] = "e",
["m"] = "en",
["n"] = "en",
["u"] = "u",
["w"] = "u",
["i"] = "i",
["y"] = "i",
["z"] = "es",
},
"e1"},

["fin-ix"] = {
{ ["a"] = "ya",
["h"] = "i",
["m"] = "en",
["n"] = "en",
["u"] = "yu",
["w"] = "yu",
["i"] = "i",
["y"] = "i",
["z"] = "is",
},
"e1"},

["vini-blank"] = {
{ ["a"] = "",
["i"] = "y",
["u"] = "w",
},
"1"},

["ini-prei"] = {
{ ["a"] = "",
["i"] = "",
["l"] = "d",
["r"] = "d",
["u"] = "w",
["y"] = "j",
},
"e1"},

} --end

return opers

Module:Sond-roots/data

2024-03-17T21:10:10Z

Vaxjedi:

Module:Sond-roots/data

2024-03-17T21:08:16Z

Vaxjedi:

Module:Sond-roots/data

2024-03-17T21:02:37Z

Vaxjedi:

Module:Test/data

2024-02-11T10:10:22Z

Vaxjedi:

2023-01-22T05:33:40Z

Vaxjedi:

==The Parable of the Baroness of the Emerald Reign==

The Emerald Reign covered the land like the drizzle of a gray day. The clouds were dark, as always, and the days were cold, as always. But hearths were warm and local trods were shielded both from cold winds and cold hearts. Thus was the legacy of the Baroness.

But it was not always thus. She who would become the Baroness, a noble sidhe of house unknown, found a city of flotsam fates and driftwood dreams. The dreams of the elements themselves washed this way and that, roared in storm and blew away just as quickly. The spirits of the dead raged silently behind their hidden walls. Thunderbirds hatched and roared into the sky, leaving destruction in their wake. Faceless terrors stalked through alley and wharf.

She beheld the sound and the fury, and she wept. She cried out to the winds, but they did not listen. She commanded the creatures in the sky to yield, but they paid no heed. She stamped on the graves of the fallen to force them to turn, but they cared not for the wrath of one of the quick.

She fell to her knees in the mud, exhausted and defeated, and she knew she was bereft. In desperation, she drew up the mud around her and formed it into a mound. And on the mound she drew a face, so that she would not be alone. And she cried to it, 'The world here eats itself, and soon there will be nothing left. Why will no one listen to me?'

And the mound said to her 'Though you are of noble blood, you do not rule here. The dreams are not your subjects. The wind and storm and waters do not bend knee to you. If you wish to command them, you must prove right of sovereignty.'

But she was not a warrior. She had no army. She said to her friend 'I cannot conquer the horrors in the streets. I cannot force the wind and the storm and the waters to submit.'

And the mound replied, 'I am but a mound of wet earth, but I do know that a sovereign does not rule alone. The crown is only as strong as the swords and hammers that are sworn to it.'

She smiled and said, 'You are wise, my muddy friend. You speak with the heart of a troll.' And with deft hands, she shaped the mound into a troll warrior. 'My hands are the hands of a sculptor,' she said. 'My gift is to give form where none was before. I shall carve and cast this place into a court of glory and renown, and my chisels shall be oath and fealty.' And her friend, now a troll, fell to one knee and swore his loyalty to her and her cause.

And thus was her path cut through the wilderness. She treated with the elements, and they joined her court. She spoke to the faceless horrors, and carved them faces in exchange for their hearts. The savage beasts, the thunderbirds, manticores, and the leviathans - those she won with perseverance and respect, until they too chose to bow before her.

With the land tamed, the kith came and found its undisputed liege, the Baroness, welcoming them to her realm. And in turn, they each bent their knee and swore loyalty to her and her crest upon which were etched the words "Fortitudo gladiis malleisque iuratis", which means 'Strength from sworn swords and hammers'.

Test

2022-10-25T02:42:51Z

Vaxjedi: Replaced content with "{{#vardefine:fnord|dronf}} {{#var:fnord}}"