Module:Date républicaine

Documentation[voir] [modifier] [historique] [purger]

Le module date républicaine permet la mise en forme de dates du calendrier républicain. Il est lié aux modèles {{date républicaine}} et {{date républicaine-}}.

Utilisation

Fonctions utilisables depuis un modèle

date_republicaine(frame) – renvoie une chaîne de caractères présentant une date du calendrier républicain avec les liens les plus pertinents en respectant les conventions typographiques, et éventuellement la date du calendrier républicain correspondante.
date_republicaine_sans_liens(frame) – renvoie une chaîne de caractères présentant une date du calendrier républicain en respectant les conventions typographiques, et éventuellement la date du calendrier républicain correspondante.

Fonctions utilisables depuis un autre module

conversion_Gregorien(jour, mois, an) – renvoie les jours, mois et années dans le calendrier républicain à partir des jour, mois et année dans le calendrier grégorien.
_date_republicaine(liens, {a1, a2, a3, a4}) – renvoie une chaîne de caractères présentant une date du calendrier républicain avec les liens les plus pertinents en respectant les convention typographiques (en paramètres : un booléen indiquant s'il faut faire des liens, et un table contenant une chaine de caractères avec une date du calendrier républicain en extension (« jour mois année », ou une chaîne de caractère par élément (« jour », « mois », « année »)).

Autres fonctions

extraction_argument (argument, chaine) – extrait de « argument » une chaine de caractère correspondant au pattern « chaine » ainsi que des informations sur le mode d'affichage de l'élément (suivi de « - » : ne pas afficher ; suivi de « * », ne pas présenter de lien wiki pour cet élément), et renvoie argument délesté de cette chaîne.
test_argument (argument) – analyse les paramètres fournis à la fonction _date républicaine(frame)
annee_affichee(annee, lien_annee, libelle_an) – mise en forme de l'année (liens et typographie) composant une date du calendrier républicain.
categorie_erreur (message) – mise en forme d'un message d'erreur avec insertion d'une catégorie de maintenance.

Modules externes dont ce module a besoin pour fonctionner

Module:Date - mise en forme des dates du calendrier grégorien.
Module:Chiffres romains - mise en forme des expressions contenant des chiffres romains.
Module:Outils - bibliothèque d'outils.

Fonctionnement

La mise en forme et le paramétrage ont été définis en fonction des conventions typographiques et de l'usage de présentation des dates dans les articles.

Le frame reçu peut se présenter sous deux formes :

avec séparateurs : {{date républicaine|jour|mois|année|(paramètre conversion optionnel)}} ;
sans séparateurs : {{date républicaine|jour mois année|(paramètre conversion optionnel)}}.

Le module analyse crée une chaîne concaténant tous les paramètres qui ne contiennent pas « conversion ». Il est nécessaire que :

l'année, si elle est fournie, soit en chiffres romains ; elle peut être précédée de « an » ou « de l'an », avec ou sans majuscule, les deux apostrophes sont acceptées ;
l'orthographe du mois, si il est fourni, soit exacte aux accents près ;
le jour, s'il est fourni, soit numérique.

Les liens créés suivent la même logique que le modèle date :

pour le jour : [[jour mois]], sinon pas de lien ;
pour le mois : [[mois année]], sinon [[mois]] (tous les mois ont un article) ;
pour l'année : [[année]] (toutes les années ont un article).

Accessibilité :

les nombres en chiffres romains sont dotés d'une infobulle donnant leur valeur en chiffres arabes.

Typographie :

les éléments sont séparés par des espaces insécables ;
les mois et année sont affichés avec une minuscule, sauf dans le cas où ils sont les premiers éléments de la chaîne de caractère renvoyée, auquel cas la casse retenue est celle fournie en entrée (cas où le mois ou l'année sont au début d'une phrase) ;
le choix de l'apostrophe est laissé au rédacteur, le module restitue celle fournie en entrée.

Mode de sélection des éléments affichés :

comme pour le module Date, la mention d'un « - » accolé à un élément permet d'en éviter l'affichage ;
la mention d'un « * » accolé à un élément permet d'éviter l'affichage d'un lien pour cet élément (inutile pour le module Date_republicaine_sans_lien, mais ne provoque pas d'erreur).

Paramètre de conversion en date grégorienne (passage d'un élément contenant « conversion » ou « grégorien ») :

séparateur :
- par défaut, la présentation est de la forme « jj mois an NN (jj mois an) »,
- en précisant « : » (« conversion: » ou « grégorien: »), la présentation est de la forme « jj mois an NN : jj mois an » ;
affichage ou non des liens :
- sa mention simple permet l'affichage de la date grégorienne correspondante entre parenthèses, avec les liens (équivalent du modèle {{date}}),
- sa mention avec « * » fait la même chose sans liens (équivalent du modèle {{date-}}) ;
sélection des éléments à afficher :
- l'ajout d'une combinaison des lettres j, m et a (j : jour, m : mois, a : année) permet de sélectionner les éléments de la date grégorienne à afficher. Sans précision ou en précisant « jma » tout est affiché, en précisant « jm » seul le jour et le mois sont affichés, etc.

Exemples

Pour plus d'exemples, voir les pages de test des modèles date républicaine et date républicaine- permettant d'évaluer les modifications apportées.

{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II}} → 1^er vendémiaire an II
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire de l’an II}} → Erreur Lua à la ligne 319 : attempt to call field 'erreur' (a nil value).
{{#invoke:Date républicaine|date_republicaine_sans_liens|1er vendémiaire an II}} → 1^er vendémiaire an II
{{#invoke:Date républicaine|date_republicaine|2 vendémiaire an II}} → 2 vendémiaire an II
{{#invoke:Date républicaine|date_republicaine|2 vendémiaire an III}} → 2 vendémiaire an III
{{#invoke:Date républicaine|date_republicaine|Vendémiaire an III}} → Vendémiaire an III
{{#invoke:Date républicaine|date_republicaine|An III}} → An III
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire* an II}} → 1^er vendémiaire an II
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II-}} → 1^er vendémiaire
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien}} → Erreur Lua à la ligne 319 : attempt to call field 'erreur' (a nil value).
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien*}} → Erreur Lua à la ligne 319 : attempt to call field 'erreur' (a nil value).
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien:}} → Erreur Lua à la ligne 319 : attempt to call field 'erreur' (a nil value).
{{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien jm}} → Erreur Lua à la ligne 319 : attempt to call field 'erreur' (a nil value).

Projet Scribunto

La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis sa sous-page de documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (modifier).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.

local p = {}
local Outils = require( 'Module:Outils' )
local trim = Outils.trim
local OutilsDates = require( 'Module:Date' )
local modeleDate = OutilsDates.modeleDate

local test_conversion = false

local jour, jour_affiche = '', ''
local article = ''
local test = true
local message = ''

local type_romains = "[IVXL]+"
local type_nombre = "[0-9]+"
local type_quantieme = "[1-3]?[0-9][er]?"
local type_1er = "1er"
local type_an_republicain = "[Aa]n [IVXL]+"
local type_jour_complementaire = "[1-6]e%*?%-? [Jj]our compl[eé]mentaire"

-- Table des libellés à afficher pour 1er, 2e, 3e, 4e, 5e, 6e
local infobulle = {
	["1er"] = "Premier",
	["2e"] = "Deuxième",
	["3e"] = "Troisième",
	["4e"] = "Quatrième",
	["5e"] = "Cinquième",
	["6e"] = "Sixième"
}

-- Table des noms des mois républicains, avec la casse de la première lettre et les erreurs acceptables
local listeNomsMois = {
	{"vendémiaire", "vendémiaire"},
	{"vendemiaire", "vendémiaire"},
	{"Vendémiaire", "vendémiaire"},
	{"Vendemiaire", "vendémiaire"},
    {"brumaire", "brumaire"},
    {"Brumaire", "brumaire"},
    {"frimaire", "frimaire"},
    {"Frimaire", "frimaire"},
    {"nivôse", "nivôse"},
    {"nivose", "nivôse"},
    {"Nivôse", "nivôse"},
    {"Nivose", "nivôse"},
    {"pluviôse", "pluviôse"},
    {"pluviose", "pluviôse"},
    {"Pluviôse", "pluviôse"},
    {"Pluviose", "Pluviôse"},
    {"ventôse", "ventôse"},
    {"ventose", "ventôse"},
    {"Ventôse", "ventôse"},
    {"Ventose", "ventôse"},
    {"germinal", "germinal"},
    {"Germinal", "germinal"},
    {"floréal", "floréal"},
    {"floreal", "floréal"},
    {"Floréal", "floréal"},
    {"Floreal", "floréal"},
    {"prairial", "prairial"},
    {"Prairial", "prairial"},
    {"messidor", "messidor"},
    {"Messidor", "messidor"},
    {"thermidor", "thermidor"},
    {"Thermidor", "thermidor"},
    {"fructidor", "fructidor"},
    {"Fructidor", "fructidor"},
    {"jour complémentaire", "jour complémentaire"},
    {"jour complementaire", "jour complémentaire"},
    {"Jour complémentaire", "jour complémentaire"},
    {"Jour complementaire", "jour complémentaire"}
}

-- Table des noms des mois républicains, avec la casse de la première lettre et les erreurs acceptables
local listeOrdreMois = {
	["vendémiaire"] = 1,
    ["brumaire"] = 2,
    ["frimaire"] = 3,
    ["nivôse"] = 4,
    ["pluviôse"] = 5,
    ["ventôse"] = 6,
    ["germinal"] = 7,
    ["floréal"] = 8,
    ["prairial"] =9,
    ["messidor"] = 10,
    ["thermidor"] = 11,
    ["fructidor"] = 12,
    ["jour complémentaire"] = 13
}

-- Liste des jours complémentaires
local listeJoursComplementaires = {
	"jour de la vertu",
	"Jour de la vertu",
    "jour du génie",
    "Jour du génie",
    "jour du travail",
    "Jour du travail",
    "jour de l'opinion",
    "Jour de l'opinion",
    "jour des récompenses",
    "Jour des récompenses",
    "jour de la Révolution",
    "Jour de la Révolution"
}

-- Table temporaire pour éviter les requêtes de test d'existence des articles.
-- Liste des articles existants sur les jours/mois, à remplacer par un table externe
local listeArticlesJours = {
	["1er vendémiaire"] = true,
    ["7 vendémiaire"] = true,
    ["13 vendémiaire"] = true,
    ["14 vendémiaire"] = true,
    ["15 vendémiaire"] = true,
    ["16 vendémiaire"] = true,
    ["17 vendémiaire"] = true,
    ["18 vendémiaire"] = true,
    ["19 vendémiaire"] = true,
    ["20 vendémiaire"] = true,
    
    ["18 brumaire"] = true,
    ["19 brumaire"] = true,
    ["20 brumaire"] = true,
    ["21 brumaire"] = true,
    ["22 brumaire"] = true,
    ["12 brumaire"] = true,
    ["23 brumaire"] = true,
    ["24 brumaire"] = true,
    
    ["4 frimaire"] = true,
    ["10 frimaire"] = true,
    ["11 frimaire"] = true,
    
    ["25 nivôse"] = true,
    ["13 nivôse"] = true,
    
    ["13 pluviôse"] = true,
    ["16 pluviôse"] = true,
    
    ["19 ventôse"] = true,
    
    ["16 germinal"] = true,
    ["11 germinal"] = true,
    
    ["10 floréal"] = true,
    
    ["25 prairial"] = true,
    ["30 prairial"] = true,
    
    ["8 messidor"] = true,
    ["23 messidor"] = true,
    ["30 messidor"] = true,
    
    ["9 thermidor"] = true,
    
    ["18 fructidor"] = true,
    ["20 fructidor"] = true,
    ["30 fructidor"] = true,
    ["6 fructidor"] = true
}

-- Table temporaire pour éviter les requêtes de test d'existence des articles.
-- Liste des articles existants sur les mois/année, à remplacer par un table externe
local listeArticlesMois = {
    ["floréal an LXXIX"] = true,
    ["prairial an LXXIX"] = true,
	["vendémiaire an II"] = true
}
   
-- liste des chiffres romains pour contrôle mise en forme de l'infobulle
local listeRomains = {	["I"] = "1",
	["II"] = "2",
	["III"] = "3",
	["IV"] = "4",
	["V"] = "5",
	["VI"] = "6",
	["VII"] = "7",
	["VIII"] = "8",
	["IX"] = "9",
	["X"] = "10",
	["XI"] = "11", 
	["XII"] = "12",
	["XIII"] = "13",
	["XIV"] = "14",
	["LXXIX"] = "79"
}

-- extrait une chaîne de caractère (jour, mois ou année), en restituant cette chaîne et l'argument de départ délesté de cette chaîne
-- et en transférant vers des booléens les indicateurs d'affichage des éléments ou des liens
function p.extraction_argument (argument, chaine)
	local x, position = 0, 0
	local lien, afficher = true, true
	local extrait = ''
 	position = string.find (argument, chaine)
 	if position	then
	  	x = position + string.len(chaine)
	 	if x < (string.len(argument) + 1) then
	 		if string.sub(argument, x, x) == '*' then
	 			lien = false
	 			x=x+1
	 		else
	 			if string.sub(argument, x, x) == '-' then
	 				afficher = false
	 				x=x+1
	 			end
	 		end
	 	end
	 	extrait = string.sub(argument, position, x - 1)
		argument=string.sub(argument, 1, position - 1)..string.sub(argument, x)
	end
		
	return argument, extrait, afficher, lien
 end
 	
-- Extraction d'éventuels jour, mois et année du calendrier républicain.
-- Le paramètre en entrée est sous la forme d'une chaîne, le séparateur étant l'espace
-- l'année doit être en chiffres romains
-- "an" peut être omis devant l'année
-- le jour doit être numérique, "er" est toléré pour le premier jour de chaque mois
-- les paramètres peuvent être présentés dans n'importe quel ordre
-- les mois doivent être orthographiés correctement, les accents peuvent être omis. La majuscule n'est pas prise en compte
function p.test_argument (argument)
	local tab = { test = true,
					message = '',
					quantieme = '',
					exposant_jour = '',
					test_quantieme = false,
					test_jour_complementaire = false,
					mois = '',
					test_mois = false,
					an = '',
					test_an = false,
					lien_jour = true,
					lien_mois = true,
					lien_an = true,
					afficher_jour = true,
					afficher_mois = true,
					afficher_an = true,
					jour_saisi = '',
					complementaire_saisi = '',
					mois_saisi = '',
					an_saisi = '',
					libelle_an = ''
					}
	local position = 0

-- On retire l'éventuel "er" de "1er" pour simplifier le traitement qui suit
    if argument:match (type_1er) then
		argument=argument:gsub('1er', '1')
	end

-- On recherche si c'est sous la forme "6e jour complémentaire" pour écarter le "e"
	if mw.ustring.find(argument, type_jour_complementaire) then
		tab.exposant_jour = 'e'
		position = mw.ustring.find (argument, type_jour_complementaire)
		if position	then
			if position == 1 then
				argument=mw.ustring.sub(argument, 1, 1)..mw.ustring.sub(argument, 3)
			else
				argument=mw.ustring.sub(argument, 1, position)..mw.ustring.sub(argument, position + 2)
			end
		end
	end

-- On recherche le mois, s'il existe il est retiré de la chaîne de caractère analysée
	for i = 1, 38 do
 		if string.find (argument, listeNomsMois[i][1]) then
 			argument, tab.mois_saisi, tab.afficher_mois, tab.lien_mois = p.extraction_argument (argument, listeNomsMois[i][1])
			tab.mois = listeNomsMois[i][2]
			tab.test_mois = true
  			i = 34
 		end
	end

-- On recherche s'il s'agit d'un des six "jours complémentaires", si c'est le cas il est retiré de la chaîne de caractère analysée
	for i = 1, 12 do
		if string.find (argument, listeJoursComplementaires[i]) then
 			argument, tab.complementaire_saisi, tab.afficher_jour, tab.lien_jour = p.extraction_argument (argument, listeJoursComplementaires[i])
			tab.test_jour_complementaire = true
			tab.quantieme = tab.complementaire_saisi
			i = 12
		end
	end
	
-- On recherche le jour en chiffres. Si on le trouve, il est retiré de la chaîne analysée
	if argument:match (type_nombre)	then
		tab.test_quantieme = true
		tab.quantieme = argument:match (type_nombre)
		if tab.quantieme == '1'	then
			tab.exposant_jour = 'er'
		end
		argument, tab.jour_saisi, tab.afficher_jour, tab.lien_jour = p.extraction_argument (argument, tab.quantieme)
	end

-- Si la chaîne analysée est vide, le traitement est terminé 
 	argument=trim(argument)
	if argument	then
		argument, tab.libelle_an = p.extraction_argument (argument, 'An')
		if not (tab.libelle_an == 'An') then
			argument, tab.libelle_an = p.extraction_argument (argument, 'an')
		end
-- On vérifie si la chaîne qui reste est une année sous la forme "XX"
		if argument:match (type_romains) then
			tab.test_an = true
			tab.an = argument:match (type_romains)
			argument, tab.an_saisi, tab.afficher_an, tab.lien_an = p.extraction_argument (argument, tab.an)
		end

		if tab.test_an then
			if not listeRomains[tab.an]	then
				tab.test = false
				tab.message = Outils.erreur ('année hors du calendrier républicain ('..tab.an..')')
				return tab
			end
		end
		argument=trim(argument)
		if argument	then
-- La chaîne n'est pas sous un format attendu, message d'erreur
 		 	tab.test = false
 			tab.message = Outils.erreur ('format de date incorrect ('..argument..')')
 		end
	end
	return tab
end

-- Mise en forme de l'année affichée ; le paramètre en entrée doit être sous la forme "XX"
function p.annee_affichee(annee, lien_annee, libelle_an)
	local chaine = ''
	local annee_affichee = ''
	local premier_car = ''
	if annee then
-- Vérification de la syntaxe en chiffres romains
		if annee:match (type_romains) then
			if libelle_an then
				annee_affichee = libelle_an..' '
			else
				annee_affichee = 'an '
			end
-- Récupération de la valeur affichée dans l'infobulle
			annee_affichee = annee_affichee..'<abbr class="abbr" title="'..listeRomains[annee]..'">'..annee..'</abbr>'
			if lien_annee then
-- Cas particulier de l'an I
				if annee == 'I'	then
					chaine = '[[An I du calendrier républicain|'..annee_affichee..']]'
				else
					chaine = '[[An '..annee..'|'..annee_affichee..']]'
				end
			else
				chaine = annee_affichee
			end
			return test, chaine
		end
	else
		test = false
		message = Outils.erreur ("aucune année passée en paramètre (annee_affichee)")
		return test, message
	end
end

-- Fonction calculant une date du calendrier grégorien à partir d'une date du calendrier républicain
function p.conversion_Gregorien (jour, mois, an, test_mois, test_complementaire)
-- table du nombre de jour écoulé depuis le début de l'année jusqu'au premier de chaque mois du calendrier grégorien
-- (sans tenir compte des années bissextiles)
	local rang_mois_Greg = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 }
	local x = 0
	local jour_Rep, mois_Rep, an_Rep, jour_Greg, mois_Greg, an_Greg = '', '', '', '', '', ''
	local message = ''
	local test = true

-- Fonction permettant de connaître le nombre de jours bissextiles entre deux années
    local function nb_jours_complement_bissextile (an)
    	local nb = 0
    	for i = 1792, 1791+an do
    		if  OutilsDates.isLeapYear(i) then
    			nb = nb + 1
    		end
    	end
    	return nb
    end
    
-- Si la date se présente sous la forme "nom de jour complémentaire an XX", on détermine le rang chronologique du jour en question 
	if test_jour_complementaire	then
		for i = 1, 12 do
			if listeJoursComplementaires[i] == jour	then
				jour_Rep = math.floor((i + 1)/2)
				i = 12
			end
		end
	else
		jour_Rep = tonumber(jour)
	end

-- Valeurs numériques de l'année et du mois républicains				
	an_Rep = tonumber(listeRomains[an])
	mois_Rep = listeOrdreMois[mois]

-- contrôles ?
--	if not (an_Rep < 14) and not (mois_Rep < 4)
--	then
--		if not (an_Rep == 79)
--		then
--			return false, 'Pas de conversion pour les dates non officielles'
--		end
--	end
	
-- On détermine le nombre de jour entre la date transmise et le 1er janvier 1792. On connaît le nombre de jour entre le 1er janvier
-- et le 22 septembre 1792, première journée du calendrier républicain : 265
-- On multiplie le nombre d'années écoulées avant l'année en cours par 365, et on ajoute un jour par année sextile (pour les périodes considérées,
-- durant lesquelles ce calendrier a été officiel, tous les quatre ans à partir de l'an III).
-- On multiplie le nomdre de mois écoulés avant le mois en cours par 30
-- On ajoute le quantième du jour transmis ou calculé
	jour_Greg = 365*(an_Rep -1) + 30*(mois_Rep - 1) + jour_Rep + math.floor(an_Rep/4) + 265
	
-- On ajoute le résultat de la division de la partie entière du nombre de jours trouvé par la durée d'une année,
-- en tenant compte des années bissextiles comprises dans la période
	an_Greg = 1792 + math.floor((jour_Greg - nb_jours_complement_bissextile (an_Rep)-1)/365)
	
-- On calcule le reste de jours en tenant compte des années bissextiles
-- (une toutes les 4 ans sauf celles qui sont divisibles par 4 et par cent mais pas par 400)
	jour_Greg = jour_Greg - (an_Greg-1792)*365 - math.floor((an_Greg-1789)/4) + math.floor(an_Greg/1801) + math.floor(an_Greg/1901)
	
-- On détermine le mois correspondant au résultat
	local n = 1
	local m = 1
	local r = 0
	local bissextile = OutilsDates.isLeapYear(an_Greg)
	for i = 1, 12 do
		r = rang_mois_Greg[i]
-- Prise en compte d'un éventuel 29 février (années bissextiles, via isLeapYear(year) du module Date)
		if bissextile then
			if i > 2 then
				r = r + 1
			end
		end
		if not(r < jour_Greg) then
			i = 12
		else
			n = r
			m = i
		end
	end
	
	mois_Greg = m
	jour_Greg = jour_Greg - n
	
	return test, message, jour_Greg, mois_Greg, an_Greg

end

-- Traitement des paramètres
function p._date_republicaine (aucun_lien, args)
	local tab = { test = true,
					message = '',
					quantieme = '',
					exposant_jour = '',
					test_quantieme = false,
					test_jour_complementaire = false,
					mois = '',
					test_mois = false,
					an = '',
					test_an = false,
					lien_jour = true,
					lien_mois = true,
					lien_an = true,
					afficher_jour = true,
					afficher_mois = true,
					afficher_an = true,
					jour_saisi = '',
					complementaire_saisi = '',
					mois_saisi = '',
					an_saisi = '',
					libelle_an = ''
					}
	local test_conversion, test_conversion_sans_lien = false, false
	local conv_jour_mois, conv_jour, conv_an, conv_mois_an = false, false, false, false
	local deux_points = false
	local parametres, chaine = '', ''
-- Les paramètres peuvent se présenter sous la forme d'une seule chaîne ou de 3 paramètres séparés.
-- Dans ce dernier cas, on constitue une chaîne en utilisant l'espace comme séparateur, ce qui permet un traitement unique pour les 2 cas
-- Si "conversion" est spécifié, on stocke l'info mais on ne l'inclut pas dans la chaîne
	for i = 1, 4 do
		if args[i] then
			if string.match (args[i], '[Cc]onversion') then
				if not string.match (args[i], 'jma') then
					if string.match (args[i], 'jm') then
						conv_jour_mois = true
					elseif string.match (args[i], 'j') then
						conv_jour = true
					elseif string.match (args[i], 'ma') then
						conv_mois_an = true
					elseif string.match (args[i], 'a') then
						conv_an = true
					end
				end
				if string.match (args[i], ':') then
					deux_points = true
				end
				if string.match (args[i], '%*') then
					test_conversion_sans_liens = true
				else
					test_conversion = true
				end
			else
				parametres = parametres..args[i]..' '
			end
		end
	end

	if parametres then
		tab = p.test_argument (parametres)
	else
		tab.test = false
		tab.message = Outils.erreur ("Aucun paramètre transmis")
	end

	if not tab.test	then
		tab.message = p.categorie_erreur (tab.message)
		return tab.message
	end
	
	if aucun_lien then
		tab.lien_jour, tab.lien_mois, tab.lien_an = false, false, false
	end

-- Mie en forme typographique et établissement des liens possibles sur une date du calendrier républicain
	local date_affichee = ''

-- Si on a le jour mais pas le mois, c'est un cas invalide
	if tab.test_quantieme and not(tab.test_mois) then
		tab.message = p.categorie_erreur (Outils.erreur ('date invalide, mois manquant'))
		return tab.message
 	else
-- on ne peut pas avoir en même temps un jour complémentaire et un numéro de jour ou un mois
		if (tab.test_quantieme or tab.test_mois) and tab.test_jour_complementaire then
			tab.test = false
			tab.message = p.categorie_erreur (Outils.erreur ('date invalide, paramètres incompatibles'))
		end
	end
	
-- Cas où l'année n'est pas spécifiée
	if not tab.test_an then
-- Cas où on a le jour et le mois
		if tab.test_quantieme and tab.test_mois then
			if tab.afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
				if not (tab.exposant_jour == '') then
					jour = tab.quantieme..tab.exposant_jour
					jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..tab.quantieme..'<sup>'..tab.exposant_jour..'</sup></abbr>'
				else
					jour = tab.quantieme
					jour_affiche = tab.quantieme
				end
				if tab.lien_jour then
					article = jour..' '..tab.mois
					if listeArticlesJours[article] then
-- Si l'index formé par le l'ensemble jour-mois existe dans la table, c'est qu'un article wikipédia existe => lien [[jour mois]
-- Sinon => lien sur le mois seulement (les articles sur les mois existent dans tous les cas)
						date_affichee = date_affichee..'[['..article..'|'..jour_affiche..']]'
					else
						date_affichee = date_affichee..jour_affiche
					end
				end
			end
			if tab.afficher_mois then
				if date_affichee == '' then
					tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
				end
				if tab.lien_mois then
					date_affichee = date_affichee..' [['..tab.mois..']]'
				else
					date_affichee = date_affichee..' '..tab.mois
				end
			end
		else
-- Cas où seul le nom précis d'un des jours complémentaires est présent, si demandé on affiche le lien (les articles sur ces jours existent dans tous les cas)
			if tab.test_jour_complementaire and tab.afficher_jour then
				if tab.lien_jour then
					date_affichee = '[['..tab.quantieme..']]'
				else
					date_affichee = tab.quantieme
				end
			else
-- Cas où seul le mois est présent, si demandé on affiche le lien (les articles sur les mois existent dans tous les cas)
				if tab.test_mois and tab.afficher_mois then
					tab.mois = string.sub(mois_saisi, 1, 1)..string.sub(tab_mois, 2)
					if tab.lien_mois then
						date_affichee = '[['..tab.mois..']]'
					else
						date_affichee = tab.mois
					end
				end
			end
		end
	else
-- Cas où l'année est renseignée

-- Cas des dates sous la forme jour_complémentaire année
-- Traitement du jour
		if tab.test_jour_complementaire and tab.afficher_jour then
			if tab.lien_jour then
-- On vérifie dans la table s'il existe un article dont le lien est de la forme [[jour complémentaire an XX]]
-- Si ce n'est pas le cas, on affiche un lien sur le jour seul
				article = tab.quantieme..' an '..tab.an
				if listeArticlesMois[article] then
					date_affichee = '[['..article..'|'..tab.quantieme..']]'
				else
					date_affichee = '[['..tab.quantieme..']]'
				end
			else
-- Pas de lien demandé
 				date_affichee = date_affichee..tab.quantieme
			end
			if tab.afficher_an then
-- Traitement de l'année
				tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an)
				date_affichee = date_affichee..' '..chaine
			end
		end

-- Cas des dates sous la forme jour mois année
-- Traitement du jour
		if tab.test_quantieme and tab.test_mois	then
			if tab.afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
				if not (tab.exposant_jour == '') then
					jour = tab.quantieme..tab.exposant_jour
					jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..tab.quantieme..'<sup>'..tab.exposant_jour..'</sup></abbr>'
				else
					jour = tab.quantieme
					jour_affiche = tab.quantieme
				end
				article = jour..' '..tab.mois
-- Si l'index formé par l'ensemble jour-mois existe dans la table, c'est qu'un article wikipédia existe => lien [[jour mois|jour]]
-- Sinon => lien sur le mois seulement (les articles sur les mois existent dans tous les cas)
				if tab.lien_jour and listeArticlesJours[article] then
					date_affichee = '[['..article..'|'..jour_affiche..']]'
				else
					date_affichee = jour_affiche
				end
			end
			if tab.afficher_mois then
				if tab.lien_mois then
					if date_affichee == '' then
						tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
					end
					article = tab.mois..' an '..tab.an
					if listeArticlesMois[article] then
						date_affichee = date_affichee..' [['..article..'|'..tab.mois..']]'
					else
						date_affichee = date_affichee..' [['..tab.mois..']]'
					end
				else
					date_affichee = date_affichee..' '..tab.mois
				end
			end
					
			if tab.afficher_an then
				if date_affichee == '' then
					tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an, tab.libelle_an)
				else
					tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an, nil)
				end
				if not tab.test	then
					return chaine
				else
					date_affichee = date_affichee..' '..chaine
				end
			end
		end
	
-- On vérifie dans la table s'il existe un article dont le lien est de la forme [[mois an XX]]
-- Si ce n'est pas le cas, on affiche un lien sur le mois seul
		if tab.test_mois and not tab.test_quantieme and tab.afficher_mois then
			if date_affichee == '' then
				tab.mois = string.sub(tab.mois_saisi, 1, 1)..string.sub(tab.mois, 2)
			end
			article = tab.mois..' an '..tab.an
			if listeArticlesMois[article] then
				date_affichee = '[['..article..'|'..tab.mois..']]'
			else
				date_affichee = '[['..tab.mois..']]'
			end
					
			if tab.afficher_an then
				tab.test, chaine = p.annee_affichee (tab.an, tab.lien_an)
				date_affichee = date_affichee..' '..chaine
			end
		end
-- Cas où on n'affiche que l'année
		if tab.afficher_an and (date_affichee == '') then
			tab.test, date_affichee = p.annee_affichee(tab.an, tab.lien_an, tab.libelle_an)
			if not tab.test then
				date_affichee = p.categorie_erreur (date_affichee)
				return date_affichee
			end
 	 	end
	end
	if date_affichee:match( ' ' ) then
		date_affichee = '<span class="nowrap">'..date_affichee..'</span>'
	end

-- Mise en forme de l'éventuelle date correspondante dans le calendrier grégorien
	if test_conversion or test_conversion_sans_liens then
		if ((tab.test_quantieme and tab.test_mois) or tab.test_jour_complementaire) and tab.test_an	then
			tab.test, tab.message, jour_Greg, mois_Greg, an_Greg = p.conversion_Gregorien(tab.quantieme, tab.mois, tab.an, tab.test_mois, tab.test_complementaire)
			if test	then
				if deux_points then
					date_affichee = date_affichee..' : '
				else
					date_affichee = date_affichee..' ('
				end
				if test_conversion_sans_liens then
					if conv_jour_mois then
						date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg..'-', nolinks="oui"})
					elseif conv_jour then
						date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg..'-', an_Greg..'-', nolinks="oui"})
					elseif conv_mois_an then
						date_affichee = date_affichee..modeleDate({nil, mois_Greg, an_Greg, nolinks="oui"})
					elseif conv_an then
						date_affichee = date_affichee..an_Greg
					else
	 					date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg, nolinks="oui"})
	 				end
	 			else
					if conv_jour_mois then
						date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg..'-'})
					elseif conv_jour then
						date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg..'-', an_Greg..'-'})
					elseif conv_mois_an then
						date_affichee = date_affichee..modeleDate({nil, mois_Greg, an_Greg})
					elseif conv_an then
						date_affichee = date_affichee..'[['..an_Greg..']]'
					else
	 					date_affichee = date_affichee..modeleDate({jour_Greg, mois_Greg, an_Greg})
	 				end
	 			end
	 			if not deux_points then
					date_affichee = date_affichee..')'
				end
	 		else
	 			date_affichee = date_affichee..message
	 		end
	 	else
			date_affichee = Outils.erreur ('conversion impossible, date incomplète')
		end
	end
	
	if not test	then
		date_affichee = p.categorie_erreur (date_affichee)
	end
	
	return date_affichee
end

function p.categorie_erreur (message)
--	local namespaceCategorisation = { [0] = true, [4] = true, [10] = true, [14] = true, [100] = true }
	local namespaceCategorisation = { [4] = true }
	local cat = ''
	if namespaceCategorisation[ mw.title.getCurrentTitle().namespace ] then
		cat = '[[Catégorie:Page avec une erreur de paramètre du modèle Date républicaine]]'
	end
	return message .. cat
end

-- Fonction permettant la mie en forme typographique et l'établissement des liens possibles sur une date du calendrier républicain
-- en vigueur en France entre 1792 et 1806 ainsi qu'en 1871 pendant la commune
function p.date_republicaine (frame)
	local args = Outils.extractArgs(frame)
	local aucun_lien = false
	
	local chaine = p._date_republicaine (aucun_lien, args)

	return chaine
end

-- Fonction permettant la mie en forme typographique sur une date du calendrier républicain
-- en vigueur en France entre 1792 et 1806 ainsi qu'en 1871 pendant la commune
function p.date_republicaine_sans_liens (frame)
	local args = Outils.extractArgs(frame)
	local aucun_lien = true
	
	local chaine = p._date_republicaine (aucun_lien, args)

	return chaine
end

return p