Module:ko-hangeul

La documentation pour ce module peut être créée à Module:ko-hangeul/Documentation

local ko = {}
local sinogramme = require('Module:sinogramme')

-- Il est à noter que mw.ustring.gsub ne peut pas utiliser
-- un tableau de remplacement importé par mw.loadData.
local hangeul = mw.loadData("Module:ko-hangeul/data")

-- Cette fonction décompose des hangeuls en jamos.
-- La barre oblique supprime un rieul précédent s’il y en a.
-- La fonction mw.ustring.toNFD est inutile ici
-- parce qu’elle décompose un hangeul en nouveaux jamos (bloc U+1100-U+11FF)
-- tandis que nous avons besoin des jamos de compatibilité (bloc U+3130-U+318F).
function ko.decompos(str)
	str = mw.ustring.gsub(str, "([가-힣])", jamos)
	str = mw.ustring.gsub(str, "ㄹ?/", "")
	str = mw.ustring.gsub(str, "[ㄱ-ㅎ]+([ㄱ-ㅎ][ㄱ-ㅎ])", "%1") -- au plus deux consonnes
	str = mw.ustring.gsub(str, "[ㄱ-ㅎ]+([ㄱ-ㅎ])$", "%1") -- au plus une seule consonne à la fin
	return str
end

-- Fonction internelle pour décomposer un hangeul en jamos.
function jamos(caractere)
	local code = mw.ustring.codepoint(caractere)
	return hangeul.initiale[math.floor((code - 0xac00) / (21 * 28)) + 1] ..
	       hangeul.voyelle[math.floor((code - 0xac00) / 28) % 21 + 1] ..
	       hangeul.finale[(code - 0xac00) % 28 + 1]
end

-- Cette fonction supprime tous les clés de prononciation ("'", "-", "." et "s")
-- et elle compose des hangeuls.
function ko.compos(str, conserver)
	if not conserver then
		str = mw.ustring.gsub(str, "[^가-힣ㄱ-ㅣ ]", "") -- conserver seulement les hangeuls, les jamos et les espaces
	end
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ])([ㅏ-ㅣ])", hangeul_sans_finale)
	str = mw.ustring.gsub(str, "([가-히])([ㄱ-ㅎ])", hangeul_avec_finale)
	return str
end

-- fonction internelle
function hangeul_sans_finale(initiale, voyelle)
	return mw.ustring.char((hangeul.indice_initiale[initiale] - 1) * 21 * 28
	                       + (hangeul.indice_voyelle[voyelle] - 1) * 28
	                       + 0xac00)
end

-- fonction internelle
function hangeul_avec_finale(caractere, finale)
	return mw.ustring.char(mw.ustring.codepoint(caractere)
	                       + hangeul.indice_finale[finale] - 1)
end

-- Cette fonction modifie des hangeuls selon les règles du Standard
-- et les clés de prononciation ("'", "-", "." et "s").
function ko.modif_jamo(str, pron, changer_oe)
	str = ko.decompos(str)
	-- apostrophes (Articles 26-29)
	if pron then -- pour la prononciation
		str = mw.ustring.gsub(str, "'ㅇ", "ㄴ") -- Article 29
		str = mw.ustring.gsub(str, "'([ㄱㄷㅂㅅㅈ])", consonne_forte) -- Articles 26, 27 et 28
	else -- pour la romanisation
		str = mw.ustring.gsub(str, "([^ ])'ㅇ", "%1ㄴ") -- Article 29
	end
	str = mw.ustring.gsub(str, "'", "")
	-- s (Article 16)
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ])s", "ㅅ")

	-- changements phonologiques qu’il faut traiter avant la supression des traits d’union
	-- Article 17
	str = mw.ustring.gsub(str, "([ㄷㅌㄾ][ㅇㅎ])([ㅣㅕ])",
	                      function (frontiere, voyelle)
	                      	return (hangeul.palatale[frontiere] or frontiere) .. voyelle
	                      end)
	if pron then
		-- Article 4
		if changer_oe then
			str = mw.ustring.gsub(str, "ㅚ", "ㅞ")
		end
		-- Article 5
		str = mw.ustring.gsub(str, "([ㄱㄹㅁㅎㅍ])ㅖ", "%1ㅔ") -- ㅖ est prononcé ㅔ dans 계, 례, 몌, 혜 et 폐
		str = mw.ustring.gsub(str, "([ㄱ-ㅆㅈ-ㅎ])ㅢ", "%1ㅣ") -- ㅢ est prononcé ㅣ après une consonne
		str = mw.ustring.gsub(str, "([ㄱ-ㅣ]ㅇ)ㅢ", "%1ㅣ") -- ㅢ est prononcé ㅣ au milieu du mot ; -의 sera conservé
	end

	-- traits d’union et espaces (Articles 20 et 15)
	str = mw.ustring.gsub(str, "[ㄴㄵㄶ]%-ㄹ", "ㄴㄴ") -- Article 20
	if pron then -- pour la prononciation
		str = mw.ustring.gsub(str, "[ㄴㄵㄶ] ㄹ", "ㄴㄴ") -- Article 20
	else -- pour la romanisation
		str = mw.ustring.gsub(str, "([ㄱ-ㅎ])%-ㅎ", "%1--ㅎ") -- pour éviter la suppression
		str = mw.ustring.gsub(str, "([ㄱ-ㅣ]) ", "%1- ") -- pour éviter la suppression
	end
	str = mw.ustring.gsub(str, "([ㄱ-ㅣ])[%- ]", neutralisation) -- Article 15

	-- fin du mot
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ])$", neutralisation) -- Articles 9, 10 et 11
	-- frontières
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ]?)([ㄱ-ㅎ])([ㅏ-ㅣ])", pron_frontiere)
	if pron then -- pour la prononciation
		str = mw.ustring.gsub(str, "'([ㄱㄷㅂㅅㅈ])", consonne_forte)
		-- Article 5
		str = mw.ustring.gsub(str, "([ㅈㅉㅊ])([ㅑㅕㅖㅛㅠ])", -- ㅈ, ㅉ et ㅊ sont déjà palatales
		                      function (consonne, voyelle)
		                      	return consonne .. (hangeul.non_palatale[voyelle] or voyelle)
		                      end)
	else -- pour la romanisation
		str = mw.ustring.gsub(str, "['%-%.]", "") -- consonnes fortes pas romanisées
	end
	return str
end

-- Fonction internelle de la neutralisation des finales.
function neutralisation(jamo)
	return hangeul.neutralisation[jamo] or jamo
end

-- Fonction internelle des consonnes fortes.
function consonne_forte(jamo)
	return hangeul.forte[jamo] or jamo
end

-- Fonction internelle pour la prononciation.
function pron_frontiere(finale, initiale, voyelle)
	return (hangeul.frontiere[finale .. initiale]
	        or hangeul.neutralisation[finale] .. initiale)
	       .. voyelle
end

-- Cette fonction change des hangeuls en phonèmes
function ko.phoneme(str, son, sonore)
	str = ko.modif_jamo(str, true, false)
	-- prononciations modernes sans géminée
	str = mw.ustring.gsub(str, "([ㄱㄷㅂ][ㄲㄸㅆㅉㅃ])",
	                      function (frontiere)
	                      	return hangeul.sans_geminee[frontiere] or frontiere
	                      end)
	-- phonèmes d’une initiale et d’une voyelle
	str = mw.ustring.gsub(str, "ㅅㅞ", "sjwe") -- prononciation populaire de 쉐
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ])([ㅏ-ㅣ])",
	                      function (initiale, voyelle)
	                      	return "." .. hangeul.phoneme_initiale[initiale] .. hangeul.phoneme_voyelle[voyelle]
	                      end)
	-- phonème d’une finale
	str = mw.ustring.gsub(str, "([ㄱ-ㅎ])",
	                      function (finale)
	                      	return hangeul.phoneme_finale[finale]
	                      end)
	-- Article 12-4 : ㄹㅎ, ㄴㅎ, ㅁㅎ et ㅇㅎ
	-- Article 13 : ㅇㅇ
	str = mw.ustring.gsub(str, "([lnmŋ])%.(h?[aeɛijouʌwɯ])", ".%1%2")

	-- réalisation des phonèmes
	if son then
		-- sonorisation après une voyelle ou une consonne sonore
		if not sonore then
			str = mw.ustring.gsub(str, "^%.", "")
		end
		str = mw.ustring.gsub(str, "%.([hkpt]ɕ?)([aeɛijouʌwɯ])",
		                      function (consonne, voyelle)
		                      	return "." .. hangeul.sonorisation[consonne] .. voyelle
		                      end)
		-- implosives
		str = mw.ustring.gsub(str, "([kpt])%.(ˀ?[kpt])", "%1̚.%2") -- pas implosive devant ㅅ
		str = mw.ustring.gsub(str, "([kpt])$", "%1̚")
		-- ㄹㄹ
		str = mw.ustring.gsub(str, "l%.l", "ɭ.ɭ")
		-- ㄹ devant une voyelle
		str = mw.ustring.gsub(str, "l(h?[aeɛijouʌwɯ])", "ɾ%1")
		-- ㄹ de finale
		str = mw.ustring.gsub(str, "l", "ɭ")
		-- Article 12-4 : ㄹㅎ, ㄴㅎ, ㅁㅎ et ㅇㅎ
		str = mw.ustring.gsub(str, "([ɾnmŋ])h", "%1ʱ")
		-- distinction perdue entre 에 et 애
		str = mw.ustring.gsub(str, "[eɛ]", "e̞")
		-- palatalisation de 위
		str = mw.ustring.gsub(str, "wi", "ɥi")
		-- palatalisation de ㅅ et ㅆ
		str = mw.ustring.gsub(str, "sjw", "ʃw") -- prononciation populaire de 쉐
		str = mw.ustring.gsub(str, "sj", "ɕ")
		str = mw.ustring.gsub(str, "si", "ɕi")
		str = mw.ustring.gsub(str, "sɥi", "ʃɥi")
		-- palatalisation de ㅎ
		str = mw.ustring.gsub(str, "hj", "ç")
		str = mw.ustring.gsub(str, "h(ɥ?i)", "ç%1")
		-- palatalisation de ㅋ, ㅌ, ㅍ
		str = mw.ustring.gsub(str, "([ktp])ʰj", "%1ç")
		str = mw.ustring.gsub(str, "([ktp])ʰ(ɥ?i)", "%1ç%2")
		-- /w/ après une consonne
		str = mw.ustring.gsub(str, "([^%.])w", "%1ʷ")
		-- le suffixe -요
		str = mw.ustring.gsub(str, "o%.$", "o̞")
	end

	-- suppression des points au début et à la fin
	str = mw.ustring.gsub(str, "^%.", "")
	str = mw.ustring.gsub(str, "%.$", "")
	return str
end

-- Fonction internelle pour la romanisation des finales
function roman_finale(finale, initiale)
	return (hangeul.roman_finale[finale] or finale) .. (initiale or "")
end

-- Fonctions pour des modèles.

-- Prononciation (Modèle:ko-pron)
function ko.pron(frame)
	local str = frame.args[1] or ""
	local phon = frame.args["phon"] or ""
	local sonore = frame.args["sonore"] or ""
	return ko.phoneme(str, phon == "", sonore ~= "")
end

-- Initiale du premier hangeul donné
function ko.initiale(frame)
	local str = ko.decompos(frame.args[1] or "")
	str = mw.ustring.gsub(str, "[ '%-s]", "")
	return mw.ustring.match(str, "^([ㄱ-ㅎ])[ㅏ-ㅣ]") or "" -- première consonne suivie par une voyelle
end

-- Voyelle du dernier hangeul donné
function ko.voyelle(frame)
	local str = ko.decompos(frame.args[1] or "")
	str = mw.ustring.gsub(str, "[ '%-s]", "")
	return mw.ustring.match(str, "([ㅏ-ㅣ])[ㄱ-ㅎ]?$") or "" -- dernière voyelle
end

-- Finale du dernier hangeul donné
function ko.finale(frame)
	local str = ko.decompos(frame.args[1] or "")
	str = mw.ustring.gsub(str, "[ '%-s]", "")
	return mw.ustring.match(str, "([ㄱ-ㅎ]?)$") or "" -- dernière consonne
end

-- Translittération (Modèle:ko-translit)
function ko.translit(frame)
	local str = frame.args[1] or ""
	str = ko.decompos(str)
	str = mw.ustring.gsub(str, "['%-s]", "")
	str = mw.ustring.gsub(str, "ㅇ([ㅏ-ㅣ])", "-%1")
	str = mw.ustring.gsub(str, "^%-", "")
	str = mw.ustring.gsub(str, " %-", " ")
	str = mw.ustring.gsub(str, "([ㄱ-ㅣ])",
	                      function (jamo) return hangeul.translit[jamo] end)
	return str
end

-- Romanisation (Modèle:ko-roman)
function ko.roman(frame)
	local str = frame.args[1] or ""
	str = ko.modif_jamo(str)
	str = mw.ustring.gsub(str, "ㅇ([ㅏ-ㅣ])", "%1")
	str = mw.ustring.gsub(str, "([ㄱ-ㅣ])",
	                      function (jamo) return hangeul.translit[jamo] end)
	-- ㄹ devant une voyelle
	str = mw.ustring.gsub(str, "l([aeiouwy])", "r%1")
	-- ㄹㄹ
	str = mw.ustring.gsub(str, "lr", "ll")
	-- finale : b → p ; d → t ; g → k ; ng → ng sans changement
	str = mw.ustring.gsub(str, "(n?[bdg])([^aeiouwy])", roman_finale)
	str = mw.ustring.gsub(str, "(n?[bdg])$", roman_finale)
	-- majuscule
	if frame.args["maj"] and frame.args["maj"] ~= "" then
		str = mw.ustring.gsub(str, "^(.)", mw.ustring.upper)
	end
	return str
end

-- Composer des hangeuls utilisant des jamos (Modèle:hangeul mot)
function ko.hangeul_mot(frame)
	local str = frame.args[1] or ""
	local pron = frame.args["pron"] or ""
	return ko.compos(ko.decompos(str), pron ~= "")
end

-- Hangeul phonétique (Modèle:ko-hangeul-phon)
function ko.hangeul_phonetique(frame)
	local str = frame.args[1] or ""
	return ko.compos(ko.modif_jamo(str, true, true))
end

-- Frontière des sinogrammes
function ko.frontiere_hanja(frame)
	-- Article 26
	local str = frame.args[1] or ""
	local hanja = frame.args[2] or ""
	if hanja == "" then return str end

	local hanjas = {}
	local finales = {}

	local regex = "[" .. sinogramme.regex() .. "가-힣]"
	local i = 1
	for caractere in mw.ustring.gmatch(hanja, regex) do
		hanjas[i] = not mw.ustring.match(caractere, "[가-힣]") -- true si c’est un sinogramme
		i = i + 1
	end

	i = 1
	str = mw.ustring.gsub(str, "([^가-힣]*)([가-힣])",
	                      function (modif, caractere)
	                          local code = mw.ustring.codepoint(caractere) - 0xac00
	                          local initiale = hangeul.initiale[math.floor(code / (21 * 28)) + 1]
	                          finales[i] = hangeul.finale[code % 28 + 1]
	                          if modif == "" and i >= 2 then
	                              if hanjas[i - 1]
	                                 and hanjas[i]
	                                 and finales[i - 1] == "ㄹ"
	                                 and (initiale == "ㄷ" or initiale == "ㅅ" or initiale == "ㅈ") then
                                      modif = "'"
                                  elseif (hanjas[i - 1] or hanjas[i])
                                         and initiale == "ㅎ"
                                         and (finales[i - 1] == "ㄱ" or finales[i - 1] == "ㅂ") then
                                      modif = "-"
                                  end
	                          end
	                          i = i + 1
	                          return modif .. caractere
	                      end)
	return str
end

-- Supprimer le suffixe -다 du verbe (Modèle:ko-radical1)
function ko.radical1(frame)
	local str = frame.args[1] or ""
	str = ko.compos(ko.decompos(str), true)
	str = mw.ustring.gsub(str, "다$", "")
	return str
end

-- Forme en -으 (utilisée devant -니까, -ㄹ, -면, etc.) (Modèle:ko-radical2)
function ko.radical2(frame)
	local str = ko.decompos(frame.args[1] or "") -- radical
	local groupe = frame.args["groupe"] or ""

	if groupe == "b" then -- irrégulier-ㅂ
		str = mw.ustring.gsub(str, "ㅂ$", "우")
	elseif groupe == "d" then -- irrégulier-ㄷ
		str = mw.ustring.gsub(str, "ㄷ$", "ㄹ으")
	elseif groupe == "s" then -- irrégulier-ㅅ
		str = mw.ustring.gsub(str, "ㅅ$", "으")
	elseif groupe == "h" then -- irrégulier-ㅎ
		str = mw.ustring.gsub(str, "ㅎ$", "")
	elseif mw.ustring.match(str, "[ㄱ-ㄸㄺ-ㅎ]$") then -- régulier consonantique
		str = str .. "으"
	end -- régulier vocalique/-으/-ㄹ, irrégulier-러/-르/-시/-여/-이다

	return ko.compos(str, true)
end

-- Forme en -아/어 (utilisée devant -도, -서, etc.) (Modèle:ko-radical3)
function ko.radical3(frame)
	local str = ko.decompos(frame.args[1] or "") -- radical
	local groupe = frame.args["groupe"] or ""
	local alt = ((frame.args["alt"] or "") ~= "")

	if alt and not (groupe == "si"
	                or groupe == "ida"
	                or groupe == "yeo"
	                or (groupe == "" and mw.ustring.match(str, "[ㅗㅜㅐㅔㅚㅣ]$"))) then
		return nil
	end

	if groupe == "b" then -- irrégulier-ㅂ
		local wa = { [false] = "워", [true] = "와" }
		str = mw.ustring.gsub(str, "ㅂ$", wa[(frame.args["wa"] or "") ~= ""])
	elseif groupe == "d" then -- irrégulier-ㄷ
		str = mw.ustring.gsub(str, "ㄷ$", "ㄹㅇ" .. hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ])ㄷ$")])
	elseif groupe == "s" then -- irrégulier-ㅅ
		str = mw.ustring.gsub(str, "ㅅ$", "ㅇ" .. hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ])ㅅ$")])
	elseif groupe == "h" then -- irrégulier-ㅎ
		str = mw.ustring.gsub(str, "ㅑㅎ$", "ㅒ")
		str = mw.ustring.gsub(str, "ㅕㅎ$", "ㅖ")
		str = mw.ustring.gsub(str, "[ㅏㅓ]ㅎ$", "ㅐ")
	elseif groupe == "reo" then -- irrégulier-러
		str = str .. "러"
	elseif groupe == "reu" then -- irrégulier-르
		str = mw.ustring.gsub(str, "ㄹㅡ$", "ㄹㄹ" .. hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ])ㄹㅡ$")])
	elseif groupe == "eo" then -- irrégulier-어
		str = mw.ustring.gsub(str, "ㅓ$", "ㅐ")
	elseif groupe == "u" then -- irrégulier-우
		str = mw.ustring.gsub(str, "ㅜ$", "ㅓ")
	elseif groupe == "si" then -- irrégulier-시
		local voyelle = { [false] = "ㅕ", [true] = "ㅔ" }
		str = mw.ustring.gsub(str, "ㅣ$", voyelle[alt])
	elseif groupe == "ida" then -- irrégulier-이다
		if str == "" then
			local voyelle = { [false] = "여", [true] = "예" }
			str = voyelle[alt]
		else
			local voyelle = { [false] = "어", [true] = "에" }
			str = str .. voyelle[alt]
		end
	elseif groupe == "yeo" then -- irrégulier-여
		if alt then
			str = str .. "여"
		else
			str = mw.ustring.gsub(str, "ㅏ$", "ㅐ")
		end
	elseif mw.ustring.match(str, "[ㄱ-ㅎ]$") then -- régulier consonantique/-ㄹ
		str = str .. "ㅇ" .. hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ]?)[ㄱ-ㅎ]$")]
	elseif mw.ustring.match(str, "ㅡ$") then -- régulier-으
		str = mw.ustring.gsub(str, "ㅡ$", hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ]?)[ㄱ-ㅎ]ㅡ$")])
	else -- régulier vocalique
		if mw.ustring.match(str, "[ㅏㅑㅓㅕㅘ]$") then
			-- faire rien
		elseif alt then -- forme longue
			str = str .. "ㅇ" .. hangeul.yinyang[mw.ustring.match(str, "([ㅏ-ㅣ])$")]
		else
			str = mw.ustring.gsub(str, "([ㅏ-ㅣ])$", function (voyelle)
			                                         	return hangeul.diphtongue_verbale[voyelle] or (voyelle .. "어")
			                                         end)
		end
	end

	return ko.compos(str, true)
end

return ko