//**********************************************************************
//**********************************************************************
//	Projet      : Ulysse
//	Laboratoire : GREYC-ISMRA
//	Fichier     : action.cc
//      Annee       : 1997          ,
//	Auteur      : Christophe GODEREAUX
//**********************************************************************
//**********************************************************************

#ifndef ACTIONNNN
#define ACTIONNNN

#include <unistd.h> //pour rename
#include "util.cc" 
#include "assoc.cc" 


#define NB_MAX_PROPOSITION 10  // nombre max de proposition: t_tab_prop
#define NB_MAX_GN 5	      // nombre max de groupes nominaux: t_tab_gn
#define NB_MAX_ADV 4	      // nombre max d'adverbes.
#define NB_MAX_ADJ 3	      // nombre max d'adjectifs.

#define NB_CAR_TEXTE_PROP 150 // nombre de car max pour une proposition
#define NB_CAR_TEXTE_GN 150   // nombre de car max pour un groupe nominal
#define NB_CAR_VINF 80	      // nombre de caractere pour le sens de vinf
#define NB_CAR 30	      // nombre de caractere pour le sens + ...
#define NB_CAR2 15	      // nombre de caractere pour le type + ...
#define NB_CAR3 10

#define VIDE "NULL"	      // valeur par defaut de toute chaine de car.

int existe(char* val)  	   // tres util pour tester la valeur d'un char*
{
//deb("Existence de ");debn(val);
  return val!=NULL && strcmp(val,VIDE) && strcmp(val,"UNDEFINED");
}


//**********************************************************************
//				RESUME 
//**********************************************************************

/*
- La classe (t_tab_prop) represente la suite de propositions présentes dans la phrase. C'est un tableau de (t_prop).
- La structure (t_prop) represente une seule propositon. Elle contient principalement un noyau verbal (de type t_gv) et des sequence nominales (de type t_tab_gn).
- La structure (t_gv) represente un noyau verbal. Elle contient au maximum : des donnees relatives (t_verbe), un pronom cod et un pronom coi(t_pron), des adjectifs de fonction attribut du sujet (un tableau de t_adj), des adverbes (un tableau de t_adv)
- La classe (t_tab_gn) represente une suite de groupes nominaux. C'est un tableau de (t_gn).
- La structure (t_gn) represente un groupe nominal simple. Elle contient principalement au maximum : un nom (t_nom), un determinant (t_det), une preposition (t_prep), des adjectifs (un tableau de t_adj), des adverbes (un tableau de t_adv)

- Il y a donc 5 structures representant les categories syntagmatiques :
	- t_tab_prop	- t_prop
				- t_gv
				- t_tab_gn	- t_gn
et 7 structures representant les categories lexicales :
	- t_nom	 - t_det  - t_prep  -t_adj  - t_adv  - t_pron  - t_verbe

- Les donnees syntaxico-sematiques lexicale de lexlist sont stockees dans ces 7 categories lexicales. 
	-(LEX:) permet de comprendre comment cela se fait : il faut reagarder dans le fichier lexlist.
 	-(RUL:) il faut regarder dans rulelist.
*/

//**********************************************************************
//				ADVERBE 
//**********************************************************************
struct t_adv {
  	char 
	sens[NB_CAR],		// (LEX: ADV) sens
	type[NB_CAR2],		// (LEX: ADV) type 
	acte[NB_CAR];		// (LEX: ADV) acte
 	float quantite,compar;  // par calcul

        t_adv();
	int exister(){return existe(sens)||existe(type);}
};

t_adv::t_adv()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(acte,VIDE);
  quantite=compar=0;
}

ostream& operator<<(ostream& s,  t_adv adv)
{ 
   s<<"  Adv : sens="<<adv.sens  <<" type="<<adv.type;
   if (existe(adv.acte)) s <<" acte="<<adv.acte;
   if (adv.quantite!=0) s <<" quantite="<<adv.quantite;
   if (adv.compar!=0) s <<" compar="<<adv.compar;
   return s<<'\n';
}

//**********************************************************************
//				PREPOSITION 
//**********************************************************************
struct t_prep {
  	char 
	sens[NB_CAR],		// (LEX: PREP ou LOCPREP) sens
	type[NB_CAR2],		// (LEX: PREP ou LOCPREP) type
	avec_gv[NB_CAR2];	// (LEX: PREP ou LOCPREP) avec_gv
		// avec_gv contient la fonction de la proposition

        t_prep();
	int exister(){return existe(sens);}
};

t_prep::t_prep()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(avec_gv,VIDE);
}

ostream& operator<<(ostream& s,  t_prep prep)
{ 
   return s<<"  Prep : sens="<<prep.sens  <<" type="<<prep.type<<'\n';
}

//**********************************************************************
//				PRONOMS 
//**********************************************************************
struct t_pron {
  	char 
	sens[NB_CAR2],		// (LEX: PRO...) MOT
	type[NB_CAR2],		// (LEX: PRO...) CAT = categorie lexical
	genre[NB_CAR3],		// (LEX: PRO) genre
	nombre[NB_CAR3],	// (LEX: PRO) nombre
	fonction[NB_CAR2];	// inutilise pour l'instant

        t_pron();
	int exister(){return existe(sens);}
};

t_pron::t_pron()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(genre,VIDE);
  strcpy(nombre,VIDE);
  strcpy(fonction,VIDE);
}

ostream& operator<<(ostream& s,  t_pron pron)
{ 
  s<<"  Pron : sens="<<pron.sens<<" type="<<pron.type;
  if (existe(pron.fonction)) s<<" fonction="<<pron.fonction<<'\n';
  else s<<'\n';
  return s;
}


//**********************************************************************
//				ADJECTIF
//**********************************************************************

struct t_adj {
  	char 
	sens[NB_CAR],		// (LEX: ADJ) MOT
	type[NB_CAR2],		// (LEX: ADJ) type 
	genre[NB_CAR3],		// (LEX: ADJ) genre
	nombre[NB_CAR3],	// (LEX: ADJ) nombre
	quantite[NB_CAR2];	// inutilise pour l'instant

        t_adj();
	int exister(){return existe(sens);}
};

t_adj::t_adj()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(quantite,VIDE);
  strcpy(genre,VIDE);
  strcpy(nombre,VIDE);
}

ostream& operator<<(ostream& s,  t_adj adj)
{ 
   s<<"  Adj : sens="<<adj.sens  <<" type="<<adj.type;
   if (existe(adj.genre))s<<" genre="<<adj.genre;
   if (existe(adj.nombre))s<<" nombre="<<adj.nombre;
   if (existe(adj.quantite)) s <<" quantite="<<adj.quantite;
   return s<<'\n';
}

//**********************************************************************
//				DETERMINANT
//**********************************************************************

struct t_det {
  	char 
	sens[NB_CAR],		//(RUL: R_DET) mot
	type[NB_CAR2],		//(RUL: R_DET) type
	genre[NB_CAR3],		//(RUL: R_DET) genre
	nombre[NB_CAR3],	//(RUL: R_DET) nombre
	quantite[NB_CAR3];	//(RUL: R_DET) quantite

        t_det();
	int exister(){return existe(sens);}
};

t_det::t_det()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(genre,VIDE);
  strcpy(nombre,VIDE);
  strcpy(quantite,VIDE);
}

ostream& operator<<(ostream& s,  t_det det)
{ 
   s<<"  Det : sens="<<det.sens  <<" type="<<det.type;
   if (existe(det.genre))s<<" genre="<<det.genre;
   if (existe(det.nombre))s<<" nombre="<<det.nombre;
   if (existe(det.quantite)) s<<" quantite="<<det.quantite;
   return s<<'\n';
}

//**********************************************************************
//				NOM
//**********************************************************************
struct t_nom {
  	char 
	sens[NB_CAR],		//(RUL: R_NOM) n ou calcul si 2 noms
	type[NB_CAR],		//(RUL: R_NOM) type ou calcul si 2 noms
	genre[NB_CAR3],		//(RUL: R_NOM) genre ou calcul si 2 noms
	nombre[NB_CAR3];	//(RUL: R_NOM) nombre ou calcul si 2 noms
	char * texte;

        t_nom();
	int exister(){return existe(sens);}

};

t_nom::t_nom()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(genre,VIDE);
  strcpy(nombre,VIDE);
}

ostream& operator<<(ostream& s,  t_nom nom)
{ 
   s<<"  Nom : sens="<<nom.sens  <<" type="<<nom.type;
   if (existe(nom.genre))s<<" genre="<<nom.genre;
   if (existe(nom.nombre))s<<" nombre="<<nom.nombre;
   return s<<'\n';
}

//**********************************************************************
//			     MOT INTERROGATIF
//**********************************************************************
struct t_interro {		// pas encore utilise
  	char 
	sens[NB_CAR],
	type[NB_CAR],
	genre[NB_CAR3],
	nombre[NB_CAR3];	

        t_interro();
	int exister(){return existe(sens);}
};

t_interro::t_interro()
{
  strcpy(sens,VIDE);
  strcpy(type,VIDE);
  strcpy(genre,VIDE);
  strcpy(nombre,VIDE);
}

ostream& operator<<(ostream& s,  t_interro in)
{ 
   s<<"*Mot interrogatif : sens="<<in.sens  <<" type="<<in.type;
   if(existe(in.genre))s<<" genre="<<in.genre;
   if(existe(in.nombre))s<<" nombre="<<in.nombre;
   return s<<'\n';
}

//**********************************************************************
//				GROUPE NOMINAL
//**********************************************************************

struct t_gn {
	t_prep prep;			// une preposition si existe
	t_det det;			// un determinant si existe
	t_nom n;			// un nom
	t_adv adv[NB_MAX_ADV];		// un tableau d'adverbes
	int nb_adv;			// le nombre d'adverbes
	t_adj adj[NB_MAX_ADJ];		// un tableau d'adjectifs
	int nb_adj;			// le nombre d'adjectifs
	char fonction[NB_CAR2];		// la fonction du groupe nominal
	char coord[NB_CAR2];		// la coordination si existe
	char texte[NB_CAR_TEXTE_GN];	// le texte du groupe nominal

        t_gn();
        t_gn(t_pron,char*);
	void init();
	int exister();
};

t_gn::t_gn()
{  
  strcpy(fonction,VIDE);
  strcpy(coord,VIDE);
  strcpy(texte,VIDE);
  nb_adv=nb_adj=0;
}

t_gn::t_gn(t_pron p,char* fonc)
{  
  strcpy(coord,VIDE);
  strcpy(texte,VIDE);
  nb_adv=nb_adj=0;
  strcpy(fonction,fonc);
  strcpy(n.sens,p.sens);
  strcpy(n.nombre,p.nombre);
  strcpy(n.genre,p.genre);
  strcpy(n.type,p.type);
}

void t_gn::init()
{
  t_gn tmp;
  (*this)=tmp;
}

int t_gn::exister()
{
  return n.exister()||det.exister()||adj[1].exister()||existe(texte);
}

ostream& operator<<(ostream& s,  t_gn gn)
{  
   int i; 
   s<<" Groupe nominal : "/*<<gn.fonction*/<<"\n";
   if (existe(gn.coord)) s<<"  Relation gn="<<gn.coord<<"\n"; 
   if (gn.prep.exister()) s<<gn.prep; 
   if (gn.det.exister()) s<<gn.det; 
   if (gn.n.exister()) s<<gn.n; 
   for (i=0;i<gn.nb_adj;i++) s<<gn.adj[i];
   for (i=0;i<gn.nb_adv;i++) s<<gn.adv[i];
   if (existe(gn.texte)) s<<"  texte="<<gn.texte<<"\n"; 
   return s;
}

//**********************************************************************
//			TABLEAU DE GN
//**********************************************************************
class t_tab_gn {
	t_gn tab[NB_MAX_GN];		// tableau de groupes nominaux
public:
	int nbr ;			// le nombre de groupes nominaux
	char fonction[NB_CAR2];		// la fonction dans la proposition
	t_tab_gn(){nbr=0;}
	void init();
	t_gn& operator[](int i){return tab[i];};
	void ajouter(t_gn &gn);
	void ajouter(t_tab_gn &tab_tmp);
	int exister(){return nbr!=0;}
	void inserer(t_gn &gn);
        t_gn& gn_courant(){ return tab[nbr];}
        t_gn& gn_nouveau(){ return tab[nbr++];}
};

void t_tab_gn::init()
{
  t_gn p;
  for (int i=0;i<nbr;i++) tab[i]=p;
  nbr=0;
}

void t_tab_gn::ajouter(t_gn &gn)
{
  if (nbr!=NB_MAX_GN){
    tab[nbr++]=gn;
    //cout <<"ajout de gn :"<<nbr<<'\n';
  } 
  else {
    cerr<<"!!!!!!!!!!!  TROP de GN !!!!!!!!!!";
  }
}

void t_tab_gn::ajouter(t_tab_gn &tab_tmp)
{
  for (int i=0;i<tab_tmp.nbr;i++) ajouter(tab_tmp.tab[i]);
}

void t_tab_gn::inserer(t_gn &gn)
{
  if (nbr!=NB_MAX_GN){
    for (int i=nbr++;i>0;i--) tab[i]=tab[i-1];
    tab[0]=gn;
  } 
  else {
    cerr<<"!!!!!!!!!!!  TROP de GN !!!!!!!!!!";
  }
}

ostream& operator<<(ostream& s,  t_tab_gn &t)
{
  for (int i=0;i<t.nbr;i++) s<<t[i];
  return s;
}

//**********************************************************************
//				VERBE
//**********************************************************************
struct t_verbe {
	char vinf[NB_CAR], // le verbe infinitif Ex: MONTER
			   // (LEX: 
 	sens[NB_CAR_VINF], // le sens du verbe : Ex pour MONTER : ALLER
 	intr_tr_pron[NB_CAR3]; // intr(ansitif) tr(ansitif) ou pron(ominal)
	char type[NB_CAR]; // verbe de type : navigation, requete, ...
        assoc_chaine champs; 

        t_verbe();
	//void init(){t_verbe tmp;(*this)=tmp;}
	int exister(){return existe(vinf);}
};

t_verbe::t_verbe()
{  
  strcpy(vinf,VIDE);
  strcpy(sens,VIDE);
  strcpy(intr_tr_pron,VIDE);
  strcpy(type,VIDE);
}

ostream& operator<<(ostream& s,  t_verbe v)
{ 
   s<<"  Verbe : vinf="<<v.vinf <<' ';
   if (eg(v.intr_tr_pron,"intr")) s<<"intransitif";
   else if (eg(v.intr_tr_pron,"tr")) s<<"transitif";
   else if (eg(v.intr_tr_pron,"pron")) s<<"pronominal";
   s <<" ->  sens="<<v.sens<<'\n';
   if (existe(v.type)) s<<"  type="<<v.type<<'\n'; 
   s<<v.champs;
   return s;
}

//**********************************************************************
//				NOYAU VERBAL
//**********************************************************************
struct t_gv {
	char contenu[NB_CAR]; // v ou v,r_adv ou v,r_pronom ...
	t_verbe v;			// donnees sur le verbe
	t_pron pro_cod, pro_coi, pro;	// pronoms
	t_adv adv[NB_MAX_ADV];		// tableau d'adverbes
	int nb_adv;			// nombre d'adverbes
//	t_adv lieu_def;  		// lieu par defaut
	t_adj adj[NB_MAX_ADJ];		// les adjectifs attributs du sujet
	int nb_adj;			// nombre d'adjectifs
	char *texte;			// pas utilise

        t_gv();
	void init(){t_gv tmp;(*this)=tmp;}
	int exister(){return existe(v.sens);}
	int existe_adv(char*);
	int compose();
};

t_gv::t_gv()
{  
  strcpy(contenu,VIDE);
  nb_adv=0;
  nb_adj=0;
}

ostream& operator<<(ostream& s,  t_gv gv)
{ 
   s<<"*NOYAU VERBAL : "/*<<contenu="<<gv.contenu*/<<'\n'<<gv.v;
//   if (gv.pro_cod.exister()) s<<gv.pro_cod; 
   if (gv.pro_coi.exister()) s<<gv.pro_coi; 
   if (gv.pro.exister()) s<<gv.pro; 
   for (int i=0;i<gv.nb_adv;i++) s<<gv.adv[i]; 
//   if (gv.lieu_def.exister()) s<<"  lieu_def="<<gv.lieu_def; 
   if (gv.nb_adj){
     s<<"  Attribut du sujet :\n";
     for (int i=0;i<gv.nb_adj;i++) s<<"  "<<gv.adj[i];
   }
   return s;
}

int t_gv::existe_adv(char* fonction)
{
  for (int i=0;i<nb_adv;i++)
    if (eg(adv[i].type,fonction)) return TRUE;
  return FALSE;
}

int t_gv::compose()
{
  if (strchr(v.sens,'-')) return TRUE; else return FALSE;
}


//**********************************************************************
//**********************************************************************
//				PROPOSITION
//**********************************************************************
//**********************************************************************

struct t_prop {
        public :
	char categorie[30];	// proposition, groupe_nominal, adverbe, 
				// interjection, salutation
	char type[NB_CAR]; //ordre, gerondif, question, proposition, ...
	char contenu[NB_CAR];   // gv ou gv,r_gn ou gv,r_gprep ...
	char fonction[NB_CAR];  // pas  utilise 
	char relation[NB_CAR];  // ET, OU, PUIS... debutant la proposition
	t_prep prep_gv; 	// POUR, SANS, preposition la debutant  
	char conjsub[NB_CAR];   // QUE,PARCE_QUE...debutant la proposition 
	t_interro interro;	// mot interrogatif debutant la question
	t_gv gv;		// le noyau verbal
	t_tab_gn gn_sujet;	// le gn sujet
	t_tab_gn gn_comp;	// le gn complement
	//char texte[NB_CAR_TEXTE_PROP];

        t_prop();
        t_prop(char*,char*,char*);
	void init(){t_prop tmp; (*this)=tmp;}
	int exister(){return gv.exister();}
};

t_prop::t_prop()
{
//debn("initialisation proposition");
  strcpy(type,VIDE);
  strcpy(contenu,VIDE);
  strcpy(fonction,VIDE);
  strcpy(gn_sujet.fonction,"SUJET");
  strcpy(gn_comp.fonction,VIDE);
  strcpy(relation,VIDE);
  strcpy(conjsub,VIDE);
  strcpy(categorie,VIDE);
//  strcpy(texte,VIDE);
}

t_prop::t_prop(char*type0,char*fonction0,char*contenu0)
{
  strcpy(type,type0);
  strcpy(contenu,contenu0);
  strcpy(fonction,fonction0);
  strcpy(gn_sujet.fonction,"SUJET");
  strcpy(gn_comp.fonction,VIDE);
  strcpy(relation,VIDE);
  strcpy(categorie,"proposition");
//  strcpy(texte,VIDE);
}

ostream& operator<<(ostream& s,  t_prop p)
{ 

//  if (existe(p.texte)) s<<"Texte= "<<p.texte<<'\n';
  if (existe(p.contenu)) s<<" type="<<p.type;//<<" fonction="<<p.fonction;
//  if (existe(p.contenu)) s<<" contenu="<<p.contenu;
  s<<'\n';
  if (existe(p.relation)||p.prep_gv.exister()||existe(p.conjsub)) 
    s<<"*RELATION\n";
  if (existe(p.relation)) s<<"  Connecteur="<<p.relation<<'\n';
  if (p.prep_gv.exister()) s<<p.prep_gv;
  if (existe(p.conjsub)) s<<"  Conjonction="<<p.conjsub<<'\n';
  if (p.interro.exister()) s<<p.interro;
  if (p.gn_sujet.exister()) s<<"*SUJET"<<p.gn_sujet;
  if (p.gv.exister()) s<<p.gv;
  if(p.gn_comp.exister())s<<'*'<<p.gn_comp[0].fonction<<p.gn_comp;
  return s;
}

//**********************************************************************
//				TABLEAU DE PROPOSITIONS
//**********************************************************************


class t_tab_prop {
	t_prop tab[NB_MAX_PROPOSITION];		// tableau de propositions
public:
	char texte[NB_CAR_TEXTE_PROP];		// texte de la proposition
	int nbr ;				// nombre de propositions
	t_tab_prop(){nbr=0;  strcpy(texte,VIDE);}
	void init();
	t_prop& operator[](int i){return tab[i];};
	void transmettre(char*);
	int lire(char*);
	t_prop& derniere() 
          {if (nbr==0)return tab[nbr]; else return tab[nbr-1];}
	void ajouter(t_prop &prop);
	void ajouter(t_tab_prop &tab_tmp);
	void inserer_T_avant_i(t_tab_prop& ,int );
	void remplacer_Ti_par_P(int,  t_tab_prop &);
	void supprimer(int);
	void supprimer_derniere() {tab[--nbr].init();}
	int exister(){return nbr!=0;}
};

void t_tab_prop::init()
{
//  t_prop p;
//  for (int i=0;i<nbr;i++) tab[i]=p;
  nbr=0;
}


void t_tab_prop::transmettre(char * nom_fic)
{
//cout<<"transmettre:"<<nbr<<"\n";
  if (nbr>0){
//    cout<<" ] - [ Transmission: ";cout.flush();
    cout<<"##### Transmission : ";cout.flush();
    char nom_fic_tmp[100];
    sprintf(nom_fic_tmp,"%s.action",nom_fic);
    FILE *file = fopen(nom_fic_tmp,"wb");
    cout<<fwrite(&tab,sizeof(tab[0]),nbr,file)<<" proposition";
    if (nbr>1)cout<<"s.\n"; else cout<<".\n";
//    cout<<sizeof(tab[0])/1000*nbr<<" Ko\n";
    cout.flush();
    fwrite(texte,sizeof(texte),1,file);
    fclose(file); 
    rename(nom_fic_tmp,nom_fic);
    cout<<("");
  }
//  else cout<<" ] --\nPAS D'ACTION A TRANSMETTRE \n";
  else cout<<"##### Pas de proposition à transmettre.\n";
}


int t_tab_prop::lire(char * nom_fic)
{
  FILE *file;
  if (file=fopen(nom_fic,"rb")){
    //cout<<"RECEPTION\n";cout.flush();
    int i=0;int j=0;
    do{
      j=fread(&tab[i++],sizeof(tab[0]),1,file);
    } while (j==1);
    nbr=i-1;
    fread(texte,NB_CAR_TEXTE_PROP,1,file);
    fclose(file);
    //cout<<"RECEPTION OK"<<nbr<<"\n";cout.flush();
    return TRUE;
  }
  else return FALSE;
 }

void t_tab_prop::ajouter(t_prop &prop)
{
  if (nbr!=NB_MAX_PROPOSITION){
    tab[nbr++]=prop;
    //cout <<"ajout de proposition :"<<nbr<<'\n';
  } 
  else {
    cerr<<"!!!!!!!!!!!  TROP de propositions !!!!!!!!!!";
  }
}

void t_tab_prop::ajouter(t_tab_prop &tab_tmp)
{
  for (int i=0;i<tab_tmp.nbr;i++) ajouter(tab_tmp.tab[i]);
}

ostream& operator<<(ostream& s,  t_tab_prop &t)
{
  s<<"**************************************************************** \n";
  if (existe(t.texte)) s<<t.texte<<'\n';
  for (int i=0;i<t.nbr;i++){
    s<<"***************************************\n";
    s<<"************************* "<<t[i].categorie;
    s<<' '<<i+1<<" :"<<t[i];
  }
  s<<"**************************************************************** \n";
  return s;
}

void t_tab_prop::inserer_T_avant_i(t_tab_prop & tab_tmp,int i)
{
  int j;
  for (j=1;j<nbr-i+1;j++) {
//deb("decal:");debi(nbr-j);deb(" en ");debin(nbr-j+tab_tmp.nbr);
      tab[nbr-j+tab_tmp.nbr]=tab[nbr-j];
  }
  for (j=0;j<tab_tmp.nbr;j++){
//deb("copie:");debin(i+j);
    tab[i+j]=tab_tmp[j];
  }
  nbr+=tab_tmp.nbr;
}

/*void t_tab_prop::remplacer_Ti_par_P(int i, t_tab_prop & tab_tmp)
{
  int j;
  if (i<nbr && tab_tmp.nbr>1){
    for (j=1;j<nbr-i;j++) {
deb("decal:");debi(nbr+tab_tmp.nbr-1-j);deb(" ");debin(nbr+tab_tmp.nbr-2-j);
//      tab[nbr+tab_tmp.nbr-1-j]=tab[nbr+tab_tmp.nbr-2-j];
      tab[nbr+tab_tmp.nbr-1-j]=tab[nbr+tab_tmp.nbr-2-j];
    }
  }
  for (int j=0;j<tab_tmp.nbr;j++){
//deb("copie:");debin(i+j);
    tab[i+j]=tab_tmp[j];
  }
  nbr+=tab_tmp.nbr-1;
}
*/
void t_tab_prop::remplacer_Ti_par_P(int i, t_tab_prop & tab_tmp)
{
  int j;
  for (j=1;j<nbr-i;j++) {
//deb("decal:");debi(nbr-j);deb(" en ");debin(nbr-j+tab_tmp.nbr-1);
      tab[nbr-j+tab_tmp.nbr-1]=tab[nbr-j];
  }
  for (j=0;j<tab_tmp.nbr;j++){
//deb("copie:");debin(i+j);
    tab[i+j]=tab_tmp[j];
  }
  nbr+=tab_tmp.nbr-1;
}


void t_tab_prop::supprimer(int i)
{
  for (int j=i;j<nbr;j++){
    tab[j]=tab[j+1];
  }
  tab[--nbr].init();
}



#endif