local m_utilities = require("Module:utilities")
local m_links = require("Module:links")
local m_bit32 = require("bit32")
local export = {}
local lang = require("Module:languages").getByCode("fi")
-- Functions that do the actual inflecting by creating the forms of a basic term.
local inflections = {}
local show_kotus_gradations = true
local kotus_grad_type = {
["kk-k"] = "A",
["pp-p"] = "B",
["tt-t"] = "C",
["k-"] = "D",
["p-v"] = "E",
["t-d"] = "F",
["nk-ng"] = "G",
["mp-mm"] = "H",
["lt-ll"] = "I",
["nt-nn"] = "J",
["rt-rr"] = "K",
["k-j"] = "L",
["k-v"] = "M"
}
-- The main entry point.
-- This is the only function that can be invoked from a template.
function export.show(frame)
local infl_type = frame.args[1] or error("Inflection type has not been specified. Please pass parameter 1 to the module invocation")
local args = frame:getParent().args
local infl_types = {infl_type}
infl_types = mw.text.split(infl_type, "%-")
for _, type in ipairs(infl_types) do
if not inflections[type] then
error("Unknown inflection type '" .. infl_type .. "'")
end
end
local pos = args["pos"]; if not pos or pos == "" then pos = "noun" end
local allow_possessive = pos == "noun" or pos == "adj" and not args["noposs"]
-- initialize data for full inflection process
local data = {argpos = 1, num = 1, words = {}}
local argobj = {args = args, pos = 1}
local extra = ""
local poss_forms = {}
local vh = nil
for num, infl_type in ipairs(infl_types) do
-- initialize data for single word
local word_data = {forms = {}, title = nil, categories = {}}
-- word index
word_data.num = num
data.num = num
-- Generate the forms
inflections[infl_type](argobj, word_data)
postprocess_word(argobj, word_data, num == #infl_types)
word_data.class = infl_type
data["words"][num] = word_data
-- generate possessive forms (nom.sg. only)
if allow_possessive and not args["poss"] then
generate_possessive_forms(poss_forms, argobj, word_data, num == #infl_types)
end
end
if #(data["words"]) == 1 then
vh = data["words"][1]["vh"]
end
-- table
if allow_possessive and next(poss_forms) ~= nil then
extra = make_possessive_table(args, poss_forms, pos, infl_type)
end
-- join the inflected word components
export.join_words(data, args["space"] or " ")
-- Postprocess
postprocess(args, data)
if args["type"] then
table.insert(data.categories, "fi-decl with type")
end
if args["nocheck"] then
table.insert(data.categories, "fi-decl with nocheck")
end
if args["nosg"] then
table.insert(data.categories, "fi-decl with nosg")
end
if args["nopl"] then
table.insert(data.categories, "fi-decl with nopl")
end
return make_table(data, vh) .. extra .. m_utilities.format_categories(data.categories, lang)
.. require("Module:TemplateStyles")("Module:fi-nominals/style.css")
end
function get_params(argobj, num, invert_grades)
local params = {}
local args = argobj.args
local pos = argobj.pos
if num == 5 then
params.base = args[pos] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{1}}}"); if not params.base or params.base == "" then error("Parameter " .. tostring(pos) .. " (base stem) may not be empty.") end
params.strong = args[pos + 1] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{2}}}"); if not params.strong then error("Parameter " .. tostring(pos + 1) .. " (nominative grade) may not be omitted.") end
params.weak = args[pos + 2] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{3}}}"); if not params.weak then error("Parameter " .. tostring(pos + 2) .. " (genitive grade) may not be omitted.") end
params.final = args[pos + 3] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{4}}}"); if not params.final or params.final == "" then error("Parameter " .. tostring(pos + 3) .. " (final letter(s)) may not be empty.") end
params.a = args[pos + 4] or (mw.title.getCurrentTitle().nsText == "Template" and "a"); if params.a ~= "a" and params.a ~= "ä" then error("Parameter " .. tostring(pos + 4) .. " must be \"a\" or \"ä\".") end
elseif num == 4 then
params.base = args[pos] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{1}}}"); if not params.base or params.base == "" then error("Parameter " .. tostring(pos) .. " (base stem) may not be empty.") end
params.strong = args[pos + 1] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{2}}}"); if not params.strong then error("Parameter " .. tostring(pos + 1) .. " (nominative grade) may not be omitted.") end
params.weak = args[pos + 2] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{3}}}"); if not params.weak then error("Parameter " .. tostring(pos + 2) .. " (genitive grade) may not be omitted.") end
params.a = args[pos + 3] or (mw.title.getCurrentTitle().nsText == "Template" and "a"); if params.a ~= "a" and params.a ~= "ä" then error("Parameter " .. tostring(pos + 3) .. " must be \"a\" or \"ä\".") end
elseif num == 2 then
params.base = args[pos] or (mw.title.getCurrentTitle().nsText == "Template" and "{{{1}}}"); if not params.base or params.base == "" then error("Parameter " .. tostring(pos) .. " (base stem) may not be empty.") end
params.a = args[pos + 1] or (mw.title.getCurrentTitle().nsText == "Template" and "a"); if params.a ~= "a" and params.a ~= "ä" then error("Parameter " .. tostring(pos + 1) .. " must be \"a\" or \"ä\".") end
elseif num == 1 then
params.base = args[pos] or ""
end
-- Swap the grades
if invert_grades then
params.strong, params.weak = params.weak, params.strong
end
if params.a then
params.o = params.a == "ä" and "ö" or "o"
params.u = params.a == "ä" and "y" or "u"
end
argobj.pos = argobj.pos + num
return params
end
function get_extra_arg(argobj, wdata, name)
return argobj.args[name .. wdata.num] or argobj.args[name]
end
local make_weak = require("Module:fi-utilities").make_weak
--[=[
Inflection functions
]=]--
local stem_endings = {}
stem_endings["nom_sg"] = {
["nom_sg"] = "",
}
stem_endings["sg"] = {
["ess_sg"] = "na",
}
stem_endings["sg_weak"] = {
["gen_sg"] = "n",
["ine_sg"] = "ssa",
["ela_sg"] = "sta",
["ade_sg"] = "lla",
["abl_sg"] = "lta",
["all_sg"] = "lle",
["tra_sg"] = "ksi",
["ins_sg"] = "n",
["abe_sg"] = "tta",
["nom_pl"] = "t",
}
stem_endings["par_sg"] = {
["par_sg"] = "a",
}
stem_endings["ill_sg"] = {
["ill_sg"] = "Vn",
}
stem_endings["pl"] = {
["ess_pl"] = "na",
["com_pl"] = "ne",
}
stem_endings["pl_weak"] = {
["ine_pl"] = "ssa",
["ela_pl"] = "sta",
["ade_pl"] = "lla",
["abl_pl"] = "lta",
["all_pl"] = "lle",
["tra_pl"] = "ksi",
["ins_pl"] = "n",
["abe_pl"] = "tta",
}
stem_endings["par_pl"] = {
["par_pl"] = "a",
}
stem_endings["gen_pl"] = {
["gen_pl"] = "en",
}
stem_endings["ill_pl"] = {
["ill_pl"] = "Vn",
}
-- data for generating possessive forms
-- suffixes per person
local poss_forms = {["1s"] = "ni",
["2s"] = "si",
["3s"] = "nsa",
["1p"] = "mme",
["2p"] = "nne"}
local poss_forms_optimized = {
["00"] = "",
["3s"] = "nsa"}
local poss_alt = { ["00"] = false,
["1s"] = false,
["2s"] = false,
["3s"] = true, -- shorter form -Vn
["1p"] = false,
["2p"] = false}
-- which forms allow -nsa > -Vn?
local forms_alt_ok = {
["gen_sg"] = false, ["gen_pl"] = false,
["par_sg"] = false, ["par_pl"] = true,
["ine_sg"] = true, ["ine_pl"] = true,
["ela_sg"] = true, ["ela_pl"] = true,
["ill_sg"] = false, ["ill_pl"] = false,
["ade_sg"] = true, ["ade_pl"] = true,
["abl_sg"] = true, ["abl_pl"] = true,
["all_sg"] = true, ["all_pl"] = true,
["ess_sg"] = true, ["ess_pl"] = true,
["tra_sg"] = true, ["tra_pl"] = true,
["ins_sg"] = false, ["ins_pl"] = false,
["abe_sg"] = true, ["abe_pl"] = true,
["com_sg"] = true, ["com_pl"] = true,
}
-- which forms end in -n?
-- (in which case it is dropped before the possessive suffix)
local forms_gen_ok = {
["gen_sg"] = true, ["gen_pl"] = true,
["ill_sg"] = true, ["ill_pl"] = true,
["ins_sg"] = true, ["ins_pl"] = true,
}
-- Make a copy of the endings, with front vowels
stem_endings = {["a"] = stem_endings, ["ä"] = mw.clone(stem_endings)}
for stem_key, endings in pairs(stem_endings["ä"]) do
for key, ending in pairs(endings) do
endings[key] = mw.ustring.gsub(endings[key], "([aou])", {["a"] = "ä", ["o"] = "ö", ["u"] = "y"})
end
end
-- Create any stems that were not given
local function make_stems(data, stems)
if not stems["nom_sg"] and stems["sg"] then
stems["nom_sg"] = mw.clone(stems["sg"])
end
if not stems["par_sg"] and stems["sg"] then
stems["par_sg"] = mw.clone(stems["sg"])
end
if not stems["ill_sg"] and stems["sg"] then
stems["ill_sg"] = {}
for _, stem in ipairs(stems["sg"]) do
-- If the stem ends in a long vowel or diphthong, then add -h
if mw.ustring.find(stem, "([aeiouyäö])%1$") or mw.ustring.find(stem, "[aeiouyäö][iyü]$") then
table.insert(stems["ill_sg"], stem .. "h")
else
table.insert(stems["ill_sg"], stem)
end
end
end
if not stems["par_pl"] and stems["pl"] then
stems["par_pl"] = {}
for _, stem in ipairs(stems["pl"]) do
table.insert(stems["par_pl"], stem)
end
end
if not stems["gen_pl"] and stems["par_pl"] then
stems["gen_pl"] = {}
for _, stem in ipairs(stems["par_pl"]) do
-- If the partitive plural stem ends in -it, then replace the t with d or tt
if mw.ustring.find(stem, "it$") then
table.insert(stems["gen_pl"], (mw.ustring.gsub(stem, "t$", "d")))
table.insert(stems["gen_pl"], stem .. "t")
else
table.insert(stems["gen_pl"], stem)
end
end
end
if not stems["ill_pl"] and stems["pl"] then
stems["ill_pl"] = {}
for _, stem in ipairs(stems["pl"]) do
table.insert(stems["ill_pl"], stem)
end
end
end
-- Create forms based on each stem, by adding endings to it
local function process_stems(data, stems, vh)
if not stems["sg_weak"] and stems["sg"] then
stems["sg_weak"] = mw.clone(stems["sg"])
end
if not stems["pl_weak"] and stems["pl"] then
stems["pl_weak"] = mw.clone(stems["pl"])
end
-- Go through each of the stems given
for stem_key, substems in pairs(stems) do
for _, stem in ipairs(substems) do
-- Attach the endings to the stem
for form_key, ending in pairs(stem_endings[vh][stem_key]) do
if not data.forms[form_key] then
data.forms[form_key] = {}
end
-- "V" is a copy of the last vowel in the stem
if mw.ustring.find(ending, "V") then
local vowel = mw.ustring.match(stem, "([aeiouyäö])[^aeiouyäö]*$")
ending = mw.ustring.gsub(ending, "V", vowel or "?")
end
table.insert(data.forms[form_key], stem .. ending)
end
end
end
data["stems"] = stems
data["vh"] = vh
end
local function merge_stems(stems_a, stems_b)
local stems_m = {}
-- implying same keys for both stems
for stem_key, substems in pairs(stems_a) do
stems_m[stem_key] = mw.clone(substems)
for _, bstem in pairs(stems_b[stem_key] or {}) do
table.insert(stems_m[stem_key], bstem)
end
end
return stems_m
end
inflections["valo"] = function(args, data)
data.title = "[[Kotus]] 變格類型 1/[[Appendix:芬蘭語名詞變格/valo|valo]]"
table.insert(data.categories, "芬蘭語valo類名詞")
local params = get_params(args, 5)
make_weak(params.base, params.strong, params.final, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local wk_sg = params.weak
local wk_pl = params.weak
if mw.ustring.sub(params.base, -1) == params.final then
if wk_sg == "" and (mw.ustring.find(params.base, "[aeiouyäö][iuy]$") or mw.ustring.find(params.base, "[iuy][eoö]$")) then
wk_sg = "’"
end
if wk_pl == "" then
wk_pl = "’"
end
end
local stems = {}
stems["sg"] = {params.base .. params.strong .. params.final}
stems["sg_weak"] = {params.base .. wk_sg .. params.final}
stems["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems["pl_weak"] = {params.base .. wk_pl .. params.final .. "i"}
stems["par_pl"] = {params.base .. params.strong .. params.final .. "j"}
stems["ill_pl"] = {params.base .. params.strong .. params.final .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["palvelu"] = function(args, data)
data.title = "[[Kotus]] 變格類型 2/[[Appendix:芬蘭語名詞變格/palvelu|palvelu]],無層級變化"
table.insert(data.categories, "芬蘭語palvelu類名詞")
local params = get_params(args, 2)
local stems = {}
stems["sg"] = {params.base}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "j", params.base .. "it"}
stems["ill_pl"] = {params.base .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["valtio"] = function(args, data)
data.title = "[[Kotus]] 變格類型 3/[[Appendix:芬蘭語名詞變格/valtio|valtio]],無層級變化"
table.insert(data.categories, "芬蘭語valtio類名詞")
local params = get_params(args, 2)
local final = mw.ustring.sub(params.base, -1)
local stems = {}
stems["sg"] = {params.base}
stems["par_sg"] = {params.base .. "t"}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "it"}
stems["ill_pl"] = {params.base .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["laatikko"] = function(args, data)
data.title = "[[Kotus]] 變格類型 4/[[Appendix:芬蘭語名詞變格/laatikko|laatikko]]"
table.insert(data.categories, "芬蘭語laatikko類名詞")
local params = get_params(args, 5, false, "kk", "k", "o")
make_weak(params.base, params.strong, params.final, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["sg"] = {params.base .. params.strong .. params.final}
stems["sg_weak"] = {params.base .. params.weak .. params.final}
stems["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems["pl_weak"] = {params.base .. params.weak .. params.final .. "i"}
stems["par_pl"] = {params.base .. params.strong .. params.final .. "j", params.base .. params.weak .. params.final .. "it"}
stems["ill_pl"] = {params.base .. params.strong .. params.final .. "ih", params.base .. params.weak .. params.final .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["risti"] = function(args, data)
data.title = "[[Kotus]] 變格類型 5/[[Appendix:芬蘭語名詞變格/risti|risti]]"
table.insert(data.categories, "芬蘭語risti類名詞")
local params = get_params(args, 4)
local i = get_extra_arg(args, data, "i"); if i == "0" then i = "" else i = "i" end
make_weak(params.base, params.strong, "i", params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.strong .. i}
stems["sg"] = {params.base .. params.strong .. "i"}
stems["sg_weak"] = {params.base .. params.weak .. "i"}
stems["pl"] = {params.base .. params.strong .. "ei"}
stems["pl_weak"] = {params.base .. params.weak .. "ei"}
stems["gen_pl"] = {params.base .. params.strong .. "i"}
stems["par_pl"] = {params.base .. params.strong .. "ej"}
stems["ill_pl"] = {params.base .. params.strong .. "eih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["paperi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 6/[[Appendix:芬蘭語名詞變格/paperi|paperi]],無層級變化"
table.insert(data.categories, "芬蘭語paperi類名詞")
local params = get_params(args, 2)
local i = get_extra_arg(args, data, "i"); if i == "0" then i = "" else i = "i" end
local stems = {}
stems["nom_sg"] = {params.base .. i}
stems["sg"] = {params.base .. "i"}
stems["pl"] = {params.base .. "ei"}
stems["par_pl"] = {params.base .. "eit", params.base .. "ej"}
stems["gen_pl"] = {params.base .. "i", params.base .. "eid", params.base .. "eitt"}
stems["ill_pl"] = {params.base .. "eih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["ovi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 7/[[Appendix:芬蘭語名詞變格/ovi|ovi]]"
table.insert(data.categories, "芬蘭語ovi類名詞")
local params = get_params(args, 4)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
make_weak(params.base, params.strong, "e", params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local wk_pl = params.weak
if mw.ustring.sub(params.base, -1) == "i" and params.strong == "k" and params.weak == "" then
wk_pl = "’"
end
local stems = {}
stems["nom_sg"] = {nom_sg or params.base .. params.strong .. "i"}
stems["sg"] = {params.base .. params.strong .. "e"}
stems["sg_weak"] = {params.base .. params.weak .. "e"}
stems["pl"] = {params.base .. params.strong .. "i"}
stems["pl_weak"] = {params.base .. wk_pl .. "i"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["nalle"] = function(args, data)
data.title = "[[Kotus]] 變格類型 8/[[Appendix:芬蘭語名詞變格/nalle|nalle]]"
table.insert(data.categories, "芬蘭語nalle類名詞")
local params = get_params(args, 4)
make_weak(params.base, params.strong, "e", params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["sg"] = {params.base .. params.strong .. "e"}
stems["sg_weak"] = {params.base .. params.weak .. "e"}
stems["pl"] = {params.base .. params.strong .. "ei"}
stems["pl_weak"] = {params.base .. params.weak .. "ei"}
stems["par_pl"] = {params.base .. params.strong .. "ej"}
stems["ill_pl"] = {params.base .. params.strong .. "eih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.strong .. "ein"}
end
inflections["kala"] = function(args, data)
data.title = "[[Kotus]] 變格類型 9/[[Appendix:芬蘭語名詞變格/kala|kala]]"
table.insert(data.categories, "芬蘭語kala類名詞")
local params = get_params(args, 4)
make_weak(params.base, params.strong, params.a, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local wk_sg = params.weak
if wk_sg == "" and mw.ustring.sub(params.base, -2) == params.a .. params.a then
wk_sg = "’"
end
local stems = {}
stems["sg"] = {params.base .. params.strong .. params.a}
stems["sg_weak"] = {params.base .. wk_sg .. params.a}
stems["pl"] = {params.base .. params.strong .. params.o .. "i"}
stems["pl_weak"] = {params.base .. params.weak .. params.o .. "i"}
stems["par_pl"] = {params.base .. params.strong .. params.o .. "j"}
stems["ill_pl"] = {params.base .. params.strong .. params.o .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.strong .. params.a .. "in"}
end
inflections["koira"] = function(args, data)
data.title = "[[Kotus]] 變格類型 10/[[Appendix:芬蘭語名詞變格/koira|koira]]"
table.insert(data.categories, "芬蘭語koira類名詞")
local params = get_params(args, 4)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
make_weak(params.base, params.strong, params.a, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local wk_sg = params.weak
local wk_pl = params.weak
if wk_sg == "" and mw.ustring.sub(params.base, -2) == params.a .. params.a then
wk_sg = "’"
end
if wk_pl == "" and mw.ustring.sub(params.base, -1) == "i" then
wk_pl = "’"
end
local stems = {}
stems["nom_sg"] = {nom_sg or params.base .. params.strong .. params.a}
stems["sg"] = {params.base .. params.strong .. params.a}
stems["sg_weak"] = {params.base .. wk_sg .. params.a}
stems["pl"] = {params.base .. params.strong .. "i"}
stems["pl_weak"] = {params.base .. wk_pl .. "i"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.strong .. params.a .. "in"}
end
inflections["omena"] = function(args, data)
data.title = "[[Kotus]] 變格類型 11/[[Appendix:芬蘭語名詞變格/omena|omena]],無層級變化"
table.insert(data.categories, "芬蘭語omena類名詞")
local params = get_params(args, 2)
local stems = {}
stems["sg"] = {params.base .. params.a}
stems["pl"] = {params.base .. params.o .. "i", params.base .. "i"}
stems["par_pl"] = {params.base .. "i", params.base .. params.o .. "it"}
stems["ill_pl"] = {params.base .. "i", params.base .. params.o .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.o .. "jen", params.base .. params.a .. "in"}
data.forms["par_pl"].rare = {params.base .. params.o .. "j" .. params.a}
end
inflections["kulkija"] = function(args, data)
data.title = "[[Kotus]] 變格類型 12/[[Appendix:芬蘭語名詞變格/kulkija|kulkija]],無層級變化"
table.insert(data.categories, "芬蘭語kulkija類名詞")
local params = get_params(args, 2)
local stems = {}
stems["sg"] = {params.base .. params.a}
stems["pl"] = {params.base .. params.o .. "i"}
stems["par_pl"] = {params.base .. params.o .. "it"}
stems["ill_pl"] = {params.base .. params.o .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.a .. "in"}
end
inflections["katiska"] = function(args, data)
data.title = "[[Kotus]] 變格類型 13/[[Appendix:芬蘭語名詞變格/katiska|katiska]],無層級變化"
table.insert(data.categories, "芬蘭語katiska類名詞")
local params = get_params(args, 2)
local stems = {}
stems["sg"] = {params.base .. params.a}
stems["pl"] = {params.base .. params.o .. "i"}
stems["par_pl"] = {params.base .. params.o .. "it", params.base .. params.o .. "j"}
stems["ill_pl"] = {params.base .. params.o .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.a .. "in"}
end
inflections["solakka"] = function(args, data)
data.title = "[[Kotus]] 變格類型 14/[[Appendix:芬蘭語名詞變格/solakka|solakka]]"
table.insert(data.categories, "芬蘭語solakka類名詞")
local params = get_params(args, 4)
make_weak(params.base, params.strong, params.a, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["sg"] = {params.base .. params.strong .. params.a}
stems["sg_weak"] = {params.base .. params.weak .. params.a}
stems["pl"] = {params.base .. params.strong .. params.o .. "i"}
stems["pl_weak"] = {params.base .. params.weak .. params.o .. "i"}
stems["par_pl"] = {params.base .. params.weak .. params.o .. "it", params.base .. params.strong .. params.o .. "j"}
stems["ill_pl"] = {params.base .. params.weak .. params.o .. "ih", params.base .. params.strong .. params.o .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.strong .. params.a .. "in"}
end
inflections["korkea"] = function(args, data)
data.title = "[[Kotus]] 變格類型 15/[[Appendix:芬蘭語名詞變格/korkea|korkea]],無層級變化"
table.insert(data.categories, "芬蘭語korkea類名詞")
local params = get_params(args, 2)
local final = mw.ustring.sub(params.base, -1)
local stems = {}
stems["sg"] = {params.base .. params.a}
stems["par_sg"] = {params.base .. params.a, params.base .. params.a .. "t"}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "it"}
stems["ill_pl"] = {params.base .. "isi", params.base .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.a .. "in"}
end
inflections["vanhempi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 16/[[Appendix:芬蘭語名詞變格/vanhempi|vanhempi]], ''mp-mm'' gradation"
table.insert(data.categories, "芬蘭語vanhempi類名詞")
data.gradtype = kotus_grad_type["mp-mm"]
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "mpi"}
stems["sg"] = {params.base .. "mp" .. params.a}
stems["sg_weak"] = {params.base .. "mm" .. params.a}
stems["pl"] = {params.base .. "mpi"}
stems["pl_weak"] = {params.base .. "mmi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "mp" .. params.a .. "in"}
end
inflections["vapaa"] = function(args, data)
data.title = "[[Kotus]] 變格類型 17/[[Appendix:芬蘭語名詞變格/vapaa|vapaa]],無層級變化"
table.insert(data.categories, "芬蘭語vapaa類名詞")
local params = get_params(args, 2)
local final = mw.ustring.sub(params.base, -1)
local stems = {}
stems["sg"] = {params.base .. final}
stems["par_sg"] = {params.base .. final .. "t"}
stems["ill_sg"] = {params.base .. final .. "se"}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "it"}
stems["ill_pl"] = {params.base .. "isi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["ill_pl"].rare = {params.base .. "ihin"}
end
inflections["maa"] = function(args, data)
data.title = "[[Kotus]] 變格類型 18/[[Appendix:芬蘭語名詞變格/maa|maa]],無層級變化"
table.insert(data.categories, "芬蘭語maa類名詞")
local params = get_params(args, 2)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
local pl_stem = mw.ustring.sub(params.base, 1, -2)
local stems = {}
stems["nom_sg"] = {nom_sg or params.base}
stems["sg"] = {params.base}
stems["par_sg"] = {params.base .. "t"}
stems["pl"] = {pl_stem .. "i"}
stems["par_pl"] = {pl_stem .. "it"}
stems["ill_pl"] = {pl_stem .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["suo"] = function(args, data)
data.title = "[[Kotus]] 變格類型 19/[[Appendix:芬蘭語名詞變格/suo|suo]],無層級變化"
table.insert(data.categories, "芬蘭語suo類名詞")
local params = get_params(args, 2)
local final = mw.ustring.sub(params.base, -1)
local plural = mw.ustring.sub(params.base, 1, -3) .. final
local stems = {}
stems["sg"] = {params.base}
stems["par_sg"] = {params.base .. "t"}
stems["ill_sg"] = {params.base .. "h"}
stems["pl"] = {plural .. "i"}
stems["par_pl"] = {plural .. "it"}
stems["ill_pl"] = {plural .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["filee"] = function(args, data)
data.title = "[[Kotus]] 變格類型 20/[[Appendix:芬蘭語名詞變格/filee|filee]],無層級變化"
table.insert(data.categories, "芬蘭語filee類名詞")
local params = get_params(args, 2)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
local pl_stem = mw.ustring.sub(params.base, 1, -2)
local stems = {}
stems["nom_sg"] = {nom_sg or params.base}
stems["sg"] = {params.base}
stems["par_sg"] = {params.base .. "t"}
stems["ill_sg"] = {params.base .. "h", params.base .. "se"}
stems["pl"] = {pl_stem .. "i"}
stems["par_pl"] = {pl_stem .. "it"}
stems["ill_pl"] = {pl_stem .. "ih", pl_stem .. "isi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["rosé"] = function(args, data)
data.title = "[[Kotus]] 變格類型 21/[[Appendix:芬蘭語名詞變格/rosé|rosé]],無層級變化"
table.insert(data.categories, "芬蘭語rosé類名詞")
local params = get_params(args, 2)
local ill_sg_vowel = get_extra_arg(args, data, "ill_sg_vowel"); if ill_sg_vowel == "" then error("Parameter \"ill_sg_vowel=\" cannot be empty.") end
local ill_sg_vowel2 = get_extra_arg(args, data, "ill_sg_vowel2"); if ill_sg_vowel2 == "" then error("Parameter \"ill_sg_vowel2=\" cannot be empty.") end
local stems = {}
stems["sg"] = {params.base}
stems["par_sg"] = {params.base .. "t"}
stems["ill_sg"] = {params.base .. "h"}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "it"}
stems["ill_pl"] = {params.base .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
if ill_sg_vowel then
data.forms["ill_sg"] = {params.base .. "h" .. ill_sg_vowel .. "n"}
end
if ill_sg_vowel2 then
table.insert(data.forms["ill_sg"], params.base .. "h" .. ill_sg_vowel2 .. "n")
end
end
inflections["parfait"] = function(args, data)
data.title = "[[Kotus]] 變格類型 22/[[Appendix:芬蘭語名詞變格/parfait|parfait]],無層級變化"
table.insert(data.categories, "芬蘭語parfait類名詞")
local params = get_params(args, 2)
local ill_sg_vowel = get_extra_arg(args, data, "ill_sg_vowel") or (mw.title.getCurrentTitle().nsText == "Template" and "e"); if not ill_sg_vowel or ill_sg_vowel == "" then error("Parameter \"ill_sg_vowel=\" is missing.") end
local ill_sg_vowel2 = get_extra_arg(args, data, "ill_sg_vowel2"); if ill_sg_vowel2 == "" then error("Parameter \"ill_sg_vowel2=\" cannot be empty.") end
local stems = {}
stems["nom_sg"] = {params.base}
stems["sg"] = {params.base .. "’"}
stems["par_sg"] = {params.base .. "’t"}
stems["pl"] = {params.base .. "’i"}
stems["par_pl"] = {params.base .. "’it"}
stems["ill_pl"] = {params.base .. "’ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["ill_sg"] = {params.base .. "’h" .. ill_sg_vowel .. "n"}
if ill_sg_vowel2 then
table.insert(data.forms["ill_sg"], params.base .. "h" .. ill_sg_vowel2 .. "n")
end
end
inflections["tiili"] = function(args, data)
data.title = "[[Kotus]] 變格類型 23/[[Appendix:芬蘭語名詞變格/tiili|tiili]],無層級變化"
table.insert(data.categories, "芬蘭語tiili類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "i"}
stems["sg"] = {params.base .. "e"}
stems["par_sg"] = {params.base .. "t"}
stems["pl"] = {params.base .. "i"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["uni"] = function(args, data)
data.title = "[[Kotus]] 變格類型 24/[[Appendix:芬蘭語名詞變格/uni|uni]],無層級變化"
table.insert(data.categories, "芬蘭語uni類名詞")
local params = get_params(args, 2)
local par_sg_a = get_extra_arg(args, data, "par_sg_a"); if par_sg_a and par_sg_a ~= "a" and par_sg_a ~= "ä" then error("Parameter \"par_sg_a=\" must be \"a\" or \"ä\".") end
local stems = {}
stems["nom_sg"] = {params.base .. "i"}
stems["sg"] = {params.base .. "e"}
stems["par_sg"] = {params.base .. "t"}
stems["pl"] = {params.base .. "i"}
stems["gen_pl"] = {params.base .. "i", params.base .. "t"}
make_stems(data, stems)
process_stems(data, stems, params.a)
if par_sg_a then
data.forms["par_sg"] = {}
for _, stem in ipairs(stems["par_sg"]) do
table.insert(data.forms["par_sg"], stem .. par_sg_a)
end
end
end
inflections["toimi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 25/[[Appendix:芬蘭語名詞變格/toimi|toimi]],無層級變化"
table.insert(data.categories, "芬蘭語toimi類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "mi"}
stems["sg"] = {params.base .. "me"}
stems["par_sg"] = {params.base .. "nt", params.base .. "me"}
stems["pl"] = {params.base .. "mi"}
stems["gen_pl"] = {params.base .. "mi", params.base .. "nt"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["pieni"] = function(args, data)
data.title = "[[Kotus]] 變格類型 26/[[Appendix:芬蘭語名詞變格/pieni|pieni]],無層級變化"
table.insert(data.categories, "芬蘭語pieni類名詞")
local params = get_params(args, 2)
local par_sg_a = get_extra_arg(args, data, "par_sg_a"); if par_sg_a and par_sg_a ~= "a" and par_sg_a ~= "ä" then error("Parameter \"par_sg_a=\" must be \"a\" or \"ä\".") end
local stems = {}
stems["nom_sg"] = {params.base .. "i"}
stems["sg"] = {params.base .. "e"}
stems["par_sg"] = {params.base .. "t"}
stems["pl"] = {params.base .. "i"}
stems["gen_pl"] = {params.base .. "t", params.base .. "i"}
make_stems(data, stems)
process_stems(data, stems, params.a)
if par_sg_a then
data.forms["par_sg"] = {}
for _, stem in ipairs(stems["par_sg"]) do
table.insert(data.forms["par_sg"], stem .. par_sg_a)
end
end
end
inflections["käsi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 27/[[Appendix:芬蘭語名詞變格/käsi|käsi]], ''t-d'' gradation"
table.insert(data.categories, "芬蘭語käsi類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "si"}
stems["sg"] = {params.base .. "te"}
stems["sg_weak"] = {params.base .. "de"}
stems["par_sg"] = {params.base .. "tt"}
stems["pl"] = {params.base .. "si"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "tten"}
end
inflections["kynsi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 28/[[Appendix:芬蘭語名詞變格/kynsi|kynsi]]"
table.insert(data.categories, "芬蘭語kynsi類名詞")
local params = get_params(args, 2, false, "n")
local cons = mw.ustring.match(params.base, "([lnr]?)$")
if mw.title.getCurrentTitle().nsText ~= "Template" and cons == "" then
error("Stem must end in \"l\", \"n\" or \"r\".")
end
data.title = data.title .. ", ''" .. cons .. "t-" .. cons .. cons .. "'' gradation"
data.gradtype = kotus_grad_type[cons .. "t-" .. cons .. cons]
local stems = {}
stems["nom_sg"] = {params.base .. "si"}
stems["sg"] = {params.base .. "te"}
stems["sg_weak"] = {params.base .. cons .. "e"}
stems["par_sg"] = {params.base .. "tt"}
stems["pl"] = {params.base .. "si"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "tten"}
end
inflections["lapsi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 29/[[Appendix:芬蘭語名詞變格/lapsi|lapsi]],無層級變化"
table.insert(data.categories, "芬蘭語lapsi類名詞")
local params = get_params(args, 2, false, "p")
local syncopated_stem, cons = mw.ustring.match(params.base, "^(.-)([kp]?)$")
if mw.title.getCurrentTitle().nsText ~= "Template" and cons == "" then
error("Stem must end in \"k\" or \"p\".")
end
local stems = {}
stems["nom_sg"] = {params.base .. "si"}
stems["sg"] = {params.base .. "se"}
stems["par_sg"] = {syncopated_stem .. "st"}
stems["pl"] = {params.base .. "si"}
stems["gen_pl"] = {params.base .. "si", syncopated_stem .. "st"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["veitsi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 30/[[Appendix:芬蘭語名詞變格/veitsi|veitsi]],無層級變化"
table.insert(data.categories, "芬蘭語veitsi類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "tsi"}
stems["sg"] = {params.base .. "tse"}
stems["par_sg"] = {params.base .. "st"}
stems["pl"] = {params.base .. "tsi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "sten"}
end
inflections["kaksi"] = function(args, data)
data.title = "[[Kotus]] 變格類型 31/[[Appendix:芬蘭語名詞變格/kaksi|kaksi]], ''t-d'' gradation"
table.insert(data.categories, "芬蘭語kaksi類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "ksi"}
stems["sg"] = {params.base .. "hte"}
stems["sg_weak"] = {params.base .. "hde"}
stems["par_sg"] = {params.base .. "ht"}
stems["pl"] = {params.base .. "ksi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["sisar"] = function(args, data)
data.title = "[[Kotus]] 變格類型 32/[[Appendix:芬蘭語名詞變格/sisar|sisar]]"
table.insert(data.categories, "芬蘭語sisar類名詞")
local params = get_params(args, 5, true)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
make_weak(params.base, params.strong, params.final, params.weak)
if params.strong == params.weak then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {nom_sg or params.base .. params.weak .. params.final}
stems["sg"] = {params.base .. params.strong .. params.final .. "e"}
stems["par_sg"] = {params.base .. params.weak .. params.final .. "t"}
stems["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems["gen_pl"] = {params.base .. params.strong .. params.final .. "i", params.base .. params.weak .. params.final .. "t"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["kytkin"] = function(args, data)
data.title = "[[Kotus]] 變格類型 33/[[Appendix:芬蘭語名詞變格/kytkin|kytkin]]"
table.insert(data.categories, "芬蘭語kytkin類名詞")
local params = get_params(args, 5, true)
make_weak(params.base, params.strong, params.final, params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.weak .. params.final .. "n"}
stems["sg"] = {params.base .. params.strong .. params.final .. "me"}
stems["par_sg"] = {params.base .. params.weak .. params.final .. "nt"}
stems["pl"] = {params.base .. params.strong .. params.final .. "mi"}
stems["gen_pl"] = {params.base .. params.strong .. params.final .. "mi", params.base .. params.weak .. params.final .. "nt"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["onneton"] = function(args, data)
data.title = "[[Kotus]] 變格類型 34/[[Appendix:芬蘭語名詞變格/onneton|onneton]], ''tt-t'' gradation"
table.insert(data.categories, "芬蘭語onneton類名詞")
data.gradtype = kotus_grad_type["tt-t"]
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "t" .. params.o .. "n"}
stems["sg"] = {params.base .. "tt" .. params.o .. "m" .. params.a}
stems["par_sg"] = {params.base .. "t" .. params.o .. "nt"}
stems["pl"] = {params.base .. "tt" .. params.o .. "mi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "t" .. params.o .. "nten"}
end
inflections["lämmin"] = function(args, data)
data.title = "[[Kotus]] 變格類型 35/[[Appendix:芬蘭語名詞變格/lämmin|lämmin]]"
table.insert(data.categories, "芬蘭語lämmin類名詞")
local params = get_params(args, 5, true)
make_weak(params.base, params.strong, params.final, params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.weak .. params.final .. "n"}
stems["sg"] = {params.base .. params.strong .. params.final .. "m" .. params.a}
stems["par_sg"] = {params.base .. params.weak .. params.final .. "nt"}
stems["pl"] = {params.base .. params.strong .. params.final .. "mi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. params.strong .. params.final .. "m" .. params.a .. "in"}
end
inflections["sisin"] = function(args, data)
data.title = "[[Kotus]] 變格類型 36/[[Appendix:芬蘭語名詞變格/sisin|sisin]], ''mp-mm'' gradation"
table.insert(data.categories, "芬蘭語sisin類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "in"}
stems["sg"] = {params.base .. "imp" .. params.a}
stems["sg_weak"] = {params.base .. "imm" .. params.a}
stems["par_sg"] = {params.base .. "int"}
stems["pl"] = {params.base .. "impi"}
stems["pl_weak"] = {params.base .. "immi"}
stems["gen_pl"] = {params.base .. "impi", params.base .. "int"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "imp" .. params.a .. "in"}
end
inflections["vasen"] = function(args, data)
data.title = "[[Kotus]] 變格類型 37/[[Appendix:芬蘭語名詞變格/vasen|vasen]], ''mp-mm'' gradation"
table.insert(data.categories, "芬蘭語vasen類名詞")
local params = get_params(args, 1)
params.base = params.base .. "vase"
params.a = "a"
local stems = {}
stems["nom_sg"] = {params.base .. "n"}
stems["sg"] = {params.base .. "mp" .. params.a}
stems["sg_weak"] = {params.base .. "mm" .. params.a}
stems["par_sg"] = {params.base .. "nt", params.base .. "mp" .. params.a}
stems["pl"] = {params.base .. "mpi"}
stems["pl_weak"] = {params.base .. "mmi"}
stems["gen_pl"] = {params.base .. "mpi", params.base .. "nt"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "mp" .. params.a .. "in"}
end
inflections["nainen"] = function(args, data)
data.title = "[[Kotus]] 變格類型 38/[[Appendix:芬蘭語名詞變格/nainen|nainen]],無層級變化"
table.insert(data.categories, "芬蘭語nainen類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "nen"}
stems["sg"] = {params.base .. "se"}
stems["par_sg"] = {params.base .. "st"}
stems["pl"] = {params.base .. "si"}
stems["gen_pl"] = {params.base .. "st", params.base .. "si"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["vastaus"] = function(args, data)
data.title = "[[Kotus]] 變格類型 39/[[Appendix:芬蘭語名詞變格/vastaus|vastaus]],無層級變化"
table.insert(data.categories, "芬蘭語vastaus類名詞")
local params = get_params(args, 2)
local nom_sg = get_extra_arg(args, data, "nom_sg"); if nom_sg == "" then nom_sg = nil end
local stems = {}
stems["nom_sg"] = {nom_sg or params.base .. "s"}
stems["sg"] = {params.base .. "kse"}
stems["par_sg"] = {params.base .. "st"}
stems["pl"] = {params.base .. "ksi"}
stems["gen_pl"] = {params.base .. "st", params.base .. "ksi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["kalleus"] = function(args, data)
data.title = "[[Kotus]] 變格類型 40/[[Appendix:芬蘭語名詞變格/kalleus|kalleus]], ''t-d'' gradation"
table.insert(data.categories, "芬蘭語kalleus類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "s"}
stems["sg"] = {params.base .. "te"}
stems["sg_weak"] = {params.base .. "de"}
stems["par_sg"] = {params.base .. "tt"}
stems["pl"] = {params.base .. "ksi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["vieras"] = function(args, data)
data.title = "[[Kotus]] 變格類型 41/[[Appendix:芬蘭語名詞變格/vieras|vieras]]"
table.insert(data.categories, "芬蘭語vieras類名詞")
local params = get_params(args, 5, true)
make_weak(params.base, params.strong, params.final, params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.weak .. params.final .. "s"}
stems["sg"] = {params.base .. params.strong .. params.final .. params.final}
stems["par_sg"] = {params.base .. params.weak .. params.final .. "st"}
stems["ill_sg"] = {params.base .. params.strong .. params.final .. params.final .. "se"}
stems["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems["par_pl"] = {params.base .. params.strong .. params.final .. "it"}
stems["ill_pl"] = {params.base .. params.strong .. params.final .. "isi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["ill_pl"].rare = {params.base .. params.strong .. params.final .. "ihin"}
end
inflections["mies"] = function(args, data)
data.title = "[[Kotus]] 變格類型 42/[[Appendix:芬蘭語名詞變格/mies|mies]],無層級變化"
table.insert(data.categories, "芬蘭語mies類名詞")
local params = get_params(args, 1)
params.base = params.base .. "mie"
params.a = "ä"
local stems = {}
stems["nom_sg"] = {params.base .. "s"}
stems["sg"] = {params.base .. "he"}
stems["par_sg"] = {params.base .. "st"}
stems["pl"] = {params.base .. "hi"}
stems["gen_pl"] = {params.base .. "st", params.base .. "hi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["ohut"] = function(args, data)
data.title = "[[Kotus]] 變格類型 43/[[Appendix:芬蘭語名詞變格/ohut|ohut]]"
table.insert(data.categories, "芬蘭語ohut類名詞")
local params = get_params(args, 5, true)
make_weak(params.base, params.strong, params.final, params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.weak .. params.final .. "t"}
stems["sg"] = {params.base .. params.strong .. params.final .. "e"}
stems["par_sg"] = {params.base .. params.weak .. params.final .. "tt"}
stems["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems["par_pl"] = {params.base .. params.strong .. params.final .. "it"}
stems["ill_pl"] = {params.base .. params.strong .. params.final .. "isi", params.base .. params.strong .. params.final .. "ih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["kevät"] = function(args, data)
data.title = "[[Kotus]] 變格類型 44/[[Appendix:芬蘭語名詞變格/kevät|kevät]],無層級變化"
table.insert(data.categories, "芬蘭語kevät類名詞")
local params = get_params(args, 2)
local vowel = mw.ustring.sub(params.base, -1)
local stems = {}
stems["nom_sg"] = {params.base .. "t"}
stems["sg"] = {params.base .. vowel}
stems["par_sg"] = {params.base .. "tt"}
stems["ill_sg"] = {params.base .. vowel .. "se"}
stems["pl"] = {params.base .. "i"}
stems["par_pl"] = {params.base .. "it"}
stems["ill_pl"] = {params.base .. "isi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["ill_pl"].rare = {params.base .. "ihin"}
end
inflections["kahdeksas"] = function(args, data)
data.title = "[[Kotus]] 變格類型 45/[[Appendix:芬蘭語名詞變格/kahdeksas|kahdeksas]], ''nt-nn'' gradation"
table.insert(data.categories, "芬蘭語kahdeksas類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "s"}
stems["sg"] = {params.base .. "nte"}
stems["sg_weak"] = {params.base .. "nne"}
stems["par_sg"] = {params.base .. "tt"}
stems["pl"] = {params.base .. "nsi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["tuhat"] = function(args, data)
data.title = "[[Kotus]] 變格類型 46/[[Appendix:芬蘭語名詞變格/tuhat|tuhat]], ''nt-nn'' gradation"
table.insert(data.categories, "芬蘭語tuhat類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. "t"}
stems["sg"] = {params.base .. "nte"}
stems["sg_weak"] = {params.base .. "nne"}
stems["par_sg"] = {params.base .. "tt"}
stems["pl"] = {params.base .. "nsi"}
make_stems(data, stems)
process_stems(data, stems, params.a)
data.forms["gen_pl"].rare = {params.base .. "nten"}
end
inflections["kuollut"] = function(args, data)
data.title = "[[Kotus]] 變格類型 47/[[Appendix:芬蘭語名詞變格/kuollut|kuollut]],無層級變化"
table.insert(data.categories, "芬蘭語kuollut類名詞")
local params = get_params(args, 2)
local stems = {}
stems["nom_sg"] = {params.base .. params.u .. "t"}
stems["sg"] = {params.base .. "ee"}
stems["par_sg"] = {params.base .. params.u .. "tt"}
stems["ill_sg"] = {params.base .. "eese"}
stems["pl"] = {params.base .. "ei"}
stems["par_pl"] = {params.base .. "eit"}
stems["ill_pl"] = {params.base .. "eisi", params.base .. "eih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["hame"] = function(args, data)
data.title = "[[Kotus]] 變格類型 48/[[Appendix:芬蘭語名詞變格/hame|hame]]"
table.insert(data.categories, "芬蘭語hame類名詞")
local params = get_params(args, 4, true)
make_weak(params.base, params.strong, "e", params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems = {}
stems["nom_sg"] = {params.base .. params.weak .. "e"}
stems["sg"] = {params.base .. params.strong .. "ee"}
stems["par_sg"] = {params.base .. params.weak .. "ett"}
stems["ill_sg"] = {params.base .. params.strong .. "eese"}
stems["pl"] = {params.base .. params.strong .. "ei"}
stems["par_pl"] = {params.base .. params.strong .. "eit"}
stems["ill_pl"] = {params.base .. params.strong .. "eisi", params.base .. params.strong .. "eih"}
make_stems(data, stems)
process_stems(data, stems, params.a)
end
inflections["askel"] = function(args, data)
data.title = "[[Kotus]] 變格類型 49/[[Appendix:芬蘭語名詞變格/askel|askel]]"
table.insert(data.categories, "芬蘭語askel類名詞")
local params = get_params(args, 5, true)
local prefer_hame = get_extra_arg(args, data, "e") == "1"
make_weak(params.base, params.strong, "", params.weak)
if params.weak == params.strong then
data.title = data.title .. ",無層級變化"
else
data.title = data.title .. ", ''" .. params.strong .. "-" .. params.weak .. "'' gradation"
data.gradtype = kotus_grad_type[params.strong .. "-" .. params.weak]
end
local stems_sisar = {}
stems_sisar["nom_sg"] = {nom_sg or params.base .. params.weak .. params.final}
stems_sisar["sg"] = {params.base .. params.strong .. params.final .. "e"}
stems_sisar["par_sg"] = {params.base .. params.weak .. params.final .. "t"}
stems_sisar["pl"] = {params.base .. params.strong .. params.final .. "i"}
stems_sisar["gen_pl"] = {params.base .. params.strong .. params.final .. "i", params.base .. params.weak .. params.final .. "t"}
make_stems(data, stems_sisar)
local stems_hame = {}
stems_hame["nom_sg"] = {params.base .. params.strong .. params.final .. "e"}
stems_hame["sg"] = {params.base .. params.strong .. params.final .. "ee"}
stems_hame["par_sg"] = {params.base .. params.strong .. params.final .. "ett"}
stems_hame["ill_sg"] = {params.base .. params.strong .. params.final .. "eese"}
stems_hame["pl"] = {params.base .. params.strong .. params.final .. "ei"}
stems_hame["par_pl"] = {params.base .. params.strong .. params.final .. "eit"}
stems_hame["ill_pl"] = {params.base .. params.strong .. params.final .. "eisi", params.base .. params.strong .. params.final .. "eih"}
make_stems(data, stems_hame)
if prefer_hame then
process_stems(data, stems_hame, params.a)
process_stems(data, stems_sisar, params.a)
data["stems"] = merge_stems(stems_hame, stems_sisar)
else
process_stems(data, stems_sisar, params.a)
process_stems(data, stems_hame, params.a)
data["stems"] = merge_stems(stems_sisar, stems_hame)
end
end
-- Helper functions
-- joins data.words[...].forms to data.forms
function export.join_words(data, sep)
local reorganized = {}
local classes = {}
-- reorganize from words[n].forms[case](.rare) to forms[case],words[n](.rare)
for windex, word in ipairs(data.words) do
table.insert(classes, word.class)
for case, forms in pairs(word.forms) do
if reorganized[case] == nil then
reorganized[case] = {}
end
reorganized[case][windex] = {}
for _, form in ipairs(forms) do
table.insert(reorganized[case][windex], form)
end
if word.forms[case].rare then
reorganized[case][windex].rare = {}
for _, form in ipairs(word.forms[case].rare) do
table.insert(reorganized[case][windex].rare, form)
end
end
end
end
-- merge the forms with a Cartesian product to produce all possible combinations
data.forms = {}
for case, words in pairs(reorganized) do
data.forms[case] = forms_cart_product(words, case, sep, classes)
end
if #data.words < 2 then
-- use title and categories of the sole word if there is only one
data.title = data.words[1].title
data.categories = data.words[1].categories
else
-- if there are multiple words, force nuoripari type
data.title = "[[Kotus]] 變格類型 51/[[Appendix:芬蘭語名詞變格/nuoripari|nuoripari]]"
data.categories = {"芬蘭語nuoripari類名詞"}
end
data.words = nil
end
-- computes the Cartesian product of tables
function cart_product(words, depth)
depth = depth or 1
local prod = {}
for _, val in ipairs(words[depth]) do
if depth < #words then
-- go over the next list
for _, res in ipairs(cart_product(words, depth + 1)) do
table.insert(prod, { val, unpack(res) })
end
else
-- end of list, simply return the original
table.insert(prod, { val })
end
end
return prod
end
-- computes the Cartesian product of tables, also concats
function cart_product_concat(words, sep)
local res = {}
for _, combination in ipairs(cart_product(words)) do
table.insert(res, table.concat(combination, sep))
end
return res
end
-- returns a bit mask (!) or nil
function get_rhyming_pattern(word, case, class)
if class == "askel" then
return nil
end
if case == "gen_pl" then
if mw.ustring.match(word, "tten$") then
return 2
elseif mw.ustring.match(word, "ten$") then
return 3
else
return 1
end
elseif case == "ill_sg" then
if mw.ustring.match(word, "seen$") then
return 1
elseif mw.ustring.match(word, "hen$") then
return 2
end
elseif case == "ill_pl" then
if mw.ustring.match(word, "siin$") then
return 1
elseif mw.ustring.match(word, "hin$") then
return 2
end
end
return nil -- not applicable
end
function is_nonrhyming(form, case, classes)
local expected = m_bit32.bnot(0) -- -1
for i, word in ipairs(form) do
local got = get_rhyming_pattern(word, case, classes[i])
if got then
expected = m_bit32.band(expected, got)
end
if expected == 0 then
return true
end
end
return false
end
-- computes the Cartesian product of tables, also concats
-- returns non-rhyming combinations as rare
function cart_product_concat_nonrhyming_rare(words, case, sep, classes)
local res = {}
local rare = {}
local multichoice = 0
local allow_pruning = false
for _, position in ipairs(words) do
if #position > 1 then
multichoice = multichoice + 1
end
end
allow_pruning = multichoice > 1
for _, combination in ipairs(cart_product(words)) do
local item = table.concat(combination, sep)
if is_nonrhyming(combination, case, classes) then
table.insert(rare, item)
else
table.insert(res, item)
end
end
if #res < 1 then
rare.rare = {}
return rare
end
res.rare = rare
return res
end
-- converts a list of words to extract the rare forms for ipairs
-- the number is interpreted bit-by-bit to decide which combination
-- to choose
function prepare_rare_tables(words, code)
local result = {}
for _, forms in ipairs(words) do
-- replace with rare if bit is 1
if m_bit32.band(code, 1) == 1 then
table.insert(result, forms.rare or {})
else
table.insert(result, forms)
end
-- shift right to test next bit
code = m_bit32.rshift(code, 1)
end
return result
end
-- copies all entries of source and inserts them to target
function merge_table(target, source)
for _, value in ipairs(source) do
table.insert(target, value)
end
end
function merge_table_rare(target, source)
for _, value in ipairs(source) do
table.insert(target, value)
end
target.rare = source.rare
end
-- the Cartesian product of possible forms
function forms_cart_product(words, case, sep, classes)
local result = {}
result.rare = {}
-- merge possible non-rare forms
merge_table_rare(result, cart_product_concat_nonrhyming_rare(words, case, sep, classes))
-- merge possible rare forms
-- for example, with two words:
-- 1 = rare A, common B
-- 2 = common A, rare B
-- 3 = rare A, rare B
-- (2 ^ #words) - 1 == m_bit32.lshift(1,#words)-1
-- (prepare_rare_tables actually takes out the rare forms)
for i = 1,m_bit32.lshift(1,#words)-1 do
merge_table(result.rare, cart_product_concat(prepare_rare_tables(words, i), sep))
end
-- if no rare forms, remove the table completely
if #result.rare < 1 then
result.rare = nil
end
return result
end
function make_word_possessive(args, data, poss, always_add)
local pos = get_extra_arg(args, data, "pos"); if not pos or pos == "" then pos = "名詞" end
local suffix = get_extra_arg(args, data, "suffix"); if not suffix then suffix = "" end
-- "no possessive forms exist" sentinel value
if poss == "-" then
return data.forms
end
if always_add or pos == "noun" then
-- add possessive suffix
if poss == "3" or poss == "3p" then
poss = "3s" -- 3rd person forms are identical
end
if not poss_forms[poss] then
error("Invalid poss value: '" .. p .. "'")
end
return make_poss_with_suffix(data.forms, data.stems, poss_forms[poss], suffix, poss_alt[poss])
end
return data.forms
end
function postprocess_word(args, data, always_add)
local pos = get_extra_arg(args, data, "pos"); if not pos or pos == "" then pos = "noun" end
if args.args["poss"] then
data.forms = make_word_possessive(args, data, args.args["poss"], always_add)
elseif pos == "noun" and data.forms["com_pl"] then
-- Add the possessive suffix to the comitative plural, if the word is a noun
for key, subform in ipairs(data.forms["com_pl"]) do
data.forms["com_pl"][key] = subform .. "en"
end
end
if show_kotus_gradations and data.gradtype then
data.title = mw.ustring.gsub(data.title, "([0-9]+)/", "%1*" .. data.gradtype .. "/")
end
end
function postprocess(args, data)
local pos = args["pos"]; if not pos or pos == "" then pos = "noun" end
local nosg = args["nosg"]; if nosg == "" then nosg = nil end
local nopl = args["nopl"]; if nopl == "" then nopl = nil end
local n = args["n"]; if n == "" then n = nil end
local suffix = args["suffix"]; if suffix == "" then suffix = nil end
local appendix = args["appendix"]; if appendix == "" then appendix = nil end
local has_ins_sg = args["has_ins_sg"]; if has_ins_sg == "" then has_ins_sg = nil end
local has_no_nom = args["has_no_nom"]; if has_no_nom == "" then has_no_nom = nil end
-- Add the possessive suffix to the comitative plural, if the word is a noun
-- now done per word; see postprocess_word
if nosg or n == "pl" then
table.insert(data.categories, "芬蘭語唯複名詞")
end
-- TODO: This says "nouns", but this module is also used for adjectives!
if nopl or n == "sg" then
table.insert(data.categories, "芬蘭語不可數名詞")
end
if n == "csg" then -- "chiefly singular"
data.rare_plural = true
end
if not has_ins_sg then
data.forms["ins_sg"] = nil
end
for key, form in pairs(data.forms) do
-- Add suffix to forms
for i, subform in ipairs(form) do
subform = subform .. (suffix or "")
form[i] = subform
end
if form.rare then
for i, subform in ipairs(form.rare) do
subform = subform .. (suffix or "")
form.rare[i] = subform
end
end
-- Do not show singular or plural forms for nominals that don't have them
if ((nosg or n == "pl") and key:find("_sg$")) or ((nopl or n == "sg") and key:find("_pl$")) then
form = nil
end
data.forms[key] = form
end
-- Check if the lemma form matches the page name
if not appendix and lang:makeEntryName(data.forms[(nosg or n == "pl") and "nom_pl" or "nom_sg"][1]) ~= mw.title.getCurrentTitle().text then
table.insert(data.categories, "屈折與頁面名不匹配的芬蘭語詞條")
end
if has_no_nom then
data.forms["nom_sg"] = nil
data.forms["nom_pl"] = nil
end
end
function make_possessive_table(args, data, pos, infl_type)
local nosg = args["nosg"]; if nosg == "" then nosg = nil end
local nopl = args["nopl"]; if nopl == "" then nopl = nil end
local n = args["n"]; if n == "" then n = nil end
local note = nil
local base_form = "nom_sg"
if nosg or n == "pl" then
base_form = "nom_pl"
end
if pos == "adj" then
note = not args["hideadjnote"] and "'''罕用'''。僅用於名詞化形容詞。" or ""
elseif pos ~= "noun" then
return ""
end
-- make compact table
local compacted = {}
for poss, components in pairs(data) do
local words = {}
if #components == 1 then
-- one component only, just allow all forms
compacted[poss] = components[1][base_form]
else
-- more than one, only take first form
-- maybe later this would also use some Cartesian product stuff too
for i, word in ipairs(components) do
-- pick first valid form, since that is what we would display
table.insert(words, word[base_form][1])
end
compacted[poss] = { table.concat(words, args["space"] or " ") }
end
end
return "\n" .. make_possessive_table_internal(args, compacted, infl_type, note)
end
-- Make the table
function make_table(data, vh)
local rare_plural = data.rare_plural
local note = rare_plural and "本詞的複數形不太常用,但可見於比喻用法、部分短語和口語中。" or nil
local function show_form(forms, code, no_rare)
local form = forms[code]
if not form then
return "—"
elseif type(form) ~= "table" then
error("a non-table value was given in the list of inflected forms.")
end
local ret = {}
local accel
if rare_plural and code:find("_pl$") then
-- plural is marginal
for key, subform in ipairs(form) do
table.insert(ret, "(''" .. m_links.full_link({
lang = lang,
term = subform
}) .. "'')")
end
if not no_rare and form.rare then
for key, subform in ipairs(form.rare) do
table.insert(ret, "(" .. m_links.full_link({
lang = lang,
term = subform
}) .. "<sup>罕用</sup>)")
end
end
return table.concat(ret, "<br/>")
end
-- See [[Module talk:fi-nominals]].
if code == "nom_sg" then
accel = nil
elseif code == "nom_pl" then
accel = { form = "nom//acc|p" }
elseif not code:find("^com_") then
accel = {
form = code:gsub("%f[^_](%a%a)$", {sg = "s", pl = "p"}):gsub("ins", "ist"):gsub("_", "|"),
}
elseif code == "com_pl" and vh ~= nil then
-- add vowel harmony vowel (a/ä) for comitative
accel = {
form = "com-pl-" .. vh,
}
end
for key, subform in ipairs(form) do
table.insert(ret, m_links.full_link({
lang = lang,
term = subform,
accel = accel,
}))
end
if not no_rare and form.rare then
if accel then
accel.form = 'rare-' .. accel.form
end
for key, subform in ipairs(form.rare) do
table.insert(ret, m_links.full_link({
lang = lang,
term = subform,
accel = accel,
}) .. "<sup>rare</sup>")
end
end
return table.concat(ret, "<br/>")
end
local function repl(param)
if param == "lemma" then
return m_links.full_link({lang = lang, alt = mw.title.getCurrentTitle().text}, "term")
elseif param == "info" then
return data.title and " (" .. data.title .. ")" or ""
elseif param == "maybenote" then
if note then
return [=[
|- class="vsHide"
| colspan="4" style="width:100px" | ]=] .. note .. "\n"
else
return ""
end
else
local param2 = mw.ustring.match(param, "^(.-):c$")
if param2 then
return show_form(data.forms, param2, true)
else
return show_form(data.forms, param)
end
end
end
local wikicode = [=[
{| class="inflection-table fi-decl vsSwitcher vsToggleCategory-變格"
|-
! class="vsToggleElement" colspan="4" | {{{lemma}}}{{{info}}}的變格
|- class="vsShow"
! class="case-column" colspan="2" | 主格
| class="number-column" | {{{nom_sg:c}}}
| class="number-column" | {{{nom_pl:c}}}
|- class="vsShow"
! colspan="2" | 屬格
| {{{gen_sg:c}}}
| {{{gen_pl:c}}}
|- class="vsShow"
! colspan="2" | 部分格
| {{{par_sg:c}}}
| {{{par_pl:c}}}
|- class="vsShow"
! colspan="2" | 入格
| {{{ill_sg:c}}}
| {{{ill_pl:c}}}
|- class="vsHide"
! class="case-column" colspan="2" |
! class="number-column" | 單數
! class="number-column" | 複數
|- class="vsHide"
! colspan="2" | 主格
| {{{nom_sg}}}
| {{{nom_pl}}}
|- class="vsHide"
! rowspan="2" | 賓格
! nom.<sup title="The nominative accusative is used, for example, as the object of certain passives and imperatives."></sup>
| {{{nom_sg}}}
| rowspan="2" | {{{nom_pl}}}
|- class="vsHide"
! gen.
| {{{gen_sg}}}
|- class="vsHide"
! colspan="2" | 屬格
| {{{gen_sg}}}
| {{{gen_pl}}}
|- class="vsHide"
! colspan="2" | 部分格
| {{{par_sg}}}
| {{{par_pl}}}
|- class="vsHide"
! colspan="2" | 內格
| {{{ine_sg}}}
| {{{ine_pl}}}
|- class="vsHide"
! colspan="2" | 出格
| {{{ela_sg}}}
| {{{ela_pl}}}
|- class="vsHide"
! colspan="2" | 入格
| {{{ill_sg}}}
| {{{ill_pl}}}
|- class="vsHide"
! colspan="2" | 所格
| {{{ade_sg}}}
| {{{ade_pl}}}
|- class="vsHide"
! colspan="2" | 奪格
| {{{abl_sg}}}
| {{{abl_pl}}}
|- class="vsHide"
! colspan="2" | 向格
| {{{all_sg}}}
| {{{all_pl}}}
|- class="vsHide"
! colspan="2" | 樣格
| {{{ess_sg}}}
| {{{ess_pl}}}
|- class="vsHide"
! colspan="2" | 變格
| {{{tra_sg}}}
| {{{tra_pl}}}
|- class="vsHide"
! colspan="2" | 具格
| {{{ins_sg}}}
| {{{ins_pl}}}
|- class="vsHide"
! colspan="2" | 缺格
| {{{abe_sg}}}
| {{{abe_pl}}}
|- class="vsHide"
! colspan="2" | 共格
| {{{com_sg}}}
| {{{com_pl}}}
|}]=]
return mw.ustring.gsub(wikicode, "{{{([a-z0-9_:]+)}}}", repl)
end
------------------------------------------
-- POSSESSIVE FORM GENERATION & DISPLAY --
------------------------------------------
local function prepare_possessive_list(forms)
local res = {}
for _, v in ipairs(forms) do
table.insert(res, v)
end
if forms["rare"] then
for _, v in ipairs(forms["rare"]) do
table.insert(res, v)
res[v] = "rare"
end
end
return res
end
local function wrap_rare_forms(forms)
local newforms = {}
for case, subforms in pairs(forms) do
local common = {}
local rare = {}
for _, v in ipairs(subforms) do
if subforms[v] == "rare" then
table.insert(rare, v)
else
table.insert(common, v)
end
end
common.rare = rare
newforms[case] = common
end
return newforms
end
local function make_possessives_from_stems(stems, suffix, suffix2)
local pforms = {}
for _, stem in pairs(stems) do
table.insert(pforms, stem .. suffix .. suffix2)
end
return pforms
end
function make_poss_with_suffix(forms, stems, suffix, suffix2, allow_alt)
local result = {}
if suffix:find("a") and mw.ustring.sub(forms["par_sg"][1], -1) == "ä" then
suffix = mw.ustring.gsub(suffix, "a", "ä")
end
for k, v in pairs(forms_alt_ok) do
if forms[k] then
result[k] = {}
if k == "par_sg" and allow_alt then
-- par_sg is a bit of an exception: it allows
-- alt form if it doesn't end in two "aa"/"ää"
local prepared = prepare_possessive_list(forms[k])
for _, form in ipairs(prepared) do
local modform = form
if mw.ustring.sub(modform, -2, -2) ~= mw.ustring.sub(modform, -1) then
local final = modform .. mw.ustring.sub(modform, -1) .. "n"
table.insert(result[k], final)
result[k][final] = prepared[form]
end
end
elseif forms_alt_ok[k] and allow_alt then
local prepared = prepare_possessive_list(forms[k])
for _, form in ipairs(prepared) do
local modform = form
if k == "tra_sg" or k == "tra_pl" then
modform = mw.ustring.sub(form, 1, -2) .. "e"
end
local final = modform .. mw.ustring.sub(modform, -1) .. "n"
table.insert(result[k], final)
result[k][final] = prepared[form]
end
end
if k == "gen_sg" or k == "ins_sg" then
result[k] = make_possessives_from_stems(stems["sg"], suffix, suffix2)
elseif k == "ins_pl" then
result[k] = make_possessives_from_stems(stems["pl"], suffix, suffix2)
elseif forms_gen_ok[k] then
local prepared = prepare_possessive_list(forms[k])
for _, form in ipairs(prepared) do
local tmp = form
tmp = mw.ustring.sub(tmp, 1, -2)
local final = tmp .. suffix .. suffix2
table.insert(result[k], final)
result[k][final] = prepared[form]
end
else
local prepared = prepare_possessive_list(forms[k])
for _, form in ipairs(prepared) do
local modform = form
if k == "tra_sg" or k == "tra_pl" then
modform = mw.ustring.sub(form, 1, -2) .. "e"
end
local final = modform .. suffix .. suffix2
table.insert(result[k], final)
result[k][final] = prepared[form]
end
end
end
end
-- nominative forms are identical to genitive singular
result["nom_sg"] = result["gen_sg"]
result["nom_pl"] = result["gen_sg"]
return wrap_rare_forms(result)
end
function generate_possessive_forms(result, args, data, always_add)
for poss, sufx in pairs(poss_forms) do
result[poss] = result[poss] or {}
table.insert(result[poss], make_word_possessive(args, data, poss, always_add))
end
end
local function serialize_args(args)
local items = {}
local entries = {}
local max_number = 0
for key, value in pairs(args) do
if type(key) == "number" and key > 0 and key == math.floor(key) then
items[key] = value
max_number = math.max(key, max_number)
else
table.insert(entries, key .. "=" .. value)
end
end
for i = 1,max_number,1 do
items[i] = items[i] or ""
end
-- entries before items
for i, v in ipairs(entries) do
table.insert(items, i, v)
end
return table.concat(items, "|")
end
function make_possessive_table_internal(args, data, infl_type, note)
local function show_form(forms, code, no_rare)
local subforms = forms[code]
if not subforms or #subforms < 1 then
return "—"
end
local ret = {}
for _, subform in ipairs(subforms) do
-- there might be a better way to pass extra parameters, since this is not a good way to do that
table.insert(ret, m_links.full_link({
lang = lang,
term = subform,
accel = {
form = "possessive|" .. code .. "|" .. infl_type .. "|" .. require("Module:base64").encode(serialize_args(args))
},
}))
end
return table.concat(ret, "<br/>")
end
local function repl(param)
if param == "lemma" then
return m_links.full_link({lang = lang, alt = mw.title.getCurrentTitle().text}, "term")
elseif param == "info" then
if infl_type:match("%-") then
return " (變格類型 ''nuoripari'')"
else
return " (變格類型 ''" .. infl_type .. "'')"
end
elseif param == "maybenote" then
if note then
return [=[
|- class="vsHide"
| colspan="3" | ]=] .. note .. "\n"
else
return ""
end
else
return show_form(data, param)
end
end
local wikicode = [=[
{| class="inflection-table vsSwitcher" data-toggle-category="變格" style="color: rgb(0%,0%,30%); border: solid 1px rgb(80%,80%,100%); text-align: center;" cellspacing="1" cellpadding="2"
|- style="background: #e2f6e2;"
! class="vsToggleElement" style="min-width: 30em; text-align: left;" colspan="3" | {{{lemma}}} 的[[Appendix:芬蘭語所有格後綴|所有格形式]]{{{info}}}
{{{maybenote}}}|- class="vsHide"
! style="min-width: 11em; background:#c0e4c0" | 所有者
! style="min-width: 10em; background:#c0e4c0" | 單數
! style="min-width: 10em; background:#c0e4c0" | 複數
|- class="vsHide" style="background:rgb(95%,95%,100%)"
! style="background:#e2f6e2" | 第一人稱
| {{{1s}}}
| {{{1p}}}
|- class="vsHide" style="background:rgb(95%,95%,100%)"
! style="background:#e2f6e2" | 第二人稱
| {{{2s}}}
| {{{2p}}}
|- class="vsHide" style="background:rgb(95%,95%,100%)"
! style="background:#e2f6e2" | 第三人稱
| colspan="2" | {{{3s}}}
|}]=]
return mw.ustring.gsub(wikicode, "{{{([a-z0-9_:]+)}}}", repl)
end
export.inflections = inflections
return export