/*
================================================================================
  RPL/2 (R) version 4.1.32
  Copyright (C) 1989-2020 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Fonction de calcul d'une date
================================================================================
  Entrées : pointeur sur un time_t
--------------------------------------------------------------------------------
  Sorties : pointeur sur un object
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

struct_objet *
formateur_date(struct_processus *s_etat_processus, struct timeval *horodatage)
{
	char					tableau[64 + 1];

	integer8				jour_julien;

	long					d;
	long					heures;
	long					m;
	long					minutes;
	long					secondes;
	long					y;

	real8					heure_julienne;
	real8					offset_julien;

	size_t					taille;

	struct_liste_chainee	*l_element_courant;

	struct_objet			*s_objet;

	struct tm				*stm;

	/*
	 * Récupération de la structure tm
	 */

	stm = localtime((const time_t *) &((*horodatage).tv_sec));

	if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	/*
	 * Jour de la semaine
	 */

	if ((l_element_courant = malloc(sizeof(struct_liste_chainee))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	(*s_objet).objet = l_element_courant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%A", stm);

	if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);

	/*
	 * Quantième du mois
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%d", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	d = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Mois
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%B", stm);

	if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);

	/*
	 * Année
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%Y", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	y = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Heure
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%H", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	heures = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Minutes
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%M", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	minutes = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Secondes
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%S", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	secondes = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Microsecondes
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	(*((integer8 *) (*(*l_element_courant).donnee).objet)) =
			(integer8) (*horodatage).tv_usec;

	/*
	 * Fuseau horaire
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%Z", stm);

	if (((*(*l_element_courant).donnee).objet = malloc((taille + 1) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tableau);

	/*
	 * Jour de la semaine en numérique
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%u", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);

	/*
	 * Numéro de la semaine
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%W", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);

	/*
	 * Numéro du mois
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%m", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);
	m = (long) (*((integer8 *) (*(*l_element_courant).donnee).objet));

	/*
	 * Numéro du jour dans l'année
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	taille = strftime(tableau, 64, "%j", stm);
	sscanf(tableau, "%lld", (integer8 *) (*(*l_element_courant).donnee).objet);

	/*
	 * Jours juliens (référence 0 le 24 novembre -4713 dans le calendrier
	 * grégorien proleptique). Le résultat est séparé en deux, tout
	 * d'abord la partie entière, puis la partie fractionnaire.
	 * Cette valeur apparaît dans la liste en deux parties, tout d'abord la
	 * partie entière, puis la partie fractionnaire.
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	if (m < 3)
	{
		y--;
		m += 12;
	}

	/*
	 * À noter : la date de base est toujours dans le calendrier
	 * grégorien à moins d'avoir un sérieux problème de date
	 * sur le calculateur.
	 */

	jour_julien = 1721024 + (365 * y) + (30 * m) + d + ((integer8) (y / 4))
			+ 2 + ((integer8) (y / 400)) - ((integer8) (y / 100));
	heure_julienne = floor(((real8) 0.6001) * ((real8) m + 1)) +
			(((real8) heures) / 24) + (((real8) minutes) / 1440) +
			(((real8) secondes + (((real8) (*horodatage).tv_usec) / 1000000)) /
			86400) + ((real8) 0.5);

	offset_julien = floor(heure_julienne);

	jour_julien += (integer8) offset_julien;
	heure_julienne -= offset_julien;

	(*((integer8 *) (*(*l_element_courant).donnee).objet)) = jour_julien;

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	(*((real8 *) (*(*l_element_courant).donnee).objet)) = heure_julienne;

	/*
	 * Temps Unix
	 */

	if (((*l_element_courant).suivant = malloc(sizeof(struct_liste_chainee)))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	l_element_courant = (*l_element_courant).suivant;

	if (((*l_element_courant).donnee = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return(NULL);
	}

	(*((integer8 *) (*(*l_element_courant).donnee).objet)) =
			(*horodatage).tv_sec;

	/*
	 * Fermeture de la liste
	 */

	(*l_element_courant).suivant = NULL;

	return(s_objet);
}

// vim: ts=4