/*
================================================================================
  RPL/2 (R) version 4.1.33
  Copyright (C) 1989-2021 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 renvoyant la taille d'un objet en octets
  (pondérée par le nombre d'occurrences de cet objet)
================================================================================
  Entrée : pointeur sur l'objet
--------------------------------------------------------------------------------
  Sortie : taille
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

integer8
occupation_memoire(struct_objet *s_objet)
{
	integer8					i;
	integer8					longueur;

	struct_liste_chainee		*l_element_courant;

	if (s_objet == NULL)
	{
		return(0);
	}

	switch((*s_objet).type)
	{
		case ADR :
		{
			longueur = (integer8) sizeof(integer8);
			break;
		}

		case ALG :
		{
			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			longueur = 0;

			while(l_element_courant != NULL)
			{
				longueur += occupation_memoire((*l_element_courant).donnee);
				l_element_courant = (*l_element_courant).suivant;
			}

			break;
		}

		case BIN :
		{
			longueur = (integer8) sizeof(logical8);
			break;
		}

		case CHN :
		{
			longueur = (integer8) (strlen((unsigned char *) (*s_objet).objet)) *
					(integer8) sizeof(unsigned char);
			break;
		}

		case CPL :
		{
			longueur = (integer8) sizeof(complex16);
			break;
		}

		case FCH :
		{
			longueur = sizeof(struct_fonction);
			longueur += (integer8) (strlen((*((struct_fichier *)
				 	(*s_objet).objet)).nom)) * (integer8) sizeof(unsigned char);
			longueur += occupation_memoire((*((struct_fichier *) 
					(*s_objet).objet)).format);
			break;
		}

		case FCT :
		{
			longueur = sizeof(struct_fonction);
			longueur += ((integer8) (strlen((*((struct_fonction *)
					(*s_objet).objet)).nom_fonction)) *
					(integer8) sizeof(unsigned char));
			break;
		}

		case INT :
		{
			longueur = (integer8) sizeof(integer8);
			break;
		}

		case LST :
		{
			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			longueur = 0;

			while(l_element_courant != NULL)
			{
				longueur += occupation_memoire((*l_element_courant).donnee);
				l_element_courant = (*l_element_courant).suivant;
			}

			break;
		}

		case MCX :
		{
			longueur = (integer8) sizeof(struct_matrice);
			longueur += (*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
					(*((struct_matrice *) (*s_objet).objet)).nombre_colonnes *
					(integer8) sizeof(complex16);
			break;
		}

		case MIN :
		{
			longueur = (integer8) sizeof(struct_matrice);
			longueur += (*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
					(*((struct_matrice *) (*s_objet).objet)).nombre_colonnes *
					(integer8) sizeof(integer8);
			break;
		}

		case MRL :
		{
			longueur = (integer8) sizeof(struct_matrice);
			longueur += (*((struct_matrice *) (*s_objet).objet)).nombre_lignes *
					(*((struct_matrice *) (*s_objet).objet)).nombre_colonnes *
					(integer8) sizeof(real8);
			break;
		}

		case MTX :
		{
			longueur = sizeof(struct_mutex);
			break;
		}

		case NOM :
		{
			longueur = ((integer8) strlen((*((struct_nom *) (*s_objet).objet))
					.nom)) * (integer8) sizeof(unsigned char);
			break;
		}

		case NON :
		{
			longueur = 0;
			break;
		}

		case PRC :
		{
			longueur = sizeof(struct_processus_fils);
			break;
		}

		case REL :
		{
			longueur = sizeof(real8);
			break;
		}

		case RPN :
		{
			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			longueur = 0;

			while(l_element_courant != NULL)
			{
				longueur += occupation_memoire((*l_element_courant).donnee);
				l_element_courant = (*l_element_courant).suivant;
			}

			break;
		}

		case SCK :
		{
			longueur = ((integer8) strlen((*((struct_socket *)
					(*s_objet).objet)).adresse)) *
					(integer8) sizeof(unsigned char);
			longueur += ((integer8) strlen((*((struct_socket *)
					(*s_objet).objet)).adresse_distante)) *
					(integer8) sizeof(unsigned char);
			longueur += occupation_memoire((*((struct_fichier *) 
					(*s_objet).objet)).format);
			break;
		}

		case SLB :
		{
			longueur = (integer8) sizeof(struct_bibliotheque);
			longueur += ((integer8) strlen((*((struct_bibliotheque *)
					(*s_objet).objet)).nom)) * (integer8) sizeof(unsigned char);
			break;
		}

		case SPH :
		{
			longueur = (integer8) sizeof(struct_semaphore);
			longueur += ((integer8) strlen((*((struct_semaphore *)
					(*s_objet).objet)).nom)) * (integer8) sizeof(unsigned char);
			break;
		}

		case SQL :
		{
			longueur = (integer8) sizeof(struct_connecteur_sql);
			longueur += ((integer8) strlen((*((struct_connecteur_sql *)
					(*s_objet).objet)).type)) *
					(integer8) sizeof(unsigned char);
			longueur += (integer8) (strlen((*((struct_connecteur_sql *)
					(*s_objet).objet)).locale)) *
					((integer8) sizeof(unsigned char));
			break;
		}

		case TBL :
		{
			longueur = (integer8) sizeof(struct_tableau);

			for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
					.nombre_elements; i++)
			{
				longueur += occupation_memoire((*((struct_tableau *)
						(*s_objet).objet)).elements[i]);
			}

			break;
		}

		case VCX :
		{
			longueur = (integer8) sizeof(struct_vecteur);
			longueur += (*((struct_vecteur *) (*s_objet).objet))
					.taille * (integer8) sizeof(complex16);
			break;
		}

		case VIN :
		{
			longueur = (integer8) sizeof(struct_vecteur);
			longueur += (*((struct_vecteur *) (*s_objet).objet))
					.taille * (integer8) sizeof(integer8);
			break;
		}

		case VRL :
		{
			longueur = (integer8) sizeof(struct_vecteur);
			longueur += (*((struct_vecteur *) (*s_objet).objet))
					.taille * (integer8) sizeof(real8);
			break;
		}

		default :
		{
			longueur = 0;
			break;
		}
	}

	return(longueur / (*s_objet).nombre_occurrences);
}

// vim: ts=4