internal compiler error 252
Christian Templier STNA 7SO p5747 K224
TEMPLIER_Christian@stna.dgac.fr
Fri Dec 18 02:25:00 GMT 1998
Reading specs from
/7sb/pub/egcs-1.1.1/lib/gcc-lib/sparc-sun-solaris2.5/egcs-2.91.60/specs
gcc version egcs-2.91.60 19981201 (egcs-1.1.1 release)
evenement.cc: In function `const class type_info & __tfUl()':
evenement.cc:990: Internal compiler error 252.
evenement.cc:990: Please submit a full bug report to `egcs-bugs@cygnus.com'.
_____________________evenement.ch
/******************************************************************************
** evenement.ch **
******************************************************************************
------------------------------------------------------------------------------
| identification : evenement.ch/1.0/e1/i79 |
| Date de l'extraction : 15Oct98 / 09:51:30 |
| Derniere mise a jour : 15Oct98 / 09:50:42 |
------------------------------------------------------------------------------
--------------------------------- HISTORIQUE ---------------------------------
---------------------------------------------------------------------------*/
#include "projet.ch"
#undef CLASS
#define CLASS ASN_TYPE(SYSTEME,Evenement)
#undef CLASS_NAME
#define CLASS_NAME "SYSTEME Evenement"
#undef DERIVED_CLASS
#define DERIVED_CLASS OBJECT_BASE
#ifndef EVENEMENT__CH
#define EVENEMENT__CH
#include "language_object.ch"
#include "thread_machine.ch"
#include "ressource.ch"
#undef CLASS
#define CLASS ASN_TYPE(SYSTEME,Evenement)
#undef CLASS_NAME
#define CLASS_NAME "SYSTEME Evenement"
#undef DERIVED_CLASS
#define DERIVED_CLASS OBJECT_BASE
#undef IS_BASIC_TYPE
/***********************************************************************/
/** **/
/** **/
/** CLASSE DEFINITION **/
/** **/
/** **/
/***********************************************************************/
class CLASS : virtual public DERIVED_CLASS
{
public :
/***********************************************************************/
/** **/
/** **/
/** cut & bind member functions **/
/** **/
/** **/
/***********************************************************************/
virtual BOOL Cut
() ;
virtual BOOL Bind ()
;
/***********************************************************************/
/** **/
/** **/
/** Types Management **/
/** **/
/** **/
/***********************************************************************/
typedef Stype_heure_t HEURE ;
typedef Stype_delai_t DELAI ;
typedef Stype_delai_unite_t DELAI_UNITE ;
typedef Stype_heure_t ECHEANCE ;
typedef Stype_ulong_t SECONDE ;
typedef Stype_ulong_t MILI_SECONDE ;
typedef Stype_ulong_t MICRO_SECONDE ;
typedef Stype_ulong_t NANO_SECONDE ;
typedef Stype_evt_id_t ID ;
typedef Stype_res_nb_user_t USER ;
typedef Stype_evt_attr_t ATTRIBUT ;
typedef enum _PREDICAT { wait_signal , send_signal } PREDICAT ;
typedef Stype_boolean_t EXCEPTION ;
typedef Stype_boolean_t IN_BROADCAST ;
typedef enum _STATUS { eX_OK
= 0 ,
eX_WAIT
= 1 ,
eX_INITIALISATION_IMPOSSIBLE
= 2 ,
eX_DEJA_INITIALISE
= 4 ,
eX_NON_INITIALISE
= 7 ,
eX_DESTRUCTION_IMPOSSIBLE
= 14 ,
eX_RESSOURCE_GLOBAL_NON_INITIALISE
= 49 ,
eX_NB_RENDEZ_VOUS_IMPOSSIBLE
= 50 ,
eX_RESSOURCE_RECEPTION_NON_INITIALISE = 51 ,
eX_RESSOURCE_THREAD_NON_INITIALISE
= 52 ,
eX_RESSOURCE_THREAD_ACK_NON_INITIALISE = 53 ,
eX_ERREUR_ACTIVATION_EVT
= 54 ,
eX_INITIALISATION_EVENEMENT_IMPOSSIBLE = 55 ,
eX_INITIALISATION_EVENEMENT_ACK_IMPOSSIBLE =56,
eX_DELAI_NON_CALCULER
= 57 ,
eX_UNITE_DELAI_INCONNUE
= 58 ,
eX_ERREUR_SYSTEME
= 59 ,
eX_NON_IMPLEMENTEE
= 60 ,
eX_PARAMETRE_INVALIDE
= 61
} STATUS ;
typedef enum _attendre_exception
{ dELAI=0 ,
aUTRES=1 } ATTENDRE_EXCEPTION ;
/***********************************************************************/
/** **/
/** **/
/** Object Management **/
/** **/
/** **/
/***********************************************************************/
friend ostream & operator << (ostream & s , const CLASS & value) ;
virtual ostream & PrintOn(ostream & s) ;
virtual STATUS getStatus() const ;
virtual Stype_boolean_t isInit() const ;
virtual STATUS exception_rdv() ;
virtual STATUS desabonner_rdv() ;
virtual STATUS abonner_rdv() ;
virtual USER user_Number() const ;
virtual STATUS attendre() ;
virtual STATUS attendre(DELAI & delai , DELAI_UNITE unite ,
ATTENDRE_EXCEPTION type_exception = aUTRES ) ;
virtual STATUS reserver (RESSOURCE::AGAIN
isAgain=RESSOURCE::storeAgain) ;
virtual STATUS liberer () ;
/***********************************************************************/
/** **/
/** **/
/** constructor function **/
/** **/
/** **/
/***********************************************************************/
virtual void AsnFree () ;
virtual ~CLASS() ;
inline operator CLASS *() {return(this);} ;
inline operator CLASS &() {return(*this);} ;
#define EVENEMENT_DEFAULT_TASKING 2
#define EVENEMENT_MODE (EVENEMENT_DEFAULT_TASKING -1)
CLASS(USER nb_task_in_rdv=EVENEMENT_DEFAULT_TASKING,
OBJECT_BASE::IN_HEAP isHeap=OBJECT_BASE::inHeap) ;
CLASS(CLASS & ref ,
OBJECT_BASE::IN_HEAP isHeap=OBJECT_BASE::inHeap) ;
#include "new_delete.ch"
private :
virtual STATUS initialiser () ;
virtual STATUS detruire () ;
virtual STATUS demarrer_broadcast () ;
virtual STATUS debut_rdv (ATTENDRE_EXCEPTION type_exception= aUTRES) ;
virtual STATUS ack_broadcast () ;
virtual int activer (ID &evt,PREDICAT &predicat) ;
virtual int ack_reception(ID &evt, RESSOURCE & res,PREDICAT
&predicat) ;
/***********************************************************************/
/** **/
/** **/
/** Delai Management **/
/** **/
/** **/
/***********************************************************************/
virtual STATUS heure_lire (
HEURE &heure);
virtual STATUS ajout_delai (
ECHEANCE *heure_ref,
DELAI delai,
DELAI_UNITE unite,
ECHEANCE *heure) ;
private :
static SECONDE SECONDE_NULL ;
static MILI_SECONDE MILI_SECONDE_NULL ;
static MICRO_SECONDE MICRO_SECONDE_NULL ;
static NANO_SECONDE NANO_SECONDE_NULL ;
public :
virtual STATUS calculer_delai (
DELAI & delai,
DELAI_UNITE & unite,
SECONDE &sec=SECONDE_NULL,
MILI_SECONDE &msec=MILI_SECONDE_NULL,
MICRO_SECONDE &usec=MICRO_SECONDE_NULL,
NANO_SECONDE &nsec=NANO_SECONDE_NULL) ;
/***********************************************************************/
/** **/
/** **/
/** Types Management **/
/** **/
/** **/
/***********************************************************************/
typedef enum _BOOL_EVENT { TRUE_EVENT , FALSE_EVENT } BOOL_EVENT ;
ID _evt;
BOOL_EVENT _evt_init;
BOOL_EVENT _evt_ack_init;
ID _evt_ack;
RESSOURCE _res_thread;
RESSOURCE _res_thread_ack;
RESSOURCE _res_reception;
USER _signal_envoye;
USER _signal_demande;
Stype_boolean_t _init;
STATUS _status;
USER _nb_task_in_rdv;
EXCEPTION _exception ;
IN_BROADCAST _in_broadcast;
PREDICAT wait_evt ;
PREDICAT wait_broadcast;
static RESSOURCE _res_global;
protected :
#include "new_del_decl.ch"
/***********************************************************************/
/** **/
/** **/
/** debug management **/
/** **/
/** **/
/***********************************************************************/
#include "trace.ch"
#include "debug.ch"
} ; /* end of classe definition */
#endif
#undef CLASS
#define CLASS ASN_TYPE(SYSTEME,Evenement)
#undef CLASS_NAME
#define CLASS_NAME "SYSTEME Evenement"
#undef DERIVED_CLASS
#define DERIVED_CLASS OBJECT_BASE
--------------------evenement.cc
/******************************************************************************
** evenement.cc **
******************************************************************************
------------------------------------------------------------------------------
| identification : evenement.cc/1.0/e1/i185 |
| Date de l'extraction : 11Dec98 / 11:16:21 |
| Derniere mise a jour : 11Dec98 / 11:15:54 |
------------------------------------------------------------------------------
--------------------------------- HISTORIQUE ---------------------------------
---------------------------------------------------------------------------*/
/*****************************************************************************/
/******************************************************************************
----------------------------- FONCTION xxxxxxxx ------------------------------
OBJET :
APPEL :
-------------------------------- PARAMETRES ---------------------------------
en entree :
en sortie :
en mise a jour :
------------------------- TYPE ET VALEUR DE RETOUR --------------------------
void
------------------------ DONNEES COMMUNES UTILISEES -------------------------
en lecture :
en ecriture :
en mise a jour :
--------------------------- COMMENTAIRES ANNEXES ----------------------------
-----------------------------------------------------------------------------
******************************************************************************/
#include "evenement.ch"
/***********************************************************************/
/** **/
/** **/
/** debug management **/
/** **/
/** **/
/***********************************************************************/
#include "trace.cc"
#include "debug.cc"
/***********************************************************************/
/** **/
/** **/
/** constructor function **/
/** **/
/** **/
/***********************************************************************/
#include "new_delete.cc"
CLASS::CLASS(USER nb_task_in_rdv,OBJECT_BASE::IN_HEAP isHeap) :
_exception(EX_NON) ,
_nb_task_in_rdv(nb_task_in_rdv-1) ,
wait_evt(wait_signal) , wait_broadcast(wait_signal) ,
_res_reception() , _res_thread() , _res_thread_ack() ,
_evt_init(FALSE_EVENT) , _evt_ack_init(FALSE_EVENT) ,
_signal_envoye(0) , _signal_demande(0),
_status(eX_NB_RENDEZ_VOUS_IMPOSSIBLE) ,
_init(EX_NON) , _in_broadcast(EX_NON) ,
OBJECT_BASE_CONSTRUCTOR(isHeap)
{_status=initialiser() ;
} ;
CLASS::CLASS(CLASS & ref ,OBJECT_BASE::IN_HEAP isHeap) :
_exception(EX_NON) ,
_nb_task_in_rdv(ref.user_Number()) ,
wait_evt(wait_signal) , wait_broadcast(wait_signal) ,
_res_reception() , _res_thread() ,
_res_thread_ack() , _evt_init(FALSE_EVENT) ,
_evt_ack_init(FALSE_EVENT) ,
_signal_envoye(0) , _signal_demande(0),
_status(eX_NB_RENDEZ_VOUS_IMPOSSIBLE) ,
_init(EX_NON) , _in_broadcast(EX_NON) ,
OBJECT_BASE_CONSTRUCTOR(isHeap)
{_status=initialiser() ;
} ;
CLASS::~CLASS()
{
#ifdef DEBUG_DESTRUCTOR
COUT << "CALL FOR DESTRUCTOR IN => " << GetTypeName() << endl ;
#endif
DESTRUCTOR_BODY() ;
} ;
/***********************************************************************/
/** **/
/** **/
/** default operator functions **/
/** **/
/** **/
/***********************************************************************/
CLASS::USER
CLASS::user_Number() const
{return(_nb_task_in_rdv) ;
} ;
Stype_boolean_t
CLASS::isInit() const
{return(_init);
};
ostream &
operator << (ostream & s , const CLASS & value)
{switch (value._status)
{
case CLASS::eX_OK :
{s << " _status=eX_OK " ;
break ;
}
case CLASS::eX_INITIALISATION_IMPOSSIBLE :
{s << " _status=eX_INITIALISATION_IMPOSSIBLE " ;
break ;
}
case CLASS::eX_DEJA_INITIALISE :
{s << " _status=eX_DEJA_INITIALISE " ;
break ;
}
case CLASS::eX_NON_INITIALISE :
{s << " _status=eX_NON_INITIALISE " ;
break ;
}
case CLASS::eX_DESTRUCTION_IMPOSSIBLE :
{s << " _status=eX_DESTRUCTION_IMPOSSIBLE " ;
break ;
}
case CLASS::eX_RESSOURCE_GLOBAL_NON_INITIALISE :
{s << " _status=eX_RESSOURCE_GLOBAL_NON_INITIALISE " ;
break ;
}
case CLASS::eX_NB_RENDEZ_VOUS_IMPOSSIBLE :
{s << " _status=eX_NB_RENDEZ_VOUS_IMPOSSIBLE " ;
break ;
}
case CLASS::eX_RESSOURCE_RECEPTION_NON_INITIALISE :
{s << "RESSOURCE RECEPTION -> " << value._res_reception ;
break ;
}
case CLASS::eX_RESSOURCE_THREAD_NON_INITIALISE :
{s << "RESSOURCE THREAD -> " << value._res_thread ;
break ;
}
case CLASS::eX_RESSOURCE_THREAD_ACK_NON_INITIALISE :
{s << "RESSOURCE THREAD ACK -> " << value._res_thread_ack ;
break ;
}
case CLASS::eX_ERREUR_ACTIVATION_EVT :
{s << " _status=eX_ERREUR_ACTIVATION_EVT " ;
break ;
}
case CLASS::eX_INITIALISATION_EVENEMENT_IMPOSSIBLE :
{s << " _status=eX_INITIALISATION_EVENEMENT_IMPOSSIBLE " ;
break ;
}
case CLASS::eX_INITIALISATION_EVENEMENT_ACK_IMPOSSIBLE :
{s << " _status=eX_INITIALISATION_EVENEMENT_ACK_IMPOSSIBLE " ;
break ;
}
default :
{s << "status non defini : " << value._status ;
break;
}
}
return(s);
} ;
ostream &
CLASS::PrintOn(ostream & s)
{DERIVED_CLASS::PrintOn(s);
s << *this ;
return(s);
} ;
CLASS::STATUS
CLASS::getStatus() const
{return(_status) ;
} ;
/***********************************************************************/
/** **/
/** **/
/** cut & bind member functions **/
/** **/
/** **/
/***********************************************************************/
BOOL
CLASS::Cut()
{BOOL result=FAIL;
RESSOURCE::STATUS cr=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again ;
try
{cr=CLASS::_res_global.reserver(again) ;
switch (GetBackCount())
{case 0:
case 1 :
{if (cr==RESSOURCE::eX_OK) CLASS::_res_global.liberer ()
;
try
{result=this->ASN_BASE_CLASS::Cut();
}
catch (...)
{;
}
break;
}
default :
{result=this->ASN_BASE_CLASS::Cut();
if (cr==RESSOURCE::eX_OK) CLASS::_res_global.liberer ()
;
break;
}
}
}
catch (...)
{if (cr==RESSOURCE::eX_OK) CLASS::_res_global.liberer () ;
throw ;
}
return(result) ;
} ;
BOOL
CLASS::Bind()
{BOOL result=FAIL;
RESSOURCE::STATUS cr=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again ;
try
{cr=CLASS::_res_global.reserver(again) ;
if (isInit()==EX_OUI) result=this->ASN_BASE_CLASS::Bind();
}
catch (...)
{if (cr==RESSOURCE::eX_OK) CLASS::_res_global.liberer () ;
throw ;
}
if (cr==RESSOURCE::eX_OK) CLASS::_res_global.liberer () ;
return(result) ;
} ;
void
CLASS::AsnFree()
{
/*
** wait end of evt using by calling thread
*/
try
{CLASS::STATUS status =CLASS::eX_OK;
status=reserver();
if (status==CLASS::eX_OK) status=liberer() ;
}
catch (...)
{;
}
/*
** function call by Cut and protected by global ressource
*/
_status=this->detruire();
this->DERIVED_CLASS::AsnFree();
} ;
/***********************************************************************/
/** **/
/** **/
/** Object Management **/
/** **/
/** **/
/***********************************************************************/
CLASS::STATUS
CLASS::initialiser ()
{ int cr=0;
unsigned long e_id;
/* CONTROLE DE L'INITIALISATION */
if (_init == EX_OUI)
return(CLASS::eX_DEJA_INITIALISE);
if (CLASS::_res_global.isInit()!=EX_OUI)
{_status=eX_RESSOURCE_GLOBAL_NON_INITIALISE;
return(_status) ;
}
if (_res_reception.isInit()!=EX_OUI)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE;
return(_status) ;
}
if (_res_thread.isInit()!=EX_OUI)
{_status=eX_RESSOURCE_THREAD_NON_INITIALISE;
return(_status) ;
}
if (_res_thread_ack.isInit()!=EX_OUI)
{_status=eX_RESSOURCE_THREAD_ACK_NON_INITIALISE;
return(_status) ;
}
/* CONTROLE DE L'INITIALISATION */
cr = Pthread_cond_init(&_evt,Pthread_condattr_default);
if (cr != 0)
{_status= eX_INITIALISATION_EVENEMENT_IMPOSSIBLE ;
return(_status) ;
}
_evt_init=TRUE_EVENT;
cr = Pthread_cond_init(&_evt_ack,Pthread_condattr_default);
if (cr != 0)
{_status= eX_INITIALISATION_EVENEMENT_ACK_IMPOSSIBLE ;
return(_status) ;
}
_evt_ack_init=TRUE_EVENT;
_init=EX_OUI;
_status= CLASS::eX_OK ;
return(_status);
} ;
/**********************************************************************/
/* FONCTION : heure_lire */
/**********************************************************************/
CLASS::STATUS
CLASS::heure_lire (
CLASS::HEURE &heure)
{
int cr;
cr = lire_heure ((&heure));
if (cr != 0)
return(eX_ERREUR_SYSTEME);
return(eX_OK);
}
/**********************************************************************/
/* FONCTION : calculer_delai */
/**********************************************************************/
CLASS::STATUS
CLASS::calculer_delai (
CLASS::DELAI & delai,
CLASS::DELAI_UNITE & unite,
CLASS::SECONDE &sec,
CLASS::MILI_SECONDE &msec,
CLASS::MICRO_SECONDE &usec,
CLASS::NANO_SECONDE &nsec)
{
switch (unite) {
case EX_DELAI_SEC :
sec = delai;
msec = 0L;
usec = 0L;
nsec = 0L;
break;
case EX_DELAI_MSEC :
sec = delai / 1000L;
msec = (delai % 1000L);
usec = 0L;
nsec = 0L;
break;
case EX_DELAI_USEC :
sec = delai / 1000L;
msec = 0L;
usec = (delai % 1000L) * 1000L;
nsec = 0L;
if (usec > 1000000L) {
(sec)++;
(usec) -= 1000000L;
}
break;
case EX_DELAI_NSEC :
sec = delai / 1000L;
msec = 0L;
usec = 0L;
nsec = (delai % 1000L) * 1000000L;
if (nsec > 1000000000L) {
(sec)++;
(nsec) -= 1000000000L;
}
break;
default :
return(eX_UNITE_DELAI_INCONNUE);
}
return(eX_OK);
} ;
/**********************************************************************/
/* FONCTION : ajout_delai */
/**********************************************************************/
CLASS::STATUS
CLASS::ajout_delai (
CLASS::ECHEANCE *heure_ref,
CLASS::DELAI delai,
CLASS::DELAI_UNITE unite,
CLASS::ECHEANCE *heure)
{
CLASS::STATUS cr;
CLASS::SECONDE sec;
CLASS::MILI_SECONDE msec;
CLASS::MICRO_SECONDE usec;
CLASS::NANO_SECONDE nsec;
CLASS::ECHEANCE *tmp_heure;
/* CALCUL DU DELAI SUIVANT L'UNITE */
cr = calculer_delai (delai,unite,sec,msec,usec,nsec);
if (cr != eX_OK)
return(cr);
if (heure_ref == NULL_PTR)
{CLASS::STATUS cr=heure_lire(*heure);
if (cr != (int) eX_OK)
return(cr);
tmp_heure = heure;
}
else {
tmp_heure = heure_ref;
}
heure_ajout_delai (tmp_heure,sec,msec,usec,nsec,heure);
return(eX_OK);
} ;
/**********************************************************************/
/* FONCTION : desabonner_rdv */
/**********************************************************************/
CLASS::STATUS
CLASS::desabonner_rdv()
{
int cr=0;
/* CONTROLE DE L'INITIALISATION DES ATTRIBUTS */
if (_init == EX_NON)
{return(CLASS::eX_NON_INITIALISE) ;
}
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{if ((cr_ressource=_res_reception.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE ;
return (_status) ;
}
if (_nb_task_in_rdv>0)
{_nb_task_in_rdv-- ;
}
else
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
_status=eX_NB_RENDEZ_VOUS_IMPOSSIBLE;
return (_status) ;
}
if (_signal_demande<_nb_task_in_rdv)
{_res_reception.liberer() ;
}
else
{_status=demarrer_broadcast();
if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
}
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
throw ;
}
}
_status= CLASS::eX_OK ;
return (_status);
} ;
/**********************************************************************/
/* FONCTION : abonner_rdv */
/**********************************************************************/
CLASS::STATUS
CLASS::abonner_rdv()
{
int cr=0;
/* CONTROLE DE L'INITIALISATION DES ATTRIBUTS */
if (_init == EX_NON)
{return (CLASS::eX_NON_INITIALISE) ;
}
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{if ((cr_ressource=_res_reception.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE ;
return (_status) ;
}
_nb_task_in_rdv++ ;
_res_reception.liberer() ;
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
throw ;
}
}
_status= CLASS::eX_OK ;
return (_status);
} ;
/**********************************************************************/
/* FONCTION : ack_reception & exception_rdv */
/**********************************************************************/
int
CLASS::activer(CLASS::ID &evt,PREDICAT &predicat)
{predicat=send_signal;
return(Pthread_cond_broadcast (&evt));
} ;
int
CLASS::ack_reception(CLASS::ID &evt, RESSOURCE & res,PREDICAT &predicat)
{int cr=EINTR;
while (predicat!=send_signal)
{cr = Pthread_cond_wait (&evt,res.get());
}
return(cr);
} ;
/**********************************************************************/
/* FONCTION : exception_rdv */
/* */
/* si le rendez vous est en cours d initialisation de deblocage */
/* l'exeption n'est pas prise en compte , le traitement de la fonction*/
/* se terminine par une exception sur la classe */
/**********************************************************************/
CLASS::STATUS
CLASS::exception_rdv()
{
int cr=0;
/* CONTROLE DE L'INITIALISATION DES ATTRIBUTS */
if (_init == EX_NON)
{return (CLASS::eX_NON_INITIALISE) ;
}
if (_in_broadcast==EX_OUI)
{throw this ;
}
/*
** emission evenement
*/
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{if ((cr_ressource=_res_reception.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE ;
return (_status) ;
}
_exception=EX_OUI;
if (_signal_demande!=NULL_DATA)
{try
{_status=demarrer_broadcast();
}
catch (EVENEMENT * evt)
{
}
catch (...)
{throw ;
}
}
if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
throw ;
}
}
return (CLASS::eX_OK) ;
} ;
/**********************************************************************/
/* FONCTION : demarrer_broadcast */
/**********************************************************************/
CLASS::STATUS
CLASS::demarrer_broadcast ()
{/*
** appel protege par la ressource res_reception
*/
int cr;
_signal_envoye++;
_in_broadcast=EX_OUI;
cr = activer(_evt,wait_evt);
if (cr != 0)
{_status=eX_ERREUR_ACTIVATION_EVT;
}
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{if
((cr_ressource=_res_thread_ack.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_THREAD_NON_INITIALISE ;
}
else
{
cr =
ack_reception(_evt_ack,_res_thread_ack,wait_broadcast) ;
wait_broadcast=wait_signal;
_res_thread_ack.liberer();
}
}
catch (...)
{if (_nb_task_in_rdv==(EVENEMENT_MODE))
{if (_signal_envoye>NULL_DATA)
_signal_envoye--;}
else
{_signal_envoye=NULL_DATA;}
if (cr_ressource==RESSOURCE::eX_OK)
_res_thread_ack.liberer();
_in_broadcast=EX_NON;
throw ;
}
}
if (_nb_task_in_rdv!=(EVENEMENT_MODE))
{if (_signal_envoye>NULL_DATA) _signal_envoye--;}
else
{_signal_envoye=NULL_DATA;}
_in_broadcast=EX_NON;
return (CLASS::eX_OK);
} ;
/**********************************************************************/
/* FONCTION : ack_broadcast */
/**********************************************************************/
CLASS::STATUS
CLASS::ack_broadcast ()
{/*
** appel protege par la ressource res_reception
*/
if ((_signal_demande==NULL_DATA) && (_in_broadcast==EX_OUI))
{CLASS::EXCEPTION lexception=_exception;
_exception=EX_NON;wait_evt=wait_signal;
activer(_evt_ack,wait_broadcast);
if (lexception==EX_OUI)
{throw this ;
}
}
else
{if (_exception==EX_OUI)
{throw this ;
}
}
return (eX_OK);
} ;
/**********************************************************************/
/* FONCTION : debut_rdv */
/**********************************************************************/
CLASS::STATUS
CLASS::reserver (RESSOURCE::AGAIN isAgain)
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
if (_status==CLASS::eX_OK)
try
{if ((cr_ressource=_res_reception.reserver(isAgain))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE ;
return (_status) ;
}
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
throw ;
}
return(_status);
} ;
CLASS::STATUS
CLASS::liberer ()
{RESSOURCE::STATUS status=_res_reception.liberer();
if (status!=RESSOURCE::eX_OK)
{return(CLASS::eX_RESSOURCE_RECEPTION_NON_INITIALISE) ;
}
return(CLASS::eX_OK);
} ;
CLASS::STATUS
CLASS::debut_rdv (ATTENDRE_EXCEPTION type_exception)
{CLASS::STATUS result=CLASS::eX_OK;
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
if (_status!=CLASS::eX_OK) return (_status) ;
try
{if ((cr_ressource=_res_reception.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_RECEPTION_NON_INITIALISE ;
return (_status) ;
}
if (_signal_demande!=NULL_DATA)
{/*
** phase de deblocage du rendez vous avec ack pour
** liberation de la ressource reception par la bonne tache
*/
if (_signal_demande==_nb_task_in_rdv)
{CLASS::STATUS status=CLASS::eX_OK;
/*
** le rendez vous est atteint reveiller les autres
taches et sortir
*/
int cr=0;
status=demarrer_broadcast () ;
status=_status;
if (cr_ressource==RESSOURCE::eX_OK)
_res_reception.liberer();
return (status) ;
}
else
{/*
** le rendez vous n'est pas atteint , attendre prise
rendez vous
*/
}
}
else
{if
((_signal_envoye>NULL_DATA)&&(_nb_task_in_rdv==(EVENEMENT_MODE)))
{/*
** mode evenement avec signal arrive
*/
if (type_exception!=CLASS::dELAI)
{_signal_envoye--;
_res_reception.liberer();
return (eX_OK) ;
}
else
{_signal_envoye=NULL_DATA;
}
}
}
/*
** phase de d attente du rendez vous
*/
if ((_exception==EX_OUI)&&(_signal_demande==NULL_DATA))
{_exception=EX_NON;
throw this ;
}
_signal_demande ++ ;
result=CLASS::eX_WAIT;
_res_reception.liberer();
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_reception.liberer();
throw ;
}
}
return (result) ;
} ;
/**********************************************************************/
/* FONCTION : attendre_ou_delai */
/**********************************************************************/
CLASS::STATUS
CLASS::attendre(CLASS::DELAI & delai , CLASS::DELAI_UNITE unite ,
CLASS::ATTENDRE_EXCEPTION type_exception)
{
int cr;
ECHEANCE echeance ;
/* CONTROLE DE L'INITIALISATION DES ATTRIBUTS */
if (_init == EX_NON)
return (eX_NON_INITIALISE) ;
/* AJOUT DU DELAI A L'HEURE COURANTE */
cr=ajout_delai ((ECHEANCE *)NULL,delai,unite,&echeance);
if (cr!=0)
{_status=eX_DELAI_NON_CALCULER ;
return (_status) ;
}
/*
** demande d attente
*/
{CLASS::STATUS status=debut_rdv(type_exception);
if (status==CLASS::eX_OK)
{return(status);
}
else
{if (status!=CLASS::eX_WAIT)
return (status);
}
}
/* ATTENTE DE L'EVENEMENT */
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{ECHEANCE date ;
if ((cr_ressource=_res_thread.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_THREAD_NON_INITIALISE ;
return (_status) ;
}
while (( (cr != ETIMEDOUT)
&& (cr != EINVAL)))
{Pthread_cond_timedwait
(&_evt,_res_thread.get(),(&echeance),&cr);
}
_res_thread.liberer();
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_thread.liberer();
throw ;
}
if (_signal_demande>NULL_DATA) _signal_demande -- ;
try
{ack_broadcast() ;
}
catch (CLASS * rdv)
{if ((type_exception==CLASS::dELAI)&&(cr==ETIMEDOUT))
{throw &delai ;
}
else
{throw ;
}
}
catch (...)
{throw ;
}
if (cr != 0)
{switch (cr)
{case ETIMEDOUT:
{
throw &delai ;
break;
}
case EINVAL:
{_status=eX_PARAMETRE_INVALIDE;
return (_status);
break;
}
default:
{_status=eX_NON_IMPLEMENTEE;
return (_status);
break;
}
}
}
}
return (_status);
} ;
/**********************************************************************/
/* FONCTION : attendre */
/**********************************************************************/
CLASS::STATUS
CLASS::attendre ()
{
int cr;
/* CONTROLE DE L'INITIALISATION DES ATTRIBUTS */
if (_init == EX_NON)
return (eX_NON_INITIALISE);
/*
** demande d attente
*/
{CLASS::STATUS status=debut_rdv();
if (status==CLASS::eX_OK)
{return(status);
}
else
{if (status!=CLASS::eX_WAIT)
return (status);
}
}
/* ATTENTE DE L'EVENEMENT */
{RESSOURCE::STATUS cr_ressource=RESSOURCE::eX_OK;
RESSOURCE::AGAIN again=EX_NON;
try
{if ((cr_ressource=_res_thread.reserver(again))!=RESSOURCE::eX_OK)
{_status=eX_RESSOURCE_THREAD_NON_INITIALISE ;
return (_status) ;
}
cr=ack_reception(_evt,_res_thread,wait_evt);
_res_thread.liberer();
}
catch (...)
{if (cr_ressource==RESSOURCE::eX_OK) _res_thread.liberer();
throw ;
}
if (_signal_demande>NULL_DATA) _signal_demande -- ;
ack_broadcast() ;
}
return (_status);
} ;
/**********************************************************************/
/* FONCTION : detruire */
/**********************************************************************/
CLASS::STATUS
CLASS::detruire ()
{
int cr=0;
if (_signal_demande > 0)
{/* free reference with missing call on liberer function */
}
/* DETRUIRE L EVENEMENT */
if (_evt_init==TRUE_EVENT)
{cr = Pthread_cond_destroy (&_evt);
if (cr != 0)
{_status=CLASS::eX_DESTRUCTION_IMPOSSIBLE;
}
}
if (_evt_ack_init==TRUE_EVENT)
{cr = Pthread_cond_destroy (&_evt_ack);
if (cr != 0)
{_status=CLASS::eX_DESTRUCTION_IMPOSSIBLE;
}
}
if (_init == EX_NON)
return (CLASS::eX_NON_INITIALISE);
return (_status);
} ;
More information about the Gcc-bugs
mailing list