local export = {}
local m_str_utils = require("Module:string utilities")
local links_module = "Module:links"
local u = m_str_utils.char
local rfind = m_str_utils.find
local rsubn = m_str_utils.gsub
local ulen = m_str_utils.len
local ulower = m_str_utils.lower
local uupper = mw.ustring.upper
local usub = mw.ustring.sub
-- Lect data later retrieved in the module.
local data
-- version of rsubn() that discards all but the first return value
local function rsub(term, foo, bar)
local retval = rsubn(term, foo, bar)
return retval
end
local OVERTIE = u(0x361) -- COMBINING DOUBLE INVERTED BREVE
--[[
As can be seen from the last lines of the function, this returns a table of transcriptions,
and if do_hyph, also a string being the hyphenation. These are based on a single spelling given,
so the reason why the transcriptions are multiple is only because of the -yka alternating stress
et sim. This only accepts single-word terms. Multiword terms are handled by multiword().
--]]
local function phonemic(txt, do_hyph, lang, is_prep, period, lect)
local ante = 0
local unstressed = is_prep or false
local colloquial = true
function tsub(s, r)
txt, c = rsubn(txt, s, r)
return c > 0
end
function lg(s) return s or s end
function tfind(s) return rfind(txt, s) end
if tfind("") then error("Please replace å with á.") end
-- Save indices of uppercase characters before setting everything lowercase.
local uppercase_indices
if do_hyph then
uppercase_indices = {}
local capitals = (""):format(lg {
pl = "ĄĆĘŁŃÓŚŹŻ" --] .. "ÁÉÔÛÝ" --] .. "ḾṔẂ",
szl = "ÃĆŁŃŌŎÔÕŚŹŻ",
csb = "ÔÒÃËÙÉÓĄŚŁŻŹĆŃ",
slv = "ÃÉËÊÓÕÔÚÙŃŻ",
mas = "ÁÄÉŁŃÓÔŚÛŸŻŹ"
})
if tfind(capitals) then
local i = 1
local str = rsub(txt, "", "")
while rfind(str, capitals, i) do
local r, _ = rfind(str, capitals, i)
table.insert(uppercase_indices, r)
i = r + 1
end
end
if #uppercase_indices == 0 then
uppercase_indices = nil
end
end
txt = ulower(txt)
-- Prevent palatisation of the special case kwazi-.
tsub("^kwazi", "kwaz-i")
-- falling diphthongs <au> and <eu>, and diacriticised variants
tsub(lg { "()u", csb = "()ù" }, "%1U")
-- rising diphthongs with <iV>
local V = lg {
pl = "aąeęioóuy" .. "áéôûý",
szl = "aãeéioōŏôõuy",
csb = "ôòãëùéóąeyuioa",
slv = "aãeéëêioóõôuúùyăĭŏŭŭùy̆ā",
mas = "aáäeéioóôuûÿ"
}
tsub(("()" .. (lang == "slv" and "j" or "i") .. "()"):format(V, V), "%1I%2")
if txt:find("^*") then
-- The symbol <*> before a word indicates it is unstressed.
unstressed = true
txt = txt:sub(2)
elseif txt:find("^%^+") then
-- The symbol <^> before a word indicates it is stressed on the ante-penult,
-- <^^> on the ante-ante-penult, etc.
ante = txt:gsub("(%^).*", "%1"):len()
txt = txt:sub(ante + 1)
elseif txt:find("^%+") then
-- The symbol <+> indicates the word is stressed regularly on the penult. This is useful
-- for avoiding the following checks to come into place.
txt = txt:sub(2)
else
if tfind(".+.+") then
-- Some words endings trigger stress on the ante-penult or ante-ante-penult regularly.
if tfind("liśmy$") or tfind("yśmy$") or tfind("liście$") or tfind("yście$") then
ante = 2
elseif tfind("by?$") and not tfind("ła?by?$") then
ante = 1
colloquial = false
end
end
-- Recognise <-yka> and its declined form and automatically assign it an antepenult stress.
if tfind(".+.+") and lect == nil then
local endings = lg {
{ "k", "ce", "kach", "kom" },
szl = { "k", "ce", "kacj", "kōm", "kach" },
csb = { "k", "ce", "kacj", "kóm", "kama", "kach" },
slv = { "k", "cê", "kacj", "kji", "kóm", "kóma", "kamy", "kach" }
}
for _, v in ipairs(endings) do
if tfind(("%s$"):format(v)) then
ante = 1
break
end
end
end
if lect == "mpl" then
if tfind(".+j.+") then
local endings = { "", "j", "m", "ach" }
for _, v in ipairs(endings) do
if tfind(("j%s$"):format(v)) then
ante = 1
end
end
end
end
end
-- TODO: mpl, csb, szl, slv, mas
if not txt:find("%.") then
-- Don't recognise affixes whenever there's only one vowel (or dipthong).
local _, n_vowels = rsubn(txt, (""):format(V), "")
if n_vowels > 1 then
-- syllabify common prefixes as separate
local prefixes = {
"do", "wy", "za", "aktyno", "akusto", "akwa", "anarcho", "andro", "anemo", "antropo", "arachno",
"archeo", "archi", "arcy", "areo", "arytmo", "audio", "awio", "balneo", "biblio", "brachy", "broncho",
"ceno", "centro", "centy", "chalko", "chiro", "chloro", "chole", "chondro", "choreo", "chromato",
"chrysto", "cyber", "cyklo", "cztero", "ćwierć", "daktylo", "decy", "deka", "dendro", "dermato",
"diafano", "dwu", "dynamo", "egzo", "ekstra", "elektro", "encefalo", "endo", "entero", "entomo", "ergo",
"erytro", "etno", "farmako", "femto", "ferro", "fizjo", "flebo", "franko", "ftyzjo", "galakto",
"galwano", "germano", "geronto", "giganto", "giga", "gineko", "giro", "gliko", "gloso", "glotto",
"grafo", "granulo", "grawi", "haplo", "helio", "hemato", "hepta", "hetero", "hiper", "histo", "hydro",
"info", "inter", "jedno", "kardio", "kortyko", "kosmo", "krypto", "kseno", "logo", "magneto", "między",
"niby", "nie", "nowo", "około", "oksy", "onto", "ornito", "para", "pierwo", "pięcio", "pneumo", "poli",
"ponad", "post", "poza", "proto", "pseudo", "psycho", "radio", "samo", "sfigmo", "sklero", "staro",
"stereo", "tele", "tetra", "wice", "zoo", "żyro", "ami", "ango", "ant", "a?steno",
"lasto", "chroo", "cys?to", "demo", "h?ekto", "eo", "hiro", "kontra?", "mea",
"mii", "aro", "rzy", "przed?", "wielk?o", "mi?elo", "eur", "nero", "allo", "astro",
"atto", "brio", "heksa", "all?o", "ato", "atro", "br?io", "heksa?", "pato", "ba", "izo",
"myzo", "mkro", "mio", "chemo", "gono", "kilo", "lipo", "nano", "kilk", "hem",
"home?o", "fio", "mao", "hlo", "hip?o", "oo",
-- <na-, po-, o-, u-> would hit too many false positives
}
for _, v in ipairs(prefixes) do
if tfind("^" .. v) then
local _, other_vowels = rsubn(v, (""):format(V), "")
if (n_vowels - other_vowels) > 0 then
tsub(("^(%s)"):format(v), "%1.")
break
end
end
end
if do_hyph then
-- syllabify common suffixes as separate
local suffixes = lg {
pl = {
"nąć",
"tw", "twie", "twm", "twami", "twach",
"dztw", "dztwie", "dztwm", "dztwami", "dztwach",
"dł", "dłm", "dłami", "dłach",
"j", "jom", "jami", "jach",
}, szl = {
"nōńć", "dło",
}, csb = {
"nąc", "dło"
}, slv = {
"nõc", "dlô"
}, mas = {
"nóncz", "dło"
}
}
for _, v in ipairs(suffixes) do
if tsub(("(%s)$"):format(v), ".%1") then break end
end
-- syllabify <istka> as /ist.ka/
if txt:find("st") then
local endings = lg {
{ "k", "ce", "kach", "kom", "kami" },
szl = { "k", "ce", "kami", "kacj", "kacach", "kōma" },
csb = { "k", "ce", "kami", "kacj", "kacach", },
}
for _, v in ipairs(endings) do
if tsub(("()st(%s)$"):format(v), "%1st.%2") then break end
end
end
end
end
end
-- syllabification
for _ = 0, 1 do
tsub(("()(*)()"):format(V, V, V), function (a, b, c)
local function find(x) return rfind(b, x) end
local function is_diagraph(thing)
local r = find(thing:format("z")) or find(thing:format("ch")) or find(thing:format("d"))
if lect == "mpl" then return r or find(thing:format("b́")) end
if lang == "slv" then return r or find(thing:format("gh")) end
if lang == "mas" then return r or find(thing:format("rż")) end
return r
end
if ((ulen(b) < 2) or is_diagraph("^%s$")) then
b = "." .. b
else
local i = 2
if is_diagraph("^%s") then i = 3 end
if usub(b, i, i):find("^$") then
b = "." .. b
else
b = ("%s.%s"):format(usub(b, 0, i - 1), usub(b, i))
end
end
return ("%s%s%s"):format(a, b, c)
end)
end
local hyph
if do_hyph then
-- Ignore certain symbols and diacritics for the hyphenation.
hyph = txt:gsub("'", "."):gsub("-", "")
if lang == "slv" then
local BREVE = u(0x306)
hyph = rsubn(hyph, "", {
= "j",
= "a", = "i", = "o",
= "u", = "", = "a",
})
end
hyph = hyph:lower()
-- Restore uppercase characters.
if uppercase_indices then
-- str_i loops through all the characters of the string
-- list_i loops as above but doesn't count dots
-- array_i loops through the indices at which the capital letters are
local str_i, list_i, array_i = 1, 1, 1
function h_sub(x, y) return usub(hyph, x, y) end
while array_i <= #uppercase_indices do
if h_sub(str_i, str_i) ~= "." then
if list_i == uppercase_indices then
hyph = ("%s%s%s"):format(h_sub(1,str_i-1), uupper(h_sub(str_i,str_i)), h_sub(str_i+1))
array_i = array_i + 1
end
list_i = list_i + 1
end
str_i = str_i + 1
end
end
end
tsub("'", "ˈ")
-- handle digraphs
tsub("ch", "x")
tsub("z", { ="t_ʂ", ="ʂ" })
tsub(lg { "rz", mas = "rż" }, "R")
tsub("d()", "d_%1")
if lect == "mpl" then tsub("b́", "bʲ") end
if lang == "slv" then tsub("gh", "ɣ") end
-- basic orthographical rules
-- not using lg() here for speed
if lang == "pl" then
local replacements = {
-- vowels
="ɛ", ="ɔ",
="ɔN", ="ɛN",
="u", ="ɘ",
-- consonants
="t_s", ="t_ɕ",
="ɲ", ="ɕ", ="ʑ",
="w", ="v", ="ʐ",
="ɡ", ="x",
}
if lect then
replacements = "e"
replacements = "ɒ"
if lect == "mpl" then
replacements = "ɛ̃"
replacements = "ɔ̃"
replacements = "ɨ"
replacements = "o"
replacements = "ɫ"
replacements = "pʲ"
replacements = "mʲ"
replacements = "vʲ"
-- <b́> has no unicode character and is hence handled above
else
replacements = "wɔ"
replacements = "wu"
replacements = "Y"
if data.lects.mid_o then
replacements = "o"
elseif lect == "ekr" then
replacements = "O"
end
if data.lects.front_y then
replacements = "Y"
end
if data.lects.dark_l then
replacements = "ɫ"
replacements = "lʲ"
end
if data.lects.glottal_h then
replacements = "h"
end
end
end
tsub(".", replacements)
elseif lang == "szl" then
tsub(".", {
-- vowels
="ɛ", ="ɔ",
="o", ="O",
="wɔ", = "ɔ̃",
= "ɪ",
-- consonants
="t_s", ="t_ɕ",
="ɲ", ="ɕ", ="ʑ",
="w", ="v", ="ʐ",
="ɡ", ="x",
})
elseif lang == "csb" then
tsub(".", {
-- vowels
="ɛ", ="e", ="ɔ",
="o", ="ɞ", ="ɜ",
="wɛ", ="wu", = "Y",
= "ɔ̃",
-- consonants
="t_s", ="t_ɕ",
="ɲ", ="ɕ", ="ʑ",
="w", ="v", ="ʒ",
="ɡ", ="x",
})
elseif lang == "slv" then
tsub(".", {
-- vowels
="ɛ", ="e", ="ɔ",
="o", ="ɵ", ="ə", ="E",
="ɪ", ="ʉ", ="y",
="ɔ̃", ="y̆", ="aː", -- ãăĭŏŭ
-- consonants
="t_s",
="n",
="v", ="ʒ",
="ɡ", ="x",
})
elseif lang == "mas" then
tsub(".", {
-- vowels
="ɒ", ="æ",
="ɛ", ="e",
="ɔ", ="o",
="wɔ", ="Y",
="Y", ="wu",
-- consonants
="t_s",
="ɲ", ="ʃ",
="w", ="v", ="ʒ",
="ɡ", ="x", ="ʑ",
})
end
if lang == "csb" or lang == "slv" or lang == "mas" then
tsub("ʂ", "ʃ")
tsub("ʐ", "ʒ")
end
-- palatalisation
local palatise_into = { = "ɲ", = "ɕ", = "ʑ" }
tsub("()I", function (c) return palatise_into end)
tsub("()i", function (c) return palatise_into .. "i" end)
-- voicing and devoicing
local T = "pftsʂɕkxʃx"
local D = "bdzʐʑɡʒɣ"
tsub(("(?)v"):format(T), "%1f")
tsub(("(?)R"):format(T), "%1S")
if lang == "slv" then
tsub(("(?)ɣ"):format(T), "%1x")
tsub(("(?)x"):format(D), "%1ɣ")
end
local function arr_list(x)
local r = ""
for i in pairs(x) do
r = r .. i
end
return r
end
local devoice = {
= "p",
= "t",
= "k",
= "s",
= "f",
= "ɕ",
= "ʂ",
= "ʃ",
= "S",
}
local trilled_rz = lang == "csb" or lang == "slv" or lang == "mas"
if not trilled_rz and lect then
trilled_rz = data.lects.trilled_rz
end
if trilled_rz then
devoice = nil
end
if lang == "slv" then
devoice = "x"
end
local mpl_J = lect == "mpl" and "ʲ?" or ""
local arr_list_devoice = arr_list(devoice)
if not is_prep then
tsub(("()(%s)$"):format(arr_list_devoice, mpl_J), function (a, b)
return devoice .. (type(b) == "string" and b or "")
end)
end
tsub("Y", "i")
if lang == "csb" then
tsub("()o", "%1wo")
tsub("vw", "w")
end
if lang == "slv" then
local V = "aɛeɔ̃oɵəEɪiʉuyã"
tsub("nj$", "n")
tsub("nj()", "n%1")
tsub("ɲ()", "nj%1")
tsub("ɛ$", "ə")
end
if trilled_rz then
tsub("R", "r̝")
end
if lect ~= "mpl" then
tsub("S", "ʂ")
tsub("R", "ʐ")
end
local voice = {}
for i, v in pairs(devoice) do
voice = i
end
local new_text
local devoice_string = ("()(%s?)"):format(arr_list_devoice, mpl_J, T)
local voice_string = ("()(%s?)"):format(arr_list(voice), mpl_J, D)
local function devoice_func(a, b) return devoice .. b end
local function voice_func(a, b) return voice .. b end
while txt ~= new_txt do
new_txt = txt
tsub(devoice_string, devoice_func)
tsub(voice_string, voice_func)
end
if lang == "pl" then
-- nasal vowels
tsub("N(?)", "m%1")
tsub("N(?)", "ɲ%1")
tsub("N(?_)", "ɲ%1")
tsub("N(?)", "n%1")
tsub("N(?)", "%1")
tsub("ɛN$", "ɛ")
tsub("N", "w̃")
end
-- Hyphen separator, e.g. to prevent palatisation of <kwazi->.
tsub("-", "")
tsub("_", OVERTIE)
tsub("I", "j")
tsub("U", "w")
-- Handles stress.
local function add_stress(stressed_syllable, force_initial_stress)
local stressed_txt
if force_initial_stress or (lect and data.lects.initial_stress) then
-- Deals with initially stressed lects.
stressed_txt = "ˈ" .. txt
else
-- Accent elsewhere, usually ante-penult although can vary depending on
-- the <stressed_syllable> value, counting backwards.
local regex = ""
for _ = 0, stressed_syllable do
regex = regex .. "+%."
end
stressed_txt = rsub(txt, "%.(" .. regex .. "+)$", "ˈ%1")
-- If no stress mark could have been placed, it can only be initial,
-- e.g. in monosyllables.
if not rfind(stressed_txt, "ˈ") then
stressed_txt = "ˈ" .. stressed_txt
end
end
return stressed_txt
end
local should_stress = not (unstressed or txt:find("ˈ"))
local prons = should_stress and add_stress(ante) or txt
if is_prep then
prons = prons .. "$"
end
if lang == "pl" then
if lect then
if lect == "ekr" then
if tfind("O") then
prons = { (prons:gsub("O", "o")), (prons:gsub("O", "u")) }
end
elseif lect == "ora" or lect == "zag" then
local stressed_initially = add_stress(0, true)
if stressed_initially ~= prons then
prons = lect == "ora" and { stressed_initially, prons } or { prons, stressed_initially }
end
elseif lect == "mpl" then
if tfind("") then
local mp_early = prons:gsub("", "r̝")
local mp_late = prons:gsub("R", "ʐ"):gsub("S", "ʂ")
if period == "early" then
prons = mp_early
elseif period == "late" then
prons = mp_late
elseif not period then
prons = {
mp_early, mp_late,
}
else
error(("'%s' is not a supported Middle Polish period, try with 'early' or 'late'."):format(period))
end
end
end
else
if should_stress and ante > 0 and colloquial then
local stressed_antepenult = add_stress(0)
if stressed_antepenult ~= prons then
prons = { prons, stressed_antepenult }
end
end
end
elseif lang == "szl" then
if tfind("O") then
prons = {
(prons:gsub("O", "ɔ")),
(prons:gsub("O", "ɔw")),
(prons:gsub("O", "ɛw")),
}
end
elseif lang == "slv" then
if tfind("E") then
local V = "aɛeɔ̃oɵəEɪiʉuyã"
prons = prons:gsub("ˈ(*)E", "ˈ%1i̯ɛ")
prons = prons:gsub("E$", "ə")
prons = prons:gsub("E", "ɛ")
end
end
if do_hyph then
return prons, hyph
else
return prons
end
end
-- TODO: This might slow things down if used too much?
local function table_insert_if_absent(t, s)
for _, v in ipairs(t) do
if v == s then return end
end
table.insert(t, s)
end
-- Returns rhyme from a transcription.
local function do_rhyme(pron, lang)
local V = ({ pl = "aɛiɔuɘ", szl = "aãɛiɔouɪ", csb = "aãɛeɜiɔoõɞu", slv = "aãɛeĭɪŏɔɵŭʉy", mas = "aɒæɛeiɔou"})
return {
rhyme = rsub(rsub(rsub(pron, "^.*ˈ", ""), ("^-()"):format(V, V), "%1"), "%.", ""),
num_syl = { select(2, rsubn(pron, (""):format(V), "")) }
}
end
--[[
Handles a single input, returning a table of transcriptions. Returns also a string of
hyphenation and a table of rhymes if it is a single-word term.
--]]
local function multiword(term, lang, period, lect)
if term:find("^%$") then
return { phonetic = term }
elseif term:find(" ") then
-- TODO: repeated
function lg(s)
return s or s
end
local prepositions = lg {
{
"beze?", "na", "dla", "do", "ku", "nade?", "o", "ode?", "po", "pode?", "przede?", "przeze?", "przy",
"spode?", "u", "we?", "z?", "znade?", "zza",
}, szl = {
"bezy?", "na", "dlŏ", "d", "ku", "nady?", "ô", "ôdy?", "po", "pody?", "przedy?", "przezy?", "przi",
"spody?", "u", "w?", "z?", "", "znady?"
}, csb = {
"beze?", "na", "dlô", "do", "kù", "nade?", "ò", "òde?", "pò", "pòde?", "przede?", "przeze?", "przë",
"spòde?", "ù", "we?", "wew", "z?", "zez", "zeza", "zó", "znade?"
}, slv = {
"dlo", "dô", "na", "nade?", "przêde?", "przêze?", "przë", "pô", "pôde?", "sê?", "vô", "we?", "wôde?",
"wù", "za"
}, mas = {
"dlá", "do", "ku", "na", "nade?", "po", "pode?", "ponade?", "poza", "prżede?", "prżeze", "prżi", "we?",
"ze?", "za", "ô", "ôde?", "û", "beze?"
}
}
local p
local contains_preps = false
for word in term:gmatch("+") do
local is_prep = false
for _, prep in ipairs(prepositions) do
if (rfind(word, ("^%s$"):format(prep))) then
is_prep = true
contains_preps = true
break
end
end
local v = phonemic(word, false, lang, is_prep, period, lect)
local sep = "%s %s"
if p == nil then
p = v
elseif type(p) == "string" then
if type(v) == "string" then
p = sep:format(p, v)
else
p = { sep:format(p, v), sep:format(p, v) }
end
else
if type(v) == "string" then
p = { sep:format(p, v), sep:format(p, v) }
else
p = { sep:format(p, v), sep:format(p, v) }
end
end
end
local function assimilate_preps(str)
local function assim(from, to, before)
str = rsub(str, ("%s(%%$ ˈ?)"):format(from, before), to .. "%1")
end
local T = "ptsʂɕkx"
assim("d", "t", T)
assim("v", "f", T)
assim("z", "s", T)
if lang == "szl" then
local D = "bdzʐʑɡ"
assim("s", "z", D)
assim("ɕ", "ʑ", D)
end
return rsub(str, "%$", "")
end
if contains_preps then
if type(p) == "string" then
p = assimilate_preps(p)
else
p = assimilate_preps(p)
p = assimilate_preps(p)
end
end
return p
else
return phonemic(term, lect ~= "mpl", lang, false, period, lect)
end
end
-- This handles all the magic characters <*>, <^>, <+>, <.>, <#>.
local function normalise_input(term, pagename)
local function check_af(str, af, reg, repl, err_msg)
reg = reg:format(af)
if not rfind(str, reg) then
error(("the word does not %s with %s!"):format(err_msg, af))
end
return str:gsub(reg, repl)
end
local function check_pref(str, pref) return check_af(str, pref, "^(%s)", "%1.", "start") end
local function check_suf(str, suf) return check_af(str, suf, "(%s)$", ".%1", "end") end
if term == "#" then
-- The diesis stands simply for {{PAGENAME}}.
return pagename
elseif (term == "+") or term:find("^%^+$") or (term == "*") then
-- Inputs that are just '+', '*', '^', '^^', etc. are treated as
-- if they contained the pagename with those symbols preceding it.
return term .. pagename
-- Handle syntax like <po.>, <.ka> and <po..ka>. This allows to not respell
-- the entire word when all is needed is to specify syllabification of a prefix
-- and/or a suffix.
elseif term:find(".+%.$") then
return check_pref(pagename, term:sub(1, -2))
elseif term:find("^%..+") then
return check_suf(pagename, term:sub(2))
elseif term:find(".+%.%..+") then
return check_suf(check_pref(pagename, term:gsub("%.%..+", "")), term:gsub(".+%.%.", ""))
end
return term
end
-- This converts the raw information, the arguments and pagename, into tables to be handed over to the IPA module.
-- It is called externally by ].
function export.get_lect_pron_info(lang_code, pagename, args_terms, args_quals, args_refs, args_period, lect_code)
if #args_terms == 1 and args_terms == "-" then
return nil, {}, {}, false
end
local pron_list = {{}}
local rhyme_list = {{}}
local hyph_list = {}
local do_hyph = false
local brackets = "/%s/"
if lect_code then
if data.lects.phonetic then
brackets = ""
end
end
-- Loops over the terms given as arguments.
for arg_index, arg_term in ipairs(args_terms) do
-- Handles magic symbols in the input.
arg_term = normalise_input(arg_term, pagename)
-- Obtains the transcription and hyphenation for the current index.
local prons, hyph = multiword(arg_term, lang_code, args_period, lect_code)
-- Obtains the possible qualifiers of the current index, separated by semicolon.
local qualifiers = {}
if args_quals then
for qual in args_quals:gmatch("+") do
table.insert(qualifiers, qual)
end
end
-- Return a single phonemic transcription with qualifiers and references
-- attached to it. An additional qualifier may be specified, which is for the
-- regular oscillations (e.g. Middle Polish <rz>, etc.). The references can
-- be omitted (if it's the second transcription of a regular oscillation).
local function new_pron(pron, additional_qualifier, dont_refs)
local bracketed_pron = brackets:format(pron)
-- Strip away syllable dividers, but return a version with the syllable dividers for
-- comparison purposes with the old {{pl-p}}. FIXME: IMO we should be including the
-- syllable dividers in the phonemic output.
local bracketed_pron_no_syldivs = bracketed_pron:gsub("%.", "")
local ret = {
pron = bracketed_pron_no_syldivs,
pron_with_syldivs = bracketed_pron,
qualifiers = qualifiers,
refs = not dont_refs and {args_refs},
}
if additional_qualifier then
local new_qualifiers = {unpack(qualifiers)}
table.insert(new_qualifiers, additional_qualifier)
ret.qualifiers = new_qualifiers
end
return ret
end
-- If the <prons> variable is a string it means only one transcription
-- was given.
if type(prons) == "string" then
table.insert(pron_list, new_pron(prons))
table.insert(rhyme_list, do_rhyme(prons, lang_code))
-- If the <pron> variable is a table and has a <phonetic> value, then simply return that.
elseif prons.phonetic then
table.insert(pron_list, {
pron = prons.phonetic,
qualifiers = qualifiers,
refs = {args_refs},
})
-- If the <prons> variably is a table and does not have a <phonetic> value, it is
-- a list of transcriptions.
else
local multiple_transcript = ({
pl = { "prescribed", "casual" },
szl = { nil, "Western", "Głogówek"},
})
if lang_code == "pl" and lect_code then
multiple_transcript = ({
mpl = { "16<sup>th</sup> c.", "17<sup>th</sup>–18<sup>th</sup> c." },
ekr = { "pre-21<sup>st</sup> c.", "21<sup>st</sup> c."},
ora = { "Poland", "Slovakia" },
zag = { "north", "south" },
})
end
for i, v in ipairs(prons) do
if #pron_list < (i + 1) then pron_list = {} end
table.insert(pron_list, new_pron(v, multiple_transcript, i ~= 1))
if #rhyme_list < (i + 1) then rhyme_list = {} end
table.insert(rhyme_list, do_rhyme(v, lang_code))
end
end
-- If a hyphenation value had been returned by the <multiword> function, it means
-- that in any case a hyphenation is required (i.e. it is not a multiword term nor is
-- the hyphenation manually turned off, etc.). If the hyphenation value acquired however
-- does not match the pagename, it is not added to the table.
if hyph then
do_hyph = true
if hyph:gsub("%.", "") == pagename then
table_insert_if_absent(hyph_list, hyph)
end
end
end
-- TODO: looks rather slow.
local function merge_subtables(t)
if #t == 1 then
return t
end
local r = {}
for _, subtable in ipairs(t) do
for _, value in ipairs(subtable) do
table.insert(r, value)
end
end
return r
end
pron_list = merge_subtables(pron_list)
rhyme_list = merge_subtables(rhyme_list)
return pron_list, hyph_list, rhyme_list, do_hyph
end
function export.get_lect_pron_info_bot(frame)
local iargs = require("Module:parameters").process(frame.args, {
= { default = "pl" },
= {},
= { list = true },
= { list = true, allow_holes = true },
= { list = true, allow_holes = true, alias_of = "qual" },
= {},
= { list = true, allow_holes = true },
= {}, -- for debugging or demonstration only
= { list = true },
})
local terms = iargs
if #terms == 0 then
terms = { "#" }
end
local pron_list, hyph_list, rhyme_list, do_hyph = export.get_lect_pron_info(
iargs.lang,
iargs.pagename or mw.loadData("Module:headword/data").pagename,
terms,
iargs.qual,
iargs.ref,
iargs.period,
iargs.lect
)
local retval = {
pron_list = pron_list,
hyph_list = hyph_list,
rhyme_list = rhyme_list,
do_hyph = do_hyph,
}
if iargs.plp then
retval.plp_prons = {}
for _, plp in ipairs(iargs.plp) do
table.insert(retval.plp_prons, "/" .. require("Module:pl-IPA").convert_to_IPA(plp) .. "/")
end
end
return require("Module:JSON").toJSON(retval)
end
-- This is the function used by the template {{zlw-mpl-IPA}}.
-- TODO: the template should be deprecated in favour of the new pl-pr template.
function export.mpl_IPA(frame)
local args = require("Module:parameters").process(frame:getParent().args, {
= { list = true },
= { list = true, allow_holes = true },
= { list = true, allow_holes = true, alias_of = "qual" },
= {},
= { list = true, allow_holes = true },
= {}, -- for debugging or demonstration only
})
local terms = args
if #terms == 0 then
terms = { "#" }
end
local lang = require("Module:languages").getByCode("pl")
return ("* %s %s"):format(
require("Module:accent qualifier").format_qualifiers(lang, {"Middle Polish"}),
require("Module:IPA").format_IPA_full {
lang = lang,
items = (export.get_lect_pron_info(
"pl",
args.pagename or mw.loadData("Module:headword/data").pagename,
terms,
args.qual,
args.ref,
args.period,
"mpl"
)),
}
)
end
-- Remove any HTML from the formatted text and resolve links, since the extra characters don't contribute to the
-- displayed length.
local function convert_to_raw_text(text)
text = rsub(text, "<.->", "")
if text:find("%[%[") then
text = require(links_module).remove_links(text)
end
return text
end
-- Return the approximate displayed length in characters.
local function textual_len(text)
return ulen(convert_to_raw_text(text))
end
function export.IPA(frame)
local arg_lang = frame.args.lang
if arg_lang == "pl" then
data = require("Module:zlw-lch-IPA/data/pl")
end
local process_args = {
= { list = true },
= { list = true, allow_holes = true },
= { list = true, allow_holes = true, alias_of = "qual" },
= { list = true, allow_holes = true },
= {}, = { alias_of = "hyphs" },
= {}, = { alias_of = "rhymes" },
= {}, = { alias_of = "audios" },
= {}, = { alias_of = "homophones" },
= {}, -- for debugging or demonstration only
}
if arg_lang == "pl" then
process_args = {}
process_args = { alias_of = "mpl_period" }
for lect_code, _ in pairs(data.lects) do
process_args = {list = true}
process_args = { list = true, allow_holes = true }
process_args = { list = true, allow_holes = true, alias_of = lect_code .. "_qual" }
process_args = { list = true, allow_holes = true }
end
for alias_code, lect_code in pairs(data.lect_aliases) do
process_args = { list = true, alias_of = lect_code }
process_args = { list = true, allow_holes = true, alias_of = lect_code .. "_qual" }
process_args = { list = true, allow_holes = true, alias_of = lect_code .. "_qual" }
process_args = { list = true, allow_holes = true, alias_of = lect_code .. "_ref" }
end
end
local args = require("Module:parameters").process(frame:getParent().args, process_args)
local lang = require("Module:languages").getByCode((arg_lang == "slv" or arg_lang == "mas") and ("zlw-" .. arg_lang) or arg_lang)
local terms = args
local pagename = args.pagename or mw.loadData("Module:headword/data").pagename
if #terms == 0 then
terms = { "#" }
end
local pron_list, hyph_list, rhyme_list, do_hyph =
export.get_lect_pron_info(arg_lang, pagename, terms, args.qual, args.ref)
local pl_lect_prons
if arg_lang == "pl" then
for lect_code, _ in pairs(data.lects) do
if #args > 0 then
if pl_lect_prons == nil then pl_lect_prons = {} end
pl_lect_prons = export.get_lect_pron_info(
"pl",
pagename,
args,
args,
args,
args,
lect_code
)
end
end
end
if args.hyphs then
if args.hyphs == "-" then
do_hyph = false
else
hyph_list = {}
for v in args.hyphs:gmatch("+") do
table.insert(hyph_list, v)
end
do_hyph = true
end
end
if args.rhymes then
if args.rhymes == "-" then
rhyme_list = {}
elseif args.rhymes ~= "+" then
rhyme_list = {}
for v in args.rhymes:gmatch("+") do
if rfind(v, ".+/.+") then
table.insert(rhyme_list, {
rhyme = rsub(v, "/.+", ""),
num_syl = { tonumber(rsub(v, ".+/", "")) },
})
else
error(("The manual rhyme %s did not specify syllable number as RHYME/NUM_SYL."):format(v))
end
end
end
end
-- This deals with duplicate values in rhymes.
if #rhyme_list > 0 then
local temp_rhyme_list = {}
local indices = {}
for _, v in ipairs(rhyme_list) do
local index = indices
if index == nil then
table.insert(temp_rhyme_list, v)
indices = #temp_rhyme_list
else
local different_num_syl = true
for _, ns in ipairs(temp_rhyme_list.num_syl) do
if ns == v.num_syl then
different_num_syl = false
break
end
end
if different_num_syl then
table.insert(temp_rhyme_list.num_syl, v.num_syl)
end
end
end
rhyme_list = temp_rhyme_list
end
local m_IPA_format = require("Module:IPA").format_IPA_full
local ret = ""
local do_collapse = false
if pron_list then
if pl_lect_prons then
do_collapse = true
ret = '<div class="vsSwitcher" data-toggle-category="pronunciations" style="width: {width}em; max-width:100%;"><span class="vsToggleElement" style="float: right;"> </span>\n'
end
ret = ret .. "*" .. m_IPA_format { lang = lang, items = pron_list }
end
if pl_lect_prons then
if do_collapse then
ret = ret .. '\n<div class="vsHide">\n'
end
local m_format_qualifiers = require("Module:accent qualifier").format_qualifiers
-- First groups the lects into their lect groups.
local grouped_lects = {}
for lect_code, lect_prons in pairs(pl_lect_prons) do
local lect_group = data.lects.group
if grouped_lects == nil then grouped_lects = {} end
table.insert(grouped_lects, { code = lect_code, prons = lect_prons })
end
-- And then displays each group in order.
local maxlen = 0
local function display_lect(value, indentation)
local formatted = ("%s%s %s"):format(indentation,
m_format_qualifiers(lang, { data.lects.name }),
m_IPA_format { lang = lang, items = value.prons }
)
maxlen = math.max(maxlen, textual_len(formatted))
ret = ret .. "\n" .. formatted
end
for group_index = 1, #data.lect_groups do
local lects = grouped_lects
local group = data.lect_groups
if lects ~= nil then
if group.single_lect then
display_lect(lects, "*")
else
-- Checks to indent Goral under Lesser Polish.
additional_indent = ""
if group.indent_with_prec then
additional_indent = "*"
if grouped_lects == nil then
ret = ret .. "\n*" .. m_format_qualifiers(lang, { data.lect_groups.name }) .. ":"
end
end
-- Lect group header.
ret = ret .. "\n*" .. additional_indent ..
m_format_qualifiers(lang, { group.name }) .. ":"
-- The lects are sorted according to their <index> value.
table.sort(lects, function (a, b) return data.lects.index < data.lects.index end)
for _, lect in ipairs(lects) do
display_lect(lect, "**" .. additional_indent)
end
end
end
end
if do_collapse then
ret = ret .. '\n</div></div>\n'
end
local em_length = math.floor(maxlen * 0.68)
ret = m_str_utils.gsub(ret, "{width}", em_length)
end
if args.audios then
local format_audio = require("Module:audio").format_audio
local audio_index = 1
for audio in args.audios:gmatch("+") do
local caption = "Audio " .. audio_index
if audio:find("<+>$") then
caption = caption .. ", ''" ..
(audio:match("<(+)>$"))
:gsub("#", pagename)
:gsub("~", pagename .. " się")
.. "''"
audio = (audio:gsub("<+>$", ""))
end
ret = ("%s\n*%s"):format(ret, format_audio {
lang = lang,
file = audio:gsub("#", pagename),
caption = caption,
})
audio_index = audio_index + 1
end
end
if #rhyme_list > 0 then
ret = ("%s\n*%s"):format(ret, require("Module:rhymes").format_rhymes { lang = lang, rhymes = rhyme_list })
end
if do_hyph then
ret = ret .. "\n*"
if #hyph_list > 0 then
local hyphs = {}
for hyph_i, hyph_v in ipairs(hyph_list) do
hyphs = { hyph = {} }
for syl_v in hyph_v:gmatch("+") do
table.insert(hyphs.hyph, syl_v)
end
end
ret = ret .. require("Module:hyphenation").format_hyphenations {
lang = lang, hyphs = hyphs, caption = "Syllabification"
}
else
ret = ret .. "Syllabification: <small></small>"
if mw.title.getCurrentTitle().nsText == "" then
ret = ("%s]"):format(ret, arg_lang)
end
end
end
if args.homophones then
local homophone_list = {}
for v in args.homophones:gmatch("+") do
if v:find("<.->$") then
table.insert(homophone_list, {
term = v:gsub("<.->$", ""),
qualifiers = { (v:gsub(".+<(.-)>$", "%1")) },
})
else
table.insert(homophone_list, { term = v })
end
end
ret = ("%s\n*%s"):format(ret, require("Module:homophones").format_homophones {
lang = lang,
homophones = homophone_list,
})
end
return ret
end
return export