This module automatically converts Bulgarian orthography to a phonetic transcription in the International Phonetic Alphabet. It also generates hyphenations and syllabifications. It supports generating all various parts of pronunciation sections together, including the above and audio and rhymes, using the show_all entry point.
local export = {}
local substring = mw.ustring.sub
local rsubn = mw.ustring.gsub
local rmatch = mw.ustring.match
local rsplit = mw.text.split
local rlen = mw.ustring.len
local U = require("Module:string/char")
local lang = require("Module:languages").getByCode("bg")
local script = require("Module:scripts").getByCode("Cyrl")
local ipa_module = "Module:IPA"
local audio_module = "Module:audio"
local headword_data_module = "Module:headword/data"
local homophones_module = "Module:homophones"
local hyphenation_module = "Module:hyphenation"
local parameters_module = "Module:parameters"
local rhymes_module = "Module:rhymes"
local table_module = "Module:table"
local tracking_module = "Module:debug/track"
local GRAVE = U(0x300)
local ACUTE = U(0x301)
local BREVE = U(0x306)
local PRIMARY = U(0x2C8)
local SECONDARY = U(0x2CC)
local TIE = U(0x361)
local FRONTED = U(0x31F)
local DOTUNDER = U(0x323)
local HYPH = U(0x2027)
local BREAK_MARKER = "."
local vowels = "aɤɔuɛiɐo"
local vowels_c = "[" .. vowels .. "]"
local cons = "bvɡdʒzjklɫwmnprstfxʃɣʲ" .. TIE
local cons_c = "[" .. cons .. "]"
local hcons_c = "[бвгджзйклмнпрстфхшщьчц#БВГДЖЗЙКЛМНПРСТФХШЩЬЧЦ=]"
local hvowels_c = "[аъоуеияѝюАЪОУЕИЯЍЮ]"
local capital_letters_c = "[БВГДЖЗЙКЛМНПРСТФХШЩЬЧЦАЪОУЕИЯЍЮ]"
local accents = PRIMARY .. SECONDARY
local accents_c = "[" .. accents .. "]"
-- single characters that map to IPA sounds
local phonetic_chars_map = {
["а"] = "a",
["б"] = "b",
["в"] = "v",
["г"] = "ɡ",
["д"] = "d",
["е"] = "ɛ",
["ж"] = "ʒ",
["з"] = "z",
["и"] = "i",
["й"] = "j",
["к"] = "k",
["л"] = "l",
["м"] = "m",
["н"] = "n",
["о"] = "ɔ",
["п"] = "p",
["р"] = "r",
["с"] = "s",
["т"] = "t",
["у"] = "u",
["ў"] = "w",
["ф"] = "f",
["х"] = "x",
["ц"] = "t" .. TIE .. "s",
["ч"] = "t" .. TIE .. "ʃ",
["ш"] = "ʃ",
["щ"] = "ʃt",
["ъ"] = "ɤ",
["ь"] = "ʲ",
["ю"] = "ʲu",
["я"] = "ʲa",
[GRAVE] = SECONDARY,
[ACUTE] = PRIMARY
}
local devoicing = {
["b"] = "p", ["d"] = "t", ["ɡ"] = "k",
["z"] = "s", ["ʒ"] = "ʃ",
["v"] = "f"
}
local voicing = {
["p"] = "b", ["t"] = "d", ["k"] = "ɡ",
["s"] = "z", ["ʃ"] = "ʒ", ["x"] = "ɣ",
["f"] = "v"
}
-- Prefixes where, if they occur at the beginning of the word and the stress is on the next syllable, we place the
-- syllable division directly after the prefix. For example, the default syllable-breaking algorithm would convert
-- безбра́чие to беˈзбрачие; but because it begins with без-, we convert it to безˈбрачие. Note that we don't (yet?)
-- convert измра́ to изˈмра instead of default измˈра, although we probably should.
--
-- Think twice before putting prefixes like на-, пре- and от- here, because of the existence of над-, пред-, and о-,
-- which are also prefixes.
local IPA_prefixes = {"bɛz", "vɤz", "vɤzproiz", "iz", "naiz", "poiz", "prɛvɤz", "proiz", "raz"}
-- 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
-- version of rsubn() that discards all but the count value
local function count_matches(term, pattern)
local _, match_count = rsubn(term, pattern, "")
return match_count
end
-- apply rsub() repeatedly until no change
local function rsub_repeatedly(term, foo, bar)
while true do
local new_term = rsub(term, foo, bar)
if new_term == term then
return term
end
term = new_term
end
end
local function char_at(str, index)
return substring(str, index, index)
end
local function starts_with(str, substr)
return substring(str, 1, rlen(substr)) == substr
end
local function count_vowels(word)
return count_matches(word, hvowels_c)
end
local function count_capital_letters(word)
return count_matches(word, capital_letters_c)
end
local function count_accents(ipa)
return count_matches(ipa, accents_c)
end
local function count_ipa_vowels(ipa)
return count_matches(ipa, vowels_c)
end
function export.remove_pron_notations(text, remove_grave)
text = rsub(text, "[." .. DOTUNDER .. "]", "")
text = rsub(text, "ў", "у")
text = rsub(text, "Ў", "У")
-- Remove grave accents from annotations but maybe not from phonetic respelling
if remove_grave then
text = mw.ustring.toNFC(rsub(mw.ustring.toNFD(text), GRAVE, ""))
end
return text
end
function export.toIPA(term, endschwa)
if type(term) == "table" then -- called from a template or a bot
endschwa = term.args.endschwa
term = term.args[1]
end
local origterm = term
term = mw.ustring.toNFD(mw.ustring.lower(term))
term = rsub(term, "у" .. BREVE, "ў") -- recompose ў
term = rsub(term, "и" .. BREVE, "й") -- recompose й
if term:find(GRAVE) and not term:find(ACUTE) then
error("Use acute accent, not grave accent, for primary stress: " .. origterm)
end
-- allow DOTUNDER to signal same as endschwa=1
term = rsub(term, "а(" .. accents_c .. "?)" .. DOTUNDER, "ъ%1")
term = rsub(term, "я(" .. accents_c .. "?)" .. DOTUNDER, "ʲɤ%1")
term = rsub(term, ".", phonetic_chars_map)
-- Mark word boundaries
term = rsub(term, "(%s+)", "#%1#")
term = "#" .. term .. "#"
-- Convert verbal and definite endings
if endschwa then
term = rsub(term, "a(" .. PRIMARY .. "?t?#)", "ɤ%1")
end
-- Change ʲ to j after vowels or word-initially
term = rsub(term, "([" .. vowels .. "#]" .. accents_c .. "?)ʲ", "%1j")
-------------------- Move stress ---------------
-- First, move leftwards over the vowel.
term = rsub(term, "(" .. vowels_c .. ")(" .. accents_c .. ")", "%2%1")
-- Then, move leftwards over j or soft sign.
term = rsub(term, "([jʲ])(" .. accents_c .. ")", "%2%1")
-- Then, move leftwards over a single consonant.
term = rsub(term, "(" .. cons_c .. ")(" .. accents_c .. ")", "%2%1")
-- Then, move leftwards over Cl/Cr combinations where C is an obstruent (NOTE: IPA ɡ).
term = rsub(term, "([bdɡptkxfv]" .. ")(" .. accents_c .. ")([rl])", "%2%1%3")
-- Then, move leftwards over kv/gv (NOTE: IPA ɡ).
term = rsub(term, "([kɡ]" .. ")(" .. accents_c .. ")(v)", "%2%1%3")
-- Then, move leftwards over sC combinations, where C is a stop or resonant (NOTE: IPA ɡ).
term = rsub(term, "([sz]" .. ")(" .. accents_c .. ")([bdɡptkvlrmn])", "%2%1%3")
-- Then, move leftwards over affricates not followed by a consonant.
term = rsub(term, "([td]" .. TIE .. "?)(" .. accents_c .. ")([szʃʒ][" .. vowels .. "ʲ])", "%2%1%3")
-- If we ended up in the middle of a tied affricate, move to its right.
term = rsub(term, "(" .. TIE .. ")(" .. accents_c .. ")(" .. cons_c .. ")", "%1%3%2")
-- Then, move leftwards over any remaining consonants at the beginning of a word.
term = rsub(term, "#(" .. cons_c .. "*)(" .. accents_c .. ")", "#%2%1")
-- Then correct for known prefixes.
for _, prefix in ipairs(IPA_prefixes) do
local prefix_prefix, prefix_final_cons = rmatch(prefix, "^(.-)(" .. cons_c .. "*)$")
if prefix_final_cons then
-- Check for accent moved too far to the left into a prefix, e.g. безбрачие accented as беˈзбрачие instead
-- of безˈбрачие
term = rsub(term, "#(" .. prefix_prefix .. ")(" .. accents_c .. ")(" .. prefix_final_cons .. ")", "#%1%3%2")
end
end
-- If the previous substitution resulted in a stress occuring immediately after a consonant
-- but before a palatalizer mark, then put the stress before the consonant.
term = rsub(term, "(" .. cons_c .. ")" .. "(" .. accents_c .. ")" .. "ʲ", "%2%1ʲ")
-- Finally, if there is an explicit syllable boundary in the cluster of consonants where the stress is, put it there.
-- First check for accent to the right of the explicit syllable boundary.
term = rsub(term, "(" .. cons_c .. "*)%.(" .. cons_c .. "*)(" .. accents_c .. ")(" .. cons_c .. "*)", "%1%3%2%4")
-- Then check for accent to the left of the explicit syllable boundary.
term = rsub(term, "(" .. cons_c .. "*)(" .. accents_c .. ")(" .. cons_c .. "*)%.(" .. cons_c .. "*)", "%1%3%2%4")
-- Finally, remove any remaining syllable boundaries.
term = rsub(term, "%.", "")
-------------------- Vowel reduction (in unstressed syllables) ---------------
local function reduce_vowel(vowel)
return rsub(vowel, "[aɔɤu]", { ["a"] = "ɐ", ["ɔ"] = "o", ["ɤ"] = "ɐ", ["u"] = "o" })
end
-- Reduce all vowels before the stress, except if the word has no accent at all. (FIXME: This is presumably
-- intended for single-syllable words without accents, but if the word is multisyllabic without accents,
-- presumably all vowels should be reduced.)
term = rsub(term, "(#[^#" .. accents .. "]*)(.-#)", function(a, b)
if count_vowels(origterm) <= 1 then
return a .. b
else
return reduce_vowel(a) .. b
end
end)
-- Reduce all vowels after the accent except the first vowel after the accent mark (which is stressed).
term = rsub(term, "(" .. accents_c .. "[^aɛiɔuɤ#]*[aɛiɔuɤ])([^#" .. accents .. "]*)", function(a, b)
return a .. reduce_vowel(b)
end)
-------------------- Vowel assimilation to adjacent consonants (fronting/raising) ---------------
term = rsub(term, "([ʃʒʲj])([aouɤ])", "%1%2" .. FRONTED)
-- Hard l
term = rsub_repeatedly(term, "l([^ʲɛi])", "ɫ%1")
-- Voicing assimilation
term = rsub(term, "([bdɡzʒv" .. TIE .. "]*)(" .. accents_c .. "?[ptksʃfx#])", function(a, b)
return rsub(a, ".", devoicing) .. b end)
term = rsub(term, "([ptksʃfx" .. TIE .. "]*)(" .. accents_c .. "?[bdɡzʒ])", function(a, b)
return rsub(a, ".", voicing) .. b end)
term = rsub(term, "n(" .. accents_c .. "?[ɡk]+)", "ŋ%1")
term = rsub(term, "m(" .. accents_c .. "?[fv]+)", "ɱ%1")
-- Sibilant assimilation
term = rsub(term, "[sz](" .. accents_c .. "?[td]?" .. TIE .. "?)([ʃʒ])", "%2%1%2")
-- Reduce consonant clusters
term = rsub(term, "([szʃʒ])[td](" .. accents_c .. "?)([tdknml])", "%2%1%3")
-- Strip hashes
term = rsub(term, "#", "")
return term
end
----Syllabification code----
-- Authorship: Chernorizets
-- Lua port: Kiril Kovachev
local function set_of(t)
local out = {}
for _, v in pairs(t) do
out[v] = true
end
return out
end
local function in_set(set, value)
return set[value] == true
end
-- Classification of letters by phonetic category
local vowels_syllab = set_of {"а", "ъ", "о", "у", "е", "и", "ю", "я"}
local sonorants = set_of { "л", "м", "н", "р", "й", "ў"}
local stops = set_of {"б", "п", "г", "к", "д", "т"}
local fricatives = set_of {"в", "ф", "ж", "ш", "з", "с", "х"}
local affricates = set_of {"ч", "ц"}
local function is_vowel(ch)
return in_set(vowels_syllab, ch)
end
local function is_palatalizer(ch)
return ch == "ь"
end
local function is_sonorant(ch)
return in_set(sonorants, ch)
end
local function is_stop(ch)
return in_set(stops, ch)
end
local function is_fricative(ch)
return in_set(fricatives, ch)
end
local function is_affricate(ch)
return in_set(affricates, ch)
end
--[[
Sonority objects:
Sonority objects take the form of a table with the following attributes:
{
rank (int): the numerical value representing the position of the sound in the sonority hierarchy;
first_index (int): the index of the first letter that makes up the sound within the word.
The index of the first letter in a word with this sonority rank.
The affricates "дж" and "дз" are represented by two letters each, but
for sonority purposes they function as a "unit", hence we just need
the index of the first letter of the affricate.
}
--]]
local function new_sonority(rank, first_index)
return {
["rank"] = rank,
["first_index"] = first_index
}
end
local function get_sonority_rank(ch)
if is_fricative(ch) then
return 1
end
if is_stop(ch) or is_affricate(ch) then
return 2
end
if is_sonorant(ch) then
return 3
end
if is_vowel(ch) then
return 4
end
return 0
end
-- Get the representation of a word as a list of sequential sonority objects, stored in a table.
-- Their representation is just {[1] = (sonority object #1), [2] = (sonority object #2)} etc.
-- Please see above for description of sonority objects' layout.
local function get_sonority_model(word, start_idx, end_idx)
local sonorities = {}
word = mw.ustring.lower(word)
local i = start_idx
while i < end_idx do
local curr = char_at(word, i)
if curr == "щ" then
-- One letter representing 2 sounds - decompose it.
table.insert(sonorities, new_sonority(get_sonority_rank("ш"), i))
table.insert(sonorities, new_sonority(get_sonority_rank("т"), i));
elseif curr == "д" then
-- Handle affricates with 'д' - only 'дж' here for illustration.
local next_char = (i == end_idx - 1 and " ") or char_at(word, i+1)
local should_skip = false
if next_char == "ж" then
table.insert(sonorities, new_sonority(2, i)) -- 2 = affricate sonority rank
i = i + 1 -- Skip over the 'ж'
should_skip = true
end
if not should_skip then table.insert(sonorities, new_sonority(get_sonority_rank("д"), i)) end
elseif not is_palatalizer(curr) then
-- Skip over 'ь' since it doesn't change the sonority.
table.insert(sonorities, new_sonority(get_sonority_rank(curr), i))
end
i = i + 1
end
return sonorities
end
-- Forced breaks when the user inputs a break marker into the input string
-- word: string; start and end are integers indexing the string
local function find_forced_break(word, range_start, range_end)
if range_start >= range_end then return -1 end
local marker_pos = mw.ustring.find(word, BREAK_MARKER, range_start, true) or -1
return marker_pos >= range_end and -1 or marker_pos
end
local function strip_forced_breaks(segment)
return rsub(segment, "[.]", "");
end
---- Morphological prefix handling
--[[
This code brings morphological prefix awareness to syllabification.
This is necessary, because following the principle of rising sonority
alone fails to determine syllable boundaries correctly in some cases
— that is, when certain prefixes should be kept together as a first syllable.
]]
--[[
Affected prefixes. Each of them ends in a consonant that can be followed
by another consonant of a higher sonority in some words. In such cases,
naive syllable breaking would chop off the prefix's last consonant, and
glue it to the onset of the next syllable.
]]
local prefixes = {
-- без- family
"без",
-- из- family
"безиз", "наиз", "поиз", "произ", "преиз", "неиз", "из",
-- въз- family
"безвъз", "превъз", "невъз", "въз",
-- раз- family
"безраз", "предраз", "пораз", "нараз", "прераз", "нераз", "раз",
-- от- family
"неот", "поот", "от",
-- ending in fricatives
"екс", "таз", "дис",
-- ending in stops
"пред"
}
--[[
Finds the (zero-based) separation point between a
morphological prefix and the rest of the word.
By convention, that's the index of the first character
after the prefix.
word: the word to check for prefixes
return -1 if no prefix found, or if the separation point
is handled by the sonority model. A non-zero index otherwise.
]]
local function followed_by_higher_sonority_cons(prefix, word) -- prefix, word are both strings
prefix = mw.ustring.lower(prefix)
word = mw.ustring.lower(word)
local prefix_last_char = char_at(prefix, rlen(prefix))
local first_char_after_prefix = char_at(word, rlen(prefix) + 1)
-- Prefixes followed by vowels do, in fact, get broken up.
if is_vowel(first_char_after_prefix) then return false end
return get_sonority_rank(prefix_last_char) < get_sonority_rank(first_char_after_prefix)
end
local function find_separation_points(word)
local matching_prefixes = {}
word = mw.ustring.lower(word)
for _, prefix in pairs(prefixes) do
if starts_with(word, prefix) and followed_by_higher_sonority_cons(prefix, word) then
table.insert(matching_prefixes, rlen(prefix) + 1)
end
end
return matching_prefixes
end
---- Main syllabification code
---Context objects:
--[[ encoded as a table like
{
word (string),
prefix_separation_points (table[int])
}
]]
local function new_context(word, pos)
return {
["word"] = word,
["prefix_separation_points"] = pos
}
end
--[[
Consonant clusters that exhibit rising sonority, but should be
broken up regardless to produce natural-sounding syllables.
The breakpoint for clusters of 3 or more consonants can vary –
here we provide a zero-based offset within the cluster for each.
]]
local sonority_exception_break = {
["км"] = 1, ["гм"] = 1, ["дм"] = 1, ["вм"] = 1,
["зм"] = 1, ["цм"] = 1, ["чм"] = 1,
["дн"] = 1, ["вн"] = 1, ["тн"] = 1, ["чн"] = 1,
["кн"] = 1, ["гн"] = 1, ["цн"] = 1,
["зд"] = 1, ["зч"] = 1, ["зц"] = 1,
["вк"] = 1, ["вг"] = 1, ["дл"] = 1, ["жд"] = 1,
["згн"] = 1, ["здн"] = 2, ["вдж"] = 1
}
local sonority_exception_keep = {
"ств", "св", "вс"
}
local function normalize_word(word)
if word == nil then return "" end
word = rsub(rsub(word, "^\\s+", ""), "\\s+^", "") -- Strip spaces
return word
end
local function normalize_syllable(syllable)
local normalized = strip_forced_breaks(syllable)
normalized = rsub(normalized, "ў", "у")
normalized = rsub(normalized, "Ў", "У")
return normalized
end
local function find_rising_sonority_break(sonorities)
local prev_rank = -1;
for _, curr in pairs(sonorities) do
if curr.rank <= prev_rank then
-- Found a break.
return curr.first_index
end
prev_rank = curr.rank
end
-- There was no rising sonority break. Start syllable at first index.
return sonorities[1].first_index
end
local function matches(str, substr, start_idx, end_idx)
local strlen = end_idx - start_idx
if strlen ~= rlen(substr) then return false end
str = mw.ustring.lower(str)
substr = mw.ustring.lower(substr)
local i = start_idx
local j = 1
while i < end_idx do
if char_at(str, i) ~= char_at(substr, j) then return false end
i = i + 1
j = j + 1
end
return true
end
-- ctx: context object
-- left and right vowels: integers
-- sonority break: integer
local function fixup_syllable_onset(ctx, left_vowel, sonority_break, right_vowel)
local word = mw.ustring.lower(ctx.word)
-- 'щр' is a syllable onset when in front of a vowel.
-- Although 'щ' + sonorant technically follows rising sonority, syllables
-- like щнV, щлV etc. are unnatural and incorrect. In such cases, we treat
-- the sonorant as the onset of the next syllable.
if char_at(word, right_vowel - 2) == "щ" then
local penult = char_at(word, right_vowel - 1)
if penult == "р" then return (right_vowel - 2) end
if is_sonorant(penult) then return (right_vowel - 1) end
end
-- Check for situations where we shouldn't break the cluster.
local match_found = false
for _, cluster in pairs(sonority_exception_keep) do
if matches(word, cluster, left_vowel + 1, right_vowel) then
match_found = true
break
end
end
if (match_found) then return left_vowel + 1 end -- syllable onset == beginning of cluster
-- Check for situations where we should break the cluster even if
-- it obeys the principle of rising sonority.
local maybe_cluster = nil
for cluster, _ in pairs(sonority_exception_break) do
if matches(word, cluster, left_vowel + 1, right_vowel) then
maybe_cluster = cluster
break
end
end
if maybe_cluster ~= nil then
local offset = sonority_exception_break[maybe_cluster]
return left_vowel + 1 + offset
end
local separation_points = ctx.prefix_separation_points
local separation_match = nil
for _, pos in pairs(separation_points) do
if pos > left_vowel and pos < right_vowel then
separation_match = pos
break
end
end
if separation_match ~= nil then return separation_match else return sonority_break end
end
-- ctx: context object
-- left/right vowels: integers
local function find_next_syllable_onset(ctx, left_vowel, right_vowel)
local n_cons = right_vowel - left_vowel - 1
-- No consonants - syllable starts on rightVowel
if n_cons == 0 then return right_vowel end
-- Check for forced breaks
local break_pos = find_forced_break(ctx.word, left_vowel + 1, right_vowel)
if break_pos ~= -1 then return break_pos + 1 end
-- Single consonant between two vowels - starts a syllable
if n_cons == 1 then return left_vowel + 1 end
-- Two or more consonants between the vowels. Find the point (if any)
-- where we break from rising sonority, and treat it as the tentative
-- onset of a new syllable.
local sonorities = get_sonority_model(ctx.word, left_vowel + 1, right_vowel)
local sonority_break = find_rising_sonority_break(sonorities)
-- Apply exceptions to the rising sonority principle to avoid
-- unnatural-sounding syllables.
return fixup_syllable_onset(ctx, left_vowel, sonority_break, right_vowel)
end
local function deaccent(term)
return rsub(term, "[" .. ACUTE .. GRAVE .. DOTUNDER .. "]", "")
end
local function deaccent_all(term)
return deaccent(rsub(mw.ustring.toNFD(term), BREVE, ""))
end
-- Returns a table of strings (list)
local function syllabify_poly(word)
local syllables = {}
local ctx = new_context(word, find_separation_points(word))
local prev_vowel = -1
local prev_onset = 1;
for i = 1, rlen(word) do
if is_vowel(mw.ustring.lower(char_at(word, i))) then
-- A vowel, yay!
local should_skip = false
if prev_vowel == -1 then
prev_vowel = i
should_skip = true;
end
-- This is not the first vowel we've seen. In-between
-- the previous vowel and this one, there is a syllable
-- break, and the first character after the break starts
-- a new syllable.
if not should_skip then
local next_onset = find_next_syllable_onset(ctx, prev_vowel, i)
table.insert(syllables, substring(word, prev_onset, next_onset - 1))
prev_vowel = i
prev_onset = next_onset
end
end
end
-- Add the last syllable
table.insert(syllables, substring(word, prev_onset))
return syllables
end
function export.syllabify_word(word)
local norm = normalize_word(word)
if rlen(norm) == 0 then return "" end;
local n_vowels = count_vowels(norm)
local syllables = n_vowels <= 1 and {norm} or syllabify_poly(norm)
local out = {}
for k, v in pairs(syllables) do
out[k] = normalize_syllable(v)
end
return table.concat(out, HYPH)
end
local function tokenize_words(term)
local out = {}
local prev_index = 1
local len = rlen(term)
for i = 1, len do
local current_char = char_at(term, i)
if current_char == "-" or current_char == " " then
table.insert(out, substring(term, prev_index, i))
prev_index = i + 1
end
end
table.insert(out, substring(term, prev_index, len))
return out
end
function export.syllabify(term)
term = deaccent(term)
local words = tokenize_words(term)
local out = {}
for _, word in pairs(words) do
table.insert(out, export.syllabify_word(word))
end
return table.concat(out, "")
end
---Hyphenation
-- Hyphenate a word from its existing syllabification
function export.hyphenate(syllabification)
-- Source: http://logic.fmi.uni-sofia.bg/hyphenation/hyph-bg.html#hyphenation-rules-between-1983-and-2012
-- Also note: the rules from 2012 onward, which encode the modern standard, are entirely
-- backwards-compatible with the previous standard. Thus our code can generate valid 2012
-- hyphenations despite only explicitly implementing the older (1983) rules.
---Pre-processing----
local word = deaccent(syllabification)
word = rsub_repeatedly(word, HYPH .. "дж", HYPH .. "#")
word = rsub_repeatedly(word, "дж$", "#")
word = rsub_repeatedly(word, "^дж", "#")
word = rsub_repeatedly(word, "(" .. hvowels_c .. ")" .. HYPH .. "(" .. hcons_c .. ")(" .. rsub(hcons_c, "[ьЬ]", "") .. "+)", "%1%2" .. HYPH .. "%3")
word = rsub_repeatedly(word, "(" .. rsub(hcons_c, "[йЙ]", "") .. ")(" .. hcons_c .. "+)" .. HYPH, "%1" .. HYPH .. "%2")
word = rsub_repeatedly(word, "^(" .. hvowels_c .. ")" .. HYPH, "%1")
word = rsub_repeatedly(word, HYPH .. "(" .. hvowels_c .. ")$", "%1")
word = rsub_repeatedly(word, "(" .. hvowels_c .. ")" .. HYPH .. "(" .. hvowels_c .. ")" .. HYPH .. "(" .. hvowels_c .. ")", "%1%2" .. HYPH .. "%3")
word = rsub_repeatedly(word, HYPH .. "(" .. hvowels_c .. ")" .. HYPH .. "(" .. hcons_c .. ")", HYPH .. "%1%2")
word = rsub_repeatedly(word, "#", "дж")
return word
end
-- Hyphenate a word directly, no need to calculate its syllabification beforehand (used in test suite)
function export.hyphenate_total(word)
local syllabification = export.syllabify(word)
return export.hyphenate(syllabification)
end
local function get_anntext(term, ann)
if ann == "1" or ann == "y" then
-- remove secondary stress annotations
return "'''" .. export.remove_pron_notations(term, true) .. "''': "
elseif ann then
return "'''" .. ann .. "''': "
else
return ""
end
end
local HYPHENATION_LABEL = "Hyphenation<sup>([[Appendix:Bulgarian hyphenation#Hyphenation|key]])</sup>"
local SYLLABIFICATION_LABEL = "Syllabification<sup>([[Appendix:Bulgarian hyphenation#Syllabification|key]])</sup>"
local function format_hyphenation(hyphenation, label)
hyphenation = deaccent(hyphenation) -- remove grave/acute accent
local syllables = rsplit(hyphenation, HYPH)
label = label or HYPHENATION_LABEL
return require(hyphenation_module).format_hyphenations {
lang = lang,
hyphs = { { hyph = syllables } },
sc = script,
caption = label,
}
end
local function format_syllabification(syllabification)
return format_hyphenation(syllabification, SYLLABIFICATION_LABEL)
end
-- Display syllabification and hyphenation, together if the same, and on separate lines if not;
-- allows specifying an indentation level, if the hyphenation must be indented to more than one level.
local function render_bg_hyph(term, indentation, syllabification, hyphenation)
syllabification = syllabification or export.syllabify(term)
hyphenation = hyphenation or export.hyphenate(syllabification)
local out = ""
-- Users must put a * (or **) before the template usage
if syllabification == hyphenation then
if syllabification ~= "-" then
out = format_syllabification(syllabification)
end
else
local syllabification_text = format_syllabification(syllabification)
local hyphenation_text = format_hyphenation(hyphenation)
if syllabification ~= "-" then
out = syllabification_text
end
if hyphenation ~= "-" then
if syllabification == "-" then
out = hyphenation_text
else
out = out .. "\n" .. mw.ustring.rep("*", indentation) .. " " .. hyphenation_text
end
end
end
return out
end
-- Entry point to {{bg-hyph}}
function export.show_hyphenation(frame)
local params = {
[1] = {},
["indent"] = { type = "number" }
}
local title = mw.title.getCurrentTitle()
local args = require(parameters_module).process(frame:getParent().args, params)
local term = args[1] or title.nsText == "Template" and "при́мер" or title.text
local indent = args["indent"] or 1
return render_bg_hyph(term, indent)
end
function export.get_rhymes(ipa)
ipa = rsub(ipa, FRONTED, "")
local length = rlen(ipa)
local i = length
local vowels_seen = 0
local final_consonant_found = false
-- March until accent is found
while i > 0 do
-- Track vowel or final consonant if found
if vowels_seen == 0 and rmatch(char_at(ipa, i), cons_c) then
final_consonant_found = true
end
if rmatch(char_at(ipa, i), vowels_c) then
vowels_seen = vowels_seen + 1
end
if rmatch(char_at(ipa, i), accents_c) then
-- Note whether letter before the accent was vowel
local final_vowel_cluster = rmatch(ipa, vowels_c .. accents_c .. vowels_c .. "$")
-- March until the vowel first following the accent is found
while i <= length and not rmatch(char_at(ipa, i), vowels_c) do
i = i + 1
end
-- March back if only a single word-final vowel was previously spotted –
-- this corresponds to final-syllable-stressed words, whose rhyme
-- needs to include a consonant according to Bulgarian rhyming rules.
if vowels_seen <= 1 and not final_consonant_found and not final_vowel_cluster then
while i > 1 and not rmatch(char_at(ipa, i), rsub(cons_c, "ʲ", "")) do
i = i - 1
end
-- Account for affricates (note: this can only occur in
-- consonant-rhyme, i.e. final-stressed words)
if i > 1 and char_at(ipa, i-1) == TIE then
-- If a tie is present, there must be a letter before it as well.
i = i - 2
elseif i > 1 and char_at(ipa, i) == "ʒ" and char_at(ipa, i-1) == "d" then
-- Treat [dʒ] sequence as an affricate – this can have some edge cases.
-- In future, the module should distinguish [d.ʒ] and [d͡ʒ].
i = i - 1
end
end
return substring(ipa, i)
end
i = i - 1
end
local n_vowels = count_ipa_vowels(ipa)
if n_vowels == 1 then
i = length
if rmatch(char_at(ipa, i), cons_c) then
while i > 1 and not rmatch(char_at(ipa, i), vowels_c) do
i = i - 1
end
else
while i > 1 and not rmatch(char_at(ipa, i), rsub(cons_c, "ʲ", "")) do
i = i - 1
end
end
if i > 1 and char_at(ipa, i - 1) == TIE then
i = i - 2
end
return substring(ipa, i)
end
return nil
end
-- Render a single IPA transcription as wikitext (with optional qualifiers + accent labels)
local function format_ipa(ipa, q, qq, a, aa)
-- Introduce narrow transcription brackets
ipa = "[" .. ipa .. "]"
local ipa_data = {
lang = lang,
items = {{ pron = ipa }},
q = q,
qq = qq,
a = a,
aa = aa,
}
return require(ipa_module).format_IPA_full(ipa_data)
end
function export.show(frame)
local params = {
[1] = {},
["endschwa"] = { type = "boolean" },
["ann"] = {},
["q"] = { type = "qualifier" },
["qq"] = { type = "qualifier" },
["a"] = { type = "labels" },
["aa"] = { type = "labels" },
["pagename"] = {},
}
local args = require(parameters_module).process(frame:getParent().args, params)
local term = args[1] or args.pagename or mw.title.getCurrentTitle().nsText == "Template" and "при́мер" or
mw.loadData(headword_data_module).pagename
local ipa = export.toIPA(term, args.endschwa)
local ipa_text = format_ipa(ipa, args.q, args.qq, args.a, args.aa)
local anntext = get_anntext(term, args.ann)
-- Terms with a lack of stress despite not being monosyllabic
if count_vowels(term) > 1 and count_accents(ipa) == 0 then
require(tracking_module)("bg-IPA/no stress")
end
return anntext .. ipa_text
end
-- Convert rhyme suffix and optional syllable count to wikitext
local function format_rhymes(rhyme_suffix, syllable_counts, q, qq, l, ll)
return require(rhymes_module).format_rhymes({
lang = lang,
rhymes = {
{rhyme = rhyme_suffix, num_syl = syllable_counts, q = q, qq = qq, a = l, aa = ll},
},
})
end
-- Entry point for {{bg-rhymes}}
function export.show_rhymes(frame)
-- TODO: add qualifiers / labels
local params = {
[1] = {},
["pagename"] = {},
["s"] = { sublist = true, type = "number", },
["q"] = { type = "qualifier", },
["qq"] = { type = "qualifier", },
["a"] = { type = "labels", },
["aa"] = { type = "labels", },
}
local args = require(parameters_module).process(frame:getParent().args, params)
local term = args[1] or args.pagename or mw.title.getCurrentTitle().nsText == "Template" and "при́мер" or
mw.loadData(headword_data_module).pagename
local ipa = export.toIPA(term, args.endschwa)
local rhymes = export.get_rhymes(ipa)
local syllable_counts = args.s or {count_vowels(term)}
return format_rhymes(rhymes, syllable_counts, args.q, args.qq, args.a, args.aa)
end
-- Matches patterns such as: Bg-къща.ogg<Sofia>,
-- with capture groups [1]="Bg-къща.ogg", [2]="Sofia"
local accent_qualifier_pattern = "(.-)<(.+)>"
-- Matches speaker profiles, i.e. a shorthand for representing a given
-- speaker and the properties of their audio
local speaker_profile_pattern = "%[([^:~]-)([:~]?)([^:~]*)%]"
local speaker_profiles = require("Module:bg-pronunciation/speaker profiles").speaker_profiles
local audio_functions = require("Module:bg-pronunciation/speaker profiles").audio_functions
-- Return a list of audio formatted as wikitext
local function format_audio_list(list, ipa, pagename, corresponding_respelling)
local request_rfap = false
if list == nil then
return {}, request_rfap
end
-- Audio list is separated by # symbols.
local file_specs = rsplit(list, "#")
local audios = {}
for _, spec in pairs(file_specs) do
-- Try to match speaker profile
local speaker_profile_name, separator, term_override = rmatch(spec, speaker_profile_pattern)
-- FIXME
if speaker_profile_name == "" and term_override ~= "" then
speaker_profile_name = term_override
term_override = nil
end
if speaker_profile_name then
local speaker_profile = speaker_profiles[speaker_profile_name]
if not speaker_profile then
error("Speaker profile named '" .. speaker_profile_name .. "' does not exist")
end
-- E.g. [ABC~2] on page="човек" is equivalent to: [ABC:човек-2].
if separator == "~" then
term_override = mw.loadData(headword_data_module).pagename .. "-" .. term_override
end
if term_override == "" then
term_override = corresponding_respelling
end
local renderer_name = speaker_profile["renderer"]
local filename = term_override or pagename
local rendered = audio_functions[renderer_name].display(speaker_profile, filename, {ipa=ipa})
if rendered then
table.insert(audios, rendered)
else
request_rfap = true
end
else
-- Attempt to match qualifiers; if none given, then the entire spec is simply interpreted as a file name.
local filename, accents_string = rmatch(spec, accent_qualifier_pattern)
filename = filename or spec
local accents_list = accents_string and rsplit(accents_string, ",") or nil
table.insert(audios,
require(audio_module).format_audio({
lang = lang,
file = filename,
a = accents_list,
})
)
end
end
return audios, request_rfap
end
local function format_homophones(homophones_list)
local homophones_data = {}
for _, hmp in pairs(homophones_list) do
table.insert(homophones_data, {
term = hmp
})
end
return require(homophones_module).format_homophones({
lang = lang,
homophones = homophones_data,
})
end
-- Entry point for {{bg-pr}}
function export.show_all(frame)
local params = {
[1] = { list = true, disallow_holes = true},
["q"] = { list = true, type = "qualifier", allow_holes=true },
["qq"] = { list = true, type = "qualifier", allow_holes=true },
["l"] = { list = true, type = "labels", allow_holes=true },
["ll"] = { list = true, type = "labels", allow_holes=true },
["ann"] = { list = true, allow_holes=true, separate_no_index = true },
["audio"] = { list = true, allow_holes=true },
["a"] = { alias_of = "audio", list = true, allow_holes=true },
["rhymes"] = { list = true, separate_no_index = true, allow_holes=true },
["s"] = { list = true, type = "number", separate_no_index = true, allow_holes=true },
["syllabification"] = { list = true, separate_no_index = true, allow_holes=true },
["syl"] = { alias_of = "syllabification", list = true, separate_no_index = true, allow_holes=true },
["hyphenation"] = { list = true, separate_no_index = true, allow_holes=true },
["hyph"] = { alias_of = "hyphenation", list = true, separate_no_index = true, allow_holes=true },
["homophones"] = { list = true, allow_holes=true },
["hs"] = { list = true, separate_no_index = true, allow_holes=true}, -- Hyphenation and syllabification override at once
["hmp"] = { alias_of = "homophones", list = true, allow_holes=true },
["endreduce"] = { list = true, allow_holes=true },
["endschwa"] = { alias_of = "endreduce", list = true, allow_holes=true },
["raw"] = { list = true, allow_holes=true },
["pagename"] = {},
}
local args = require(parameters_module).process(frame:getParent().args, params)
local pagename = args.pagename or mw.title.getCurrentTitle().nsText == "Template" and "при́мер" or
mw.loadData(headword_data_module).pagename
-- Ensure at least one pronunciation line present (unlikely to be desired in the case of multisyllabic words, though)
if #args[1] == 0 then
args[1] = {pagename}
end
-- Returns the hyphenation for a term if one is given by the user,
-- or automatically generate one from the respelling if it meets the criteria:
--[[
- must have more than one vowel
- the respelling given must be the same as the page title (when accents
are removed)
--]]
local syllabify = export.syllabify
local function hyphenate(x) return export.hyphenate(export.syllabify(x)) end
local function deal_with_hyph_syl_respellings(given, respelling, hyphenate_or_syllabify)
if given == "+" then
return hyphenate_or_syllabify(respelling)
elseif given == "#" then
return hyphenate_or_syllabify(pagename)
elseif given then
return rsub(given, "%.", HYPH)
elseif count_vowels(respelling) == 1 or rsub(deaccent_all(respelling), "%.", "") ~= pagename then
return "-"
else
return hyphenate_or_syllabify(respelling)
end
end
-- Return nil if a rhyme should not be added based on the term.
--[[ The current rules are:
- if a manual override is given by the user, that will be the rhyme regardless
- if no override is given and the term contains a space or hyphen, return nil
- if there is no space and hyphen, but there is more than 1 capital letter,
then the term will be diagonosed as an abbreviation, and nil will be returned
(this logic will help to keep rhymes for names, e.g. Петър)
- if there is more than 1 accent mark (primary or secondary combined)
in the IPA, then nil is returned
- if all the above guards fail, the module will generate a rhyme
(despite appearances, this will actually be most words anyway)
--]]
local function deal_with_rhymes(override, ipa)
if override then
return override
end
if count_capital_letters(pagename) > 1 then
return nil
end
if count_accents(ipa) > 1 then
return nil
end
if rmatch(ipa, "[ %-]") or rmatch(pagename, "[ %-]") then
return nil
end
return export.get_rhymes(ipa)
end
-- Track whether an audio file has been included using a speaker profile but doesn't yet exist; automatically {{rfap}} if so.
local request_rfap = false
-- Build up wikitext output for each pronunciation line
local pronunciation_lines = {}
for i, respelling in pairs(args[1]) do
local q = args.q[i]
local qq = args.qq[i]
local l = args.l[i]
local ll = args.ll[i]
local num_syllables = args.s.default or args.s[i] or count_vowels(respelling)
local ipa = args.raw[i] or export.toIPA(respelling, args.endreduce[i])
local audio, request_rfap_local = format_audio_list(args.audio.default or args.audio[i], ipa, pagename, respelling)
local rhymes = deal_with_rhymes(args.rhymes.default or args.rhymes[i], ipa) or "-"
local homophones = args.homophones[i] and rsplit(args.homophones[i], "#")
local syllabification = deal_with_hyph_syl_respellings(args.hs.default or args.hs[1] or args.syllabification.default or args.syllabification[i], respelling, syllabify)
local hyphenation = deal_with_hyph_syl_respellings(args.hs.default or args.hs[1] or args.hyphenation.default or args.hyphenation[i], respelling, hyphenate)
local ann = args.ann.default or args.ann[i]
table.insert(pronunciation_lines, {
term = respelling,
q = q,
qq = qq,
l = l,
ll = ll,
num_syllables = num_syllables,
ipa = ipa,
audio = audio,
rhymes = rhymes,
homophones = homophones,
syllabification = syllabification,
hyphenation = hyphenation,
ann = ann,
})
if args.rhymes[i] then
require(tracking_module)("bg-pr/manual rhyme")
if export.get_rhymes(pronunciation_lines[i]["ipa"]) ~= args.rhymes[i] then
-- Manual rhyme actually changes the displayed rhyme
require(tracking_module)("bg-pr/rhyme override discrepancy")
end
end
if request_rfap_local then
request_rfap = true
end
end
-- This function is used to check whether all pronunciation lines have the same value for
-- a particular property. If they do, then that property should only be rendered once,
-- underneath each IPA.
-- If the properties are different, then each IPA should have that property value specified
-- indented underneath it, e.g. multiple IPAs with different audio files should have
-- their audios indented beneath each IPA.
local function all_the_same(property, eq) -- `eq` allows the notion of "the_same" to be overridden
eq = eq or function(a, b) return a == b end -- Use "==" as default definition of equality
local first = pronunciation_lines[1][property]
for _, pronunciation_line in pairs(pronunciation_lines) do
if not eq(pronunciation_line[property], first) then
return first, false
end
end
return first, true
end
-- Render overall output as text
local output_lines = {}
-- Check whether values for each property are all the same,
-- in which case they can all be merged at the end of the template,
-- instead of being duplicated per-pronunciation-line.
local first_hyphenation, all_hyphenations_the_same = all_the_same("hyphenation")
local first_syllabification, all_syllabifications_the_same = all_the_same("syllabification")
local first_rhyme, all_rhymes_the_same = all_the_same("rhymes")
local first_homophones, all_homophones_the_same = all_the_same("homophones", require(table_module).deepEquals)
local first_audio, all_audio_the_same = all_the_same("audio", require(table_module).deepEquals)
-- Generate text for each pronunciation line.
for _, pronunciation_line in pairs(pronunciation_lines) do
-- Unpack data
local ipa = pronunciation_line["ipa"]
local term = pronunciation_line["term"]
local ann = pronunciation_line["ann"]
local q = pronunciation_line["q"]
local qq = pronunciation_line["qq"]
local l = pronunciation_line["l"]
local ll = pronunciation_line["ll"]
local audios = pronunciation_line["audio"]
local rhymes = pronunciation_line["rhymes"]
local homophones = pronunciation_line["homophones"]
local hyphenation = pronunciation_line["hyphenation"]
local syllabification = pronunciation_line["syllabification"]
local ipa_text = format_ipa(ipa, q, qq, l, ll)
local ann_text = get_anntext(term, ann)
local out = {"* " .. ann_text .. ipa_text}
if audios and not all_audio_the_same then
for _, audio in pairs(audios) do
table.insert(out, "** " .. audio)
end
end
if rhymes ~= "-" and not all_rhymes_the_same then
local num_syllables = pronunciation_line["num_syllables"]
local rhymes_text = format_rhymes(rhymes, {num_syllables})
table.insert(out, "** " .. rhymes_text)
end
if homophones and not all_homophones_the_same then
local homophones_text = format_homophones(homophones)
table.insert(out, "** " .. homophones_text)
end
local syllabification_text = format_syllabification(syllabification)
if syllabification == hyphenation and syllabification ~= "-" then
if not (all_hyphenations_the_same and all_syllabifications_the_same) then
table.insert(out, "** " .. syllabification_text)
end
else
local hyphenation_text = format_hyphenation(hyphenation)
if not all_syllabifications_the_same and syllabification ~= "-" then
table.insert(out, "** " .. syllabification_text)
end
if not all_hyphenations_the_same and hyphenation ~= "-" then
table.insert("** " .. hyphenation_text)
end
end
-- Produce output for one pronunciation line at a time
table.insert(output_lines, table.concat(out, "\n"))
end
-- Group audios all together if they are all identical
if all_audio_the_same and first_audio then
for _, audio in pairs(first_audio) do
table.insert(output_lines, "* " .. audio)
end
end
-- Group rhymes all together if they are all identical
if all_rhymes_the_same and first_rhyme ~= "-" then
-- Take all syllable counts for all pronunciation lines
-- to inform the syllable count of the rhyme.
local num_syllables = {}
for _, line in pairs(pronunciation_lines) do
table.insert(num_syllables, line["num_syllables"])
end
local rhymes_text = format_rhymes(first_rhyme, num_syllables)
table.insert(output_lines, "* " .. rhymes_text)
end
-- Group homophones all together if they are all identical
if all_homophones_the_same and first_homophones then
local homophones_text = format_homophones(first_homophones)
table.insert(output_lines, "* " .. homophones_text)
end
-- If some hyphenations or syllabifications are absent, then the outermost text should not include these,
-- rather they should have been appended to the relevant pronunciations lines above.
if all_hyphenations_the_same and all_syllabifications_the_same and first_hyphenation == first_syllabification and first_hyphenation ~= "-" then
local syllabification_text = format_syllabification(first_hyphenation)
table.insert(output_lines, "* " .. syllabification_text)
elseif first_hyphenation ~= first_syllabification then
if all_syllabifications_the_same and first_syllabification ~= "-" then
local syllabification_text = format_syllabification(first_syllabification)
table.insert(output_lines, "* " .. syllabification_text)
end
if all_hyphenations_the_same and first_hyphenation ~= "-" then
local hyphenation_text = format_hyphenation(first_hyphenation)
table.insert(output_lines, "* " .. hyphenation_text)
end
end
if request_rfap then
table.insert(output_lines, frame:preprocess("{{rfap|bg}}"))
end
return table.concat(output_lines, "\n")
end
return export
