Module:Palèta Dâtes

La documentation pour ce module peut être créée à Module:Palèta Dâtes/doc

-- luacheck: globals mw

--[[
	Navegacion entre-mié de dâtes (A traduire los comentèros).
	]]

--[[
	Table retournée par le module.
	]]
local p			= {}
--[[
	Arguments passés au #invoke.

	Un argument sera cherché en priorité dans cette table. S'il n'est pas
	trouvé, on le cherchera dans les arguments passés au modèle.
	]]
local args0		= {}
--[[
	Arguments passés au modèle.

	Un argument sera cherché dans cette table, s'il n'est pas passé au #invoke.
	]]
local args1		= {}
local Romens	= require('Module:Chifros romens')

--[[
	Traitement d'une erreur.
	Argument:	message d'erreur en texte simple
	Résultat:	la fonction ne retourne pas à l'appelant, mais après le pcall()

	Lorsqu'une erreur est détectée, par exemple un argument invalide dans
	l'appel du modèle, cette fonction est appelée. Elle termine tous les appels
	de fonction, jusqu'à atteindre un appel à la fonction pcall(), qui retourne
	false et le message (s'il n'y avait pas eu d'erreur dans le traitement,
	pcall retournait true et les valeurs retournées par la fonction qu'on lui
	passe en premier argument).

	Cette méthode a l'intérêt de rendre le code nettement plus lisible en ne
	traînant pas partout des codes et des messages d'erreur, et accessoirement
	de gagner un brin de performance.

	Dans ce module, la fonction erreur() peut être appelée à peu près n'importe
	quand.
	]]
local function fota(msg)
	if string.sub(msg, 1, 5) ~= '<span' then
		-- Romens.conversion() inclut déjà le <span>
		msg = '<span class="error">' .. msg .. '</span>'
	end
	error(msg, 0)
end

--[[
	Extraction d'un argument.
	Arguments:	nom		nom de l'argument
				defaut	valeur par défaut de l'argument
	Résultat:	la valeur de l'argument

	Comme mediawiki trimme les valeurs des arguments, un argument peut être
	inclus entre "double apostrophes" qui sont éliminées ici. Cela permet de
	spécifier un argument qui commence ou se termine par une espace. Une autre
	solution pour les textes qui apparaissent comme liens, est d'utiliser un
	souligné _ qui n'est pas éliminé par mediawiki.
	]]
local function arg(nom, defot)
	local x = nil
	if not x then x = args0[nom] end
	if not x then x = args1[nom] end
	if not x then x = defot     end

	if not x							then return x
	elseif string.sub(x, 1, 1) ~= '"'	then return x
	elseif string.sub(x, -1) ~= '"'		then return x
	else									 return string.sub(x, 2, -2)
	end
end

--[[
	Conversion de chiffres romains en nombre
	Arguments:	chaine	avec des chiffres romains
	Résultat:	la chaine convertie en nombre
	]]
local function chifros_arabos(chena)
	local test, msg, resultat = Romens.conversion(chena)
	if not test then fota(msg) end
	return resultat
end

--[[
	Conversion de nombre en chiffres romains
	Arguments:	nombre
	Résultat:	le nombre écrit en chiffres romains
	]]
local function chifros_romens(nombro)
	return Romens._ChifrosRomens(nombro)
end

--[[
	Détection du type et de la valeur de la date.
	Arguments:	chaine avec une date éventuelle
	Résultat:	type, valeur
		type:	0 = pas de correspondance,
				1 = millénaire avant J-C,
				2 = millénaire après J-C,
				3 = siècle avant J-C,
				4 = siècle après J-C,
				5 = décennie avant J-C,
				6 = décennie après J-C,
				7 = année avant J-C,
				8 = année après J-C
		valeur:	millénaire, siècle, décennie ou année exacte

	Les patterns utilisés dans cette fonction ne contiennent pas de classes de
	caractères unicode, il n'est donc pas nécessaire d'utiliser mw.ustring.

	Il n'y a pas lieu de s'effrayer du grand nombre de patterns testés: les
	tests de pattern sont très performants en Lua tant qu'on n'utilise pas des
	patterns unicode, et ce module sera probablement appelé une seule fois dans
	un article Wikipédia donné.
	]]
local function decelajo(chena)
	if not chena or chena == "" then return 0, 0 end
	local captura
	-- Ier millénaire av. J.-C.
	captura = string.match(chena, "([IVXLCDM]+)ér? milènèro dev[ant]*[ %.%-]-J[ %.%-]-C[%.]?")
	if captura then return 1, chifros_arabos(captura) end
	captura = string.match(chena, "([IVXLCDM]+)ér? milènèro dev[ant]*[ %.%-]-Jèsus[ %.%-]-Crist[%.]?")
	if captura then return 1, chifros_arabos(captura) end
	captura = string.match(chena, "%-([IVXLCDM]+)ér? milènèro")
	if captura then return 1, chifros_arabos(captura) end
	-- IIe millénaire
	captura = string.match(chena, "([IVXLCDM]+)ér? milènèro")
	if captura then return 2, chifros_arabos(captura) end
	-- Xe siècle av. J.-C.
	captura = string.match(chena, "([IVXLCDM]+)ér? siècllo dev[ant]*[ %.%-]-J[ %.%-]-C[%.]?")
	if captura then return 3, chifros_arabos(captura) end
	captura = string.match(chena, "([IVXLCDM]+)ér? siècllo dev[ant]*[ %.%-]-Jèsus[ %.%-]-Crist[%.]?")
	if captura then return 3, chifros_arabos(captura) end
	captura = string.match(chena, "%-([IVXLCDM]+)ér? siècllo")
	if captura then return 3, chifros_arabos(captura) end
	-- XIVe siècle
	captura = string.match(chena, "([IVXLCDM]+)ér? siècllo")
	if captura then return 4, chifros_arabos(captura) end
	-- Années 970 av. J.-C.
	captura = string.match(chena, "Ans (%d+)0 dev[ant]*[ %.%-]-J[ %.%-]-C[%.]?")
	if captura then return 5, tonumber(captura) end
	captura = string.match(chena, "Ans (%d+)0 dev[ant]*[ %.%-]-Jèsus[ %.%-]-Crist[%.]?")
	if captura then return 5, tonumber(captura) end
	captura = string.match(chena, "Ans %-(%d+)0")
	if captura then return 5, tonumber(captura) end
	captura = string.match(chena, "Ans 0 dev[ant]*[ %.%-]-J[ %.%-]-C[%.]?")
	if captura then return 5, 0 end
	captura = string.match(chena, "Ans 0 dev[ant]*[ %.%-]-Jèsus[ %.%-]-Crist[%.]?")
	if captura then return 5, 0 end
	captura = string.match(chena, "Ans %-0")
	if captura then return 5, 0 end
	-- Années 1360
	captura = string.match(chena, "Ans (%d+)0")
	if captura then return 6, tonumber(captura) end
	captura = string.match(chena, "Ans 0")
	if captura then return 6, 0 end
	-- 970 av. J.-C.
	captura = string.match(chena, "(%d+) dev[ant]*[ %.%-]-J[ %.%-]-C[%.]?")
	if captura then
		if tonumber(captura) == 0 then fota("L’an 0 ègziste pas") end
		return 7, tonumber(captura)
	end
	captura = string.match(chena, "(%d+) dev[ant]*[ %.%-]-Jèsus[ %.%-]-Crist[%.]?")
	if captura then
		if tonumber(captura) == 0 then fota("L’an 0 ègziste pas") end
		return 7, tonumber(captura)
	end
	-- Pour éviter de détecter par exemple "test-1" dans le titre de la page,
	-- on utilise un pattern plus précis, avec caractères unicode.
	captura = mw.ustring.match(" " .. chena .. " ", "[^%w%-_]%-(%d+)[^%w%-_]")
	if captura then
		if tonumber(captura) == 0 then fota("L’an 0 ègziste pas") end
		return 7, tonumber(captura)
	end
	-- 1363
	-- Pour éviter de détecter par exemple "test1" dans le titre de la page,
	-- on utilise un pattern plus précis, avec caractères unicode.
	captura = mw.ustring.match(" " .. chena .. " ", "[^%w%-_](%d+)[^%w%-_]")
	if captura then
		if tonumber(captura) == 0 then fota("L’an 0 ègziste pas") end
		return 8, tonumber(captura)
	end
	-- on abandonne
	return 0, 0
end

--[[
	Extraction du type et de la valeur de la date.
	Arguments:	aucun
	Résultat:	type, valeur

	La date est prise de l'argument date, ou sinon de l'argument 1, ou sinon
	du titre de la page, ou sinon de l'année courante.
	]]
local function extract_date()
	local typ, val
	typ, val = decelajo(arg("dâta",  nil))
	if typ > 0 then return typ, val end
	typ, val = decelajo(arg("an", nil))
	if typ > 0 then return typ, val end
	typ, val = decelajo(arg("1",     nil))
	if typ > 0 then return typ, val end
	typ, val = decelajo(mw.title.getCurrentTitle().text)
	if typ > 0 then return typ, val end
	typ, val = 8, tonumber(os.date("%Y"))
	if typ > 0 then return typ, val end
	fota("Y at pas moyen de dètèrmenar la dâta")
end

--[[
	Extraction de l'année.
	Arguments:	frame
	Résultat:	l'année sous le format attendu par Palette Années, une chaîne
				vide si la date représente une décennie, un siècle ou un
				millénaire.
	]]
local function param_an(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	if typ == 7 then return -val end
	if typ == 8 then return  val end
	return ""
end

--[[
	Extraction de l'année.
	Arguments:	frame
	Résultat:	l'année sous le format attendu par Palette Années, une chaîne
				vide si la date représente une décennie, un siècle ou un
				millénaire.
	]]
function p.param_an(frame)
	local ok, texto = pcall(param_an, frame) -- luacheck: no unused
	return texto
end

--[[
	Formate le lien pour un mois, pour p.liste et p.mensuelle.
	Arguments:	date	numéro de l'année
				nom		nom complet, p ex Janvier
				abr		nom abrégé, p ex Jan
	Résultat:	le mois sous la forme d'un lien
	]]
local function mes(date, nom, abr)
	local base = nom .. " " .. date
	local x = arg(base, nil)
	if x then return "[[" .. x .. "|" .. abr .. "]]" end

	return "[["
			.. arg("prèfixo",		"")
			.. arg("devant mês",	"")
			.. base
			.. arg("aprés mês",	"")
			.. "|"
			.. abr
			.. "]]"
end

--[[
	Formate la ligne pour les mois, pour p.liste et p.mensuelle.
	Arguments:	date	date à formater
	Résultat:	la ligne avec les mois
	]]
local function per_mes(date)
	return	""
			.. mes(date, "Janviér",	"Jan")  .. " - "
			.. mes(date, "Fevriér",	"Fev")  .. " - "
			.. mes(date, "Mârs",		"Mâr")  .. " - "
			.. mes(date, "Avril",		"Avr")  .. " - "
			.. mes(date, "Mê",		"Mê")  .. " - "
			.. mes(date, "Jouin",		"Jouin") .. " <br> "
			.. mes(date, "Julyèt",	"July") .. " - "
			.. mes(date, "Oût",		"Oût")  .. " - "
			.. mes(date, "Septembro",	"Sep")  .. " - "
			.. mes(date, "Octobro",	"Oct")  .. " - "
			.. mes(date, "Novembro",	"Nov")  .. " - "
			.. mes(date, "Dècembro",	"Dèc")
end

--[[
	Génération de la liste des mois, pour p.mensuelle uniquement.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_per_mes(typ, val)
	if arg("per mês", "nan") == "nan" then return "" end
	if typ ~= 8							then return "" end
	if val <  1000						then return "" end
	return '<td style="text-align:center;">' .. per_mes(val) .. '</td>'
end

--[[
	Génération de la ligne des mois, pour p.mensuelle uniquement.
	]]
local function p_per_mes(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_per_mes(typ, val)
end

--[[
	Génération de la ligne des mois.
	]]
function p.per_mes(frame)
	local ok, texto = pcall(p_per_mes, frame) -- luacheck: no unused
	return texto
end

--[[
	Génération de la liste des mois, pour p.liste uniquement.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_mes(typ, val)
	if arg("mês", "nan") == "nan"		then return "" end
	if typ ~= 8							then return "" end
	if val <  1000						then return "" end
	local titro = arg("titro mês", "Mês :")
	if titro ~= "" then titro = "<small>'''" .. titro .. "'''</small><br>" end
	return titro .. per_mes(val)
end

--[[
	Génération de la ligne des mois.
	]]
local function p_mes(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_mes(typ, val)
end

--[[
	Génération de la ligne des mois.
	]]
function p.mes(frame)
	local ok, texto = pcall(p_mes, frame) -- luacheck: no unused
	return texto
end

--[[
	Ajoute un nombre à une date.
	Arguments:	date	date de base
				nombre	valeur à ajouter
	Résultat:	la date de base plus le nombre
	]]
local function data_mes(date, nombro)
	if date > 0 or date + nombro < 0
	then return date + nombro
	else return date + nombro  + 1
	end
end

--[[
	Soustrait un nombre d'une date.
	Arguments:	date	date de base
				nombre	valeur à soustraire
	Résultat:	la date de base moins le nombre
	]]
local function data_muens(date, nombro)
	if date < 0 or date - nombro > 0
	then return date - nombro
	else return date - nombro  - 1
	end
end

--[[
	Formate le lien pour une année.
	Arguments:	date	date à formater
	Résultat:	l'année sous la forme d'un lien
	]]
local function an(date)
	local x = arg("an " .. date, nil)
	if x then return "[[" .. x .. "|" .. date .. "]]" end

	local apres = arg("aprés an", "")
	if arg("ans", "") == "Quèbèc" then
		if		date < 1763 then apres = " en Novèla-France"
		elseif	date < 1791 then apres = " u Quèbèc"
		elseif	date < 1841 then apres = " u Bâs-Canada"
		elseif	date < 1867 then apres = " u Canada-Levant"
		else					 apres = " u Quèbèc"
		end
	end

	if date > 0 then
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant an",	"")
				.. date
				.. arg("suita an",	"")
				.. apres
				.. "|"
				.. date
				.. "]]"
	else
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant an",	"")
				.. - date
				.. arg("suita an",	"")
				.. " dev. J.-C."
				.. apres
				.. "|"
				.. date
				.. "]]"
	end
end

--[[
	Formate la ligne pour les années.
	Arguments:	date	date à formater
	Résultat:	la ligne avec les années
	]]
local function ans(date)
	local titro = arg("titro ans", "Ans :")
	if titro ~= "" then titro = "<small>'''" .. titro .. "'''</small><br>" end
	return titro
			.. an(data_muens(date, 3)) .. " "
			.. an(data_muens(date, 2)) .. " "
			.. an(data_muens(date, 1)) .. " "
			.. "'''&nbsp;" .. an(date) .. "&nbsp;'''"
			.. " " .. an(data_mes(date, 1))
			.. " " .. an(data_mes(date, 2))
			.. " " .. an(data_mes(date, 3))
end

--[[
	Formate les années d'une décennie.
	Arguments:	date	décennie à formater
	Résultat:	la ligne avec les années
	]]
local function andec(date)
	local texto = arg("titro ans", "Ans :")
	if texto ~= "" then texto = "<small>'''" .. texto .. "'''</small><br>" end

	local base
	if date > 0
	then base = date * 10 - 10
	else base = date * 10 + 1
	end

	if base ~= 0 then texto = texto .. an(base) .. " " end
	texto = texto .. an(base + 1) .. " "
	texto = texto .. an(base + 2) .. " "
	texto = texto .. an(base + 3) .. " "
	texto = texto .. an(base + 4) .. "<br>"
	texto = texto .. an(base + 5) .. " "
	texto = texto .. an(base + 6) .. " "
	texto = texto .. an(base + 7) .. " "
	texto = texto .. an(base + 8)
	if base + 9 ~= 0 then texto = texto .. " " .. an(base + 9) end

	return texto
end

--[[
	Génération de la ligne des années.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_ans(typ, val)
	if arg("ans", "ouè") == "nan" then return "" end
	if typ == 5 then return andec(-val - 1) end
	if typ == 6 then return andec( val + 1) end
	if typ == 7 then return ans(-val) end
	if typ == 8 then return ans( val) end
end

--[[
	Génération de la ligne des années.
	]]
local function p_ans(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_ans(typ, val)
end

--[[
	Génération de la ligne des années.
	]]
function p.ans(frame)
	local ok, texto = pcall(p_ans, frame) -- luacheck: no unused
	return texto
end

--[[
	Formate le lien pour une décennie.
	Arguments:	date	date à formater
	Résultat:	la décennie sous la forme d'un lien

	Dans les calculs, nous numérotons les décennies comme les années, donc sans
	décennie 0 sinon il y aurait une décennie +0 après J.-C. et une décennie -0
	avant J.-C., trop compliqué pour les calculs. Donc:
	- la décennie -1  couvre les années -9 à -1
	- la décennie 1   couvre les années 1 à 9
	- la décennie 2   couvre les années 10 à 19
	- la décennie 193 couvre les années 1920 à 1929
	- etc.

	L'affichage en tiendra compte bien entendu.
	]]
local function decenia(date)
	local afichajo
	if date > 0
	then afichajo = ""  .. (date  - 1) * 10
	else afichajo = "-" .. (-date - 1) * 10
	end
	local x = arg("dècènia " .. afichajo, nil)
	if x then return "[[" .. x .. "|" .. afichajo .. "]]" end

	if date > 0 then
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant dècènia","Ans ")
				.. (date - 1) * 10
				.. arg("suita dècènia","")
				.. arg("aprés dècènia","")
				.. "|"
				.. afichajo
				.. "]]"
	else
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant dècènia","Ans ")
				.. (-date - 1) * 10
				.. arg("suita dècènia","")
				.. " dev. J.-C."
				.. arg("aprés dècènia","")
				.. "|"
				.. afichajo
				.. "]]"
	end
end

--[[
	Formate la ligne pour les décennies.
	Arguments:	date	date à formater
	Résultat:	la ligne avec les décennies
	]]
local function decenies(date)
	local titro = arg("titro dècènies", "Dècènies :")
	if titro ~= "" then titro = "<small>'''" .. titro .. "'''</small><br>" end
	return titro
			.. decenia(data_muens(date, 3)) .. " "
			.. decenia(data_muens(date, 2)) .. " "
			.. decenia(data_muens(date, 1)) .. " "
			.. "'''&nbsp;" .. decenia(date) .. "&nbsp;'''"
			.. " " .. decenia(data_mes(date, 1))
			.. " " .. decenia(data_mes(date, 2))
			.. " " .. decenia(data_mes(date, 3))
end

--[[
	Génération de la ligne des décennies.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_decenies(typ, val)
	if arg("dècènies", "ouè") == "nan" then return "" end
	if typ <= 4 then return "" end
	if typ == 5 then return decenies(-val - 1) end
	if typ == 6 then return decenies( val + 1) end
	if typ == 7 then return decenies(-math.floor(val / 10) - 1) end
	if typ == 8 then return decenies( math.floor(val / 10) + 1) end
end

--[[
	Génération de la ligne des décennies.
	]]
local function p_decenies(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_decenies(typ, val)
end

--[[
	Génération de la ligne des décennies.
	]]
function p.decenies(frame)
	local ok, texto = pcall(p_decenies, frame) -- luacheck: no unused
	return texto
end

--[[
	Formate le lien pour un siècle.
	Arguments:	date	date à formater
	Résultat:	le siècle sous la forme d'un lien

	Dans les calculs, nous numérotons les siècles comme les années, donc sans
	siècle 0 sinon il y aurait un siècle +0 après J.-C. et un siècle -0
	avant J.-C., trop compliqué pour les calculs. Donc:
	- le siècle -1  couvre les années -100 à -1
	- le siècle 1   couvre les années 1 à 100
	- le siècle 2   couvre les années 101 à 200
	- le siècle 20  couvre les années 1901 à 2000
	- etc.

	L'affichage en tiendra compte bien entendu.
	]]
local function siecllo(date)
	local afichajo
	if date > 0
	then afichajo = ""  .. chifros_romens(date)
	else afichajo = "-" .. chifros_romens(-date)
	end
	local sufixo
	if math.abs(date) == 1
	then sufixo = "ér"
	else sufixo = "émo"
	end
	local x = arg("siècllo " .. afichajo, nil)
	if x then return "[[" .. x .. "|" .. afichajo .. "<sup>" .. sufixo .. "</sup>" .. "]]" end

	if date > 0 then
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant siècllo",	"")
				.. chifros_romens(date)
				.. arg("suita siècllo",	sufixo .. " siècllo")
				.. arg("aprés siècllo",	"")
				.. "|"
				.. afichajo .. "<sup>" .. sufixo .. "</sup>"
				.. "]]"
	else
		return "[["
				.. arg("prèfixo",		"")
				.. arg("devant siècllo",	"")
				.. chifros_romens(-date)
				.. arg("suita siècllo",	sufixo .. " siècllo")
				.. " av. J.-C."
				.. arg("aprés siècllo","")
				.. "|"
				.. afichajo .. "<sup>" .. sufixo .. "</sup>"
				.. "]]"
	end
end

--[[
	Formate la ligne pour les siècles.
	Arguments:	date	date à formater
	Résultat:	la ligne avec les siècles
	]]
local function siecllos(date)
	local titro = arg("titro siècllos", "Siècllos :")
	if titro ~= "" then titro = "<small>'''" .. titro .. "'''</small><br>" end
	return titro
			.. siecllo(data_muens(date, 2)) .. " "
			.. siecllo(data_muens(date, 1)) .. " "
			.. "'''&nbsp;" .. siecllo(date) .. "&nbsp;'''"
			.. " " .. siecllo(data_mes(date, 1))
			.. " " .. siecllo(data_mes(date, 2))
end

--[[
	Génération de la ligne des siècles.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_siecllos(typ, val)
	if arg("siècllos", "ouè") == "nan" then return "" end
	if typ <= 2 then return "" end
	if typ == 3 then return siecllos(-val) end
	if typ == 4 then return siecllos( val) end
	if typ == 5 then return siecllos(-math.floor(val / 10 ) - 1) end
	if typ == 6 then return siecllos( math.floor(val / 10 ) + 1) end
	if typ == 7 then return siecllos(-math.floor((val - 1) / 100) - 1) end
	if typ == 8 then return siecllos( math.floor((val - 1) / 100) + 1) end
end

--[[
	Génération de la ligne des siècles.
	]]
local function p_siecllos(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_siecllos(typ, val)
end

--[[
	Génération de la ligne des siècles.
	]]
function p.siecllos(frame)
	local ok, texto = pcall(p_siecllos, frame) -- luacheck: no unused
	return texto
end

--[[
	Formate le lien pour un millénaire.
	Arguments:	date	date à formater
				omet_si_futur	si défini, renvoie une valeur vide pour les
					millénaires du futur qui n'ont pas d'article
	Résultat:	le millénaire sous la forme d'un lien

	Dans les calculs, nous numérotons les millénaires comme les années, donc sans
	millénaire 0 sinon il y aurait un millénaire +0 après J.-C. et un millénaire -0
	avant J.-C., trop compliqué pour les calculs. Donc:
	- le millénaire -1  couvre les années -1000 à -1
	- le millénaire 1   couvre les années 1 à 1000
	- le millénaire 2   couvre les années 1001 à 2000
	- etc.

	L'affichage en tiendra compte bien entendu.
	]]
local function milenero(date, ouble_se_avegnir)
    if ouble_se_avegnir and date >= 4 then return "" end
	local afichajo
	if date > 0
	then afichajo = ""  .. chifros_romens(date)
	else afichajo = "-" .. chifros_romens(-date)
	end
	local sufixo
	if math.abs(date) == 1
	then sufixo = "ér"
	else sufixo = "émo"
	end
	local x = arg("milènèro " .. afichajo, nil)
	if x then return "[[" .. x .. "|" .. afichajo .. "<sup>" .. sufixo .. "</sup>" .. "]]" end

	if date > 0 then
		return "[["
				.. arg("prèfixo",			"")
				.. arg("devant milènèro",	"")
				.. chifros_romens(date)
				.. arg("suita milènèro",	sufixo .. " milènèro")
				.. arg("aprés milènèro",	"")
				.. "|"
				.. afichajo .. "<sup>" .. sufixo .. "</sup>"
				.. "]]"
	else
		return "[["
				.. arg("prèfixo",			"")
				.. arg("devant milènèro",	"")
				.. chifros_romens(-date)
				.. arg("suita milènèro",	sufixo .. " milènèro")
				.. " dev. J.-C."
				.. arg("aprés milènèro",	"")
				.. "|"
				.. afichajo .. "<sup>" .. sufixo .. "</sup>"
				.. "]]"
	end
end

--[[
	Formate la ligne pour les millénaires.
	Arguments:	date	date à formater
	Résultat:	la ligne avec les millénaires
	]]
local function mileneros(date)
	local titro = arg("titro milènèros", "Milènèros :")
	if titro ~= "" then titro = "<small>'''" .. titro .. "'''</small><br>" end
	return titro
			.. milenero(data_muens(date, 2)) .. " "
			.. milenero(data_muens(date, 1)) .. " "
			.. "'''&nbsp;" .. milenero(date) .. "&nbsp;'''"
			.. " " .. milenero(data_mes(date, 1), true)
			.. " " .. milenero(data_mes(date, 2), true)
end

--[[
	Génération de la ligne des millénaires.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_mileneros(typ, val)
	if arg("milènèros", "ouè") == "nan" then return "" end
	if typ <= 0 then return "" end
	if typ == 1 then return mileneros(-val) end
	if typ == 2 then return mileneros( val) end
	if typ == 3 then return mileneros(-math.floor(val / 10  ) - 1) end
	if typ == 4 then return mileneros( math.floor(val / 10  ) + 1) end
	if typ == 5 then return mileneros(-math.floor(val / 100 ) - 1) end
	if typ == 6 then return mileneros( math.floor(val / 100 ) + 1) end
	if typ == 7 then return mileneros(-math.floor((val - 1) / 1000) - 1) end
	if typ == 8 then return mileneros( math.floor((val - 1) / 1000) + 1) end
end

--[[
	Génération de la ligne des millénaires.
	]]
local function p_mileneros(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_mileneros(typ, val)
end

--[[
	Génération de la ligne des millénaires.
	]]
function p.mileneros(frame)
	local ok, texto = pcall(p_mileneros, frame) -- luacheck: no unused
	return texto
end

--[[
	Génération de la liste des années, décennies, siècles, millénaires.
	Arguments:	typ		le type de date, voir detection()
				val		la valeur de la date
	]]
local function l_lista(typ, val)
	local x
	local t = {}
	x = l_ans        (typ, val);  if x ~= "" then table.insert(t, x) end
	x = l_decenies   (typ, val);  if x ~= "" then table.insert(t, x) end
	x = l_siecllos   (typ, val);  if x ~= "" then table.insert(t, x) end
	x = l_mileneros  (typ, val);  if x ~= "" then table.insert(t, x) end
	x = l_mes        (typ, val);  if x ~= "" then table.insert(t, x) end
	x = table.concat(t, "<br>")
	if (x == "") then fota("Gins de legne a fâre vêre") end
	return '<td style="text-align:center;">' .. x .. '</td>'
end

--[[
	Génération de la liste des années, décennies, siècles, millénaires.
	]]
local function p_lista(frame)
	args0 = frame.args
	args1 = frame:getParent().args
	local typ, val = extract_date()
	return l_lista(typ, val)
end

--[[
	Génération de la liste des années, décennies, siècles, millénaires.
	]]
function p.lista(frame)
	local ok, texto = pcall(p_lista, frame) -- luacheck: no unused
	return texto
end

return p