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}} →
• {{#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}} →
• {{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien*}} →
• {{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien:}} →
• {{#invoke:Date républicaine|date_republicaine|1er vendémiaire an II|grégorien jm}} →

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 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 du génie",
    "jour du travail",
    "jour de l'opinion",
    "jour des récompenses",
    "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 chaine de caractère (jour, mois ou année), 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
 	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
		argument=string.sub(argument, 1, position - 1)..string.sub(argument, x)
	end
		
	return argument, 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 quantieme, exposant_jour, mois, an = '', '', '', ''
	local test_quantieme, test_mois, test_an, test_jour_complementaire = false, false, false, false
	local lien_jour, lien_mois, lien_an, afficher_jour, afficher_mois, afficher_an = true, true, true, true, true, true
	local position = 0
	local chaine = ''

-- On retire l'éventuel "er" de "1er" pour simplifier le traitement qui suit
    if argument:match (type_1er) then
		argument=argument:gsub('1er', '1')
		exposant_jour = 'er'
	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
		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, afficher_mois, lien_mois = p.extraction_argument (argument, listeNomsMois[i][1])
			mois = listeNomsMois[i][2]
			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, 6 do
		if string.find (argument, listeJoursComplementaires[i])	then
 			argument, afficher_jour, lien_jour = p.extraction_argument (argument, listeJoursComplementaires[i])
			test_jour_complementaire = true
			quantieme = listeJoursComplementaires[i]
			i = 6
		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
		test_quantieme = true
		quantieme = argument:match (type_nombre)
		if quantieme == '1'	then
			exposant_jour = 'er'
		end
		argument, afficher_jour, lien_jour = p.extraction_argument (argument, quantieme)
	end

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

		if test_an then
			if not listeRomains[an]	then
				test = false
				message = Outils.erreur ('année hors du calendrier républicain ('..an..')')
				return test, message
			end
		end
		argument=trim(argument)
		if argument	then
-- La chaîne n'est pas sous un format attendu, message d'erreur
 		 	test = false
 			message = Outils.erreur ('format de date incorrect ('..argument..')')
 		end
	end
	return test, message, quantieme, exposant_jour, test_quantieme, test_jour_complementaire, mois, test_mois, an, test_an, lien_jour, lien_mois, lien_an, afficher_jour, afficher_mois, afficher_an
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)
	local chaine = ''
	local annee_affichee = ''
	if annee then
-- Vérification de la syntaxe en chiffres romains
		if annee:match (type_romains) then
-- Récupération de la valeur affichée dans l'infobulle
			annee_affichee = 'an <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 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.mise_en_forme_date (quantieme, exposant_jour, test_quantieme, test_jour_complementaire, mois, test_mois,	an, test_an, lien_jour, lien_mois, lien_an, afficher_jour, afficher_mois, afficher_an)
	local date_affichee = ''
	local test=true
	local message = ''

-- Si on a le jour mais pas le mois, c'est un cas invalide
	if test_quantieme and not(test_mois) then
		message = Outils.erreur ('date invalide, mois manquant')
		return false, 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 (test_quantieme or test_mois) and test_jour_complementaire then
			test = false
			message = Outils.erreur ('date invalide, paramètres incompatibles')
			return test, message
		end
	end
	
-- Cas où l'année n'est pas spécifiée
	if not test_an then
-- Cas où on a le jour et le mois
		if test_quantieme and test_mois then
			if afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
				if not (exposant_jour == '') then
					jour = quantieme..exposant_jour
					jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..quantieme..'<sup>'..exposant_jour..'</sup></abbr>'
				else
					jour = quantieme
					jour_affiche = quantieme
				end
				if lien_jour then
					article = jour..' '..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..'[['..jour..' '..mois..'|'..jour_affiche..']]'
					else
						date_affichee = date_affichee..jour_affiche
					end
				end
			end
			if afficher_mois then
				if lien_mois then
					date_affichee = date_affichee..' [['..mois..']]'
				else
					date_affichee = date_affichee..' '..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 test_jour_complementaire and afficher_jour then
				if lien_jour then
					date_affichee = '[['..quantieme..']]'
				else
					date_affichee = 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 test_mois and afficher_mois then
					if lien_mois then
						date_affichee = '[['..mois..']]'
					else
						date_affichee = 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 test_jour_complementaire and afficher_jour then
			if 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 = string.lower(quantieme)..' an '..an
				if listeArticlesMois[article] then
					date_affichee = '[['..article..'|'..quantieme..']]'
				else
					date_affichee = '[['..quantieme..']]'
				end
			else
-- Pas de lien demandé
 				date_affichee = date_affichee..quantieme
			end
			if afficher_an then
-- Traitement de l'année
				test, chaine = p.annee_affichee (an, lien_an)
				date_affichee = date_affichee..' '..chaine
			end
		end

-- Cas des dates sous la forme jour mois année
-- Traitement du jour
		if test_quantieme and test_mois	then
			if afficher_jour then
-- Cas particulier pour la mise en forme de "1er", "2e", etc.
				if not (exposant_jour == '') then
					jour = quantieme..exposant_jour
					jour_affiche = '<abbr class="abbr" title="'..infobulle[jour]..'" >'..quantieme..'<sup>'..exposant_jour..'</sup></abbr>'
				else
					jour = quantieme
					jour_affiche = quantieme
				end
				article = jour..' '..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 lien_jour then
					if listeArticlesJours[article] then
						date_affichee = date_affichee..'[['..jour..' '..mois..'|'..jour_affiche..']]'
					else
						if test_quantieme then
						 	date_affichee = date_affichee..jour_affiche
						else
							date_affichee = date_affichee..'[['..quantieme..']]'
						end
					end
				else
					date_affichee = jour_affiche
				end
			end
			if afficher_mois then
				if lien_mois then
					article = string.lower(mois)..' an '..an
					if listeArticlesMois[article] then
						date_affichee = date_affichee..' [['..article..'|'..mois..']]'
					else
						date_affichee = date_affichee..' [['..mois..']]'
					end
				else
					date_affichee = date_affichee..' '..mois
				end
			end
					
			if afficher_an then
				test, chaine = p.annee_affichee (an, lien_an)
				if not test	then
					return test, 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 test_mois and not test_quantieme and afficher_mois then
			article = string.lower(mois)..' an '..an
			if listeArticlesMois[article] then
				date_affichee = '[['..article..'|'..mois..']]'
			else
				date_affichee = '[['..mois..']]'
			end
					
			if afficher_an then
				test, chaine = p.annee_affichee (an, lien_an)
				date_affichee = date_affichee..' '..chaine
			end
		end
-- Cas où on n'affiche que l'année
		if afficher_an and not chaine then
			test, date_affichee = p.annee_affichee(an, lien_an)
 	 	end
	end
	if date_affichee:match( ' ' ) then
		date_affichee = '<span class="nowrap">'..date_affichee..'</span>'
	end

	return test, date_affichee
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, 6 do
			if listeJoursComplementaires[i] == jour	then
				jour_Rep = i
				i = 6
			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

-- 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 (aucun_lien, args)
	local test_conversion, test_conversion_sans_lien = false, false
	local quantieme, mois, an = '', '', ''
	local test_quantieme, test_mois, test_an, test_jour_complementaire = false, false, false, false
	local lien_jour, lien_mois, lien_an = true, true, true

	local parametres = ''
-- 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
				test_conversion_sans_liens = true
			else
				if string.match (args[i], '[Cc]onversion') then
					test_conversion = true
				else
					parametres = parametres..args[i]..' '
				end
			end
		end
	end

	if parametres then
		test, message, quantieme, exposant_jour, test_quantieme, test_jour_complementaire, mois, test_mois,	an, test_an, lien_jour, lien_mois, lien_an, afficher_jour, afficher_mois, afficher_an = p.test_argument (parametres)
	else
		test = false
		message = Outils.erreur ("Aucun paramètre transmis")
	end

	if not test	then
		message = message..'[[Catégorie:Page avec une erreur de paramètre du modèle Date républicaine]]'
		return message
	end
	
	if aucun_lien then
		lien_jour, lien_mois, lien_an = false, false, false
	end
    test, chaine = p.mise_en_forme_date (quantieme, exposant_jour, test_quantieme, test_jour_complementaire, mois, test_mois, an, test_an, lien_jour, lien_mois, lien_an, afficher_jour, afficher_mois, afficher_an)

	if test and (test_conversion or test_conversion_sans_liens)	then
		if ((test_quantieme and test_mois) or test_jour_complementaire) and test_an	then
			test, message, jour_Greg, mois_Greg, an_Greg, n = p.conversion_Gregorien(quantieme, mois, an, test_mois, test_complementaire)
			if test	then
				if test_conversion_sans_liens then
	 				chaine = chaine..' ('..OutilsDates.modeleDate({jour_Greg, mois_Greg, an_Greg, nolinks="oui"})..')'
	 			else
	 				chaine = chaine..' ('..OutilsDates.modeleDate({jour_Greg, mois_Greg, an_Greg})..')'
	 			end
	 		else
	 			chaine = chaine..message
	 		end
	 	else
			message = Outils.erreur ('conversion impossible, date incomplète')
			chaine = chaine..message
		end
	end
	
	if not test	then
		chaine = chaine..'[[Catégorie:Page avec une erreur de paramètre du modèle Date républicaine]]'
	end
	
	return chaine
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