/****************************************************************************/
/*                                                                          */
/*                      Chaine de CAO & VLSI   Alliance                     */
/*                                                                          */
/*    Produit : ring router                                                 */
/*    Fichier : routalim.c                                                  */
/*                                                                          */
/*    (c) copyright 1992 Laboratoire MASI equipe CAO & VLSI                 */
/*    Tous droits reserves                                                  */
/*    Support : e-mail cao-vlsi@masi.ibp.fr                                 */
/*                                                                          */
/*    Ecrit   par : Olivier Van Hautte                  le : 01/08/92       */
/*    Modifie par : Franck Wajsburt                     le :   /  /         */
/*                                                                          */
/****************************************************************************/

/*-----------------------------------------------------------------------------------*/

/* RING 21 juillet 92                 ROUTALIM.C                                     */

/* routage des alim : couronne + colonnes + deports eventuels                        */

#include <stdio.h>
#include "includes.h"
#include "struct.h"

/*-------------------------------------------------------------------------------------*/
/* Cette joyeuse procedure pose les couronnes d'alimentation superieures et inferieures 
   et retourne les numeros des pistes d'alim dans 2 tableaux coursup[] et courinf[]    */

void pose_couralim(coursup, piste_sup, piste_inf, lst_equipo, lecoeur, tab_plots, segx_occ, segy_occ, tabpiste)
char	*coursup;
long	piste_sup[NB_FACES];
long	piste_inf[NB_FACES];
LST_EQUIPO  lst_equipo;
COEUR       lecoeur;
BARRE_PLOTS tab_plots[NB_FACES];
LST_SEGMENT segx_occ[NB_FACES];
LST_SEGMENT segy_occ[NB_FACES];
long	tabpiste[NB_FACES];
{
	long	largvdd = 0 , largvss = 0 , wtheovdd, wtheovss, wreelvdd_ymetal, wreelvdd_xmetal, wreelvss_xmetal;
	long	wreelvss_ymetal, maxlarg_y, maxlarg_x;
	long	nbpistemoinsvdd_ymetal, nbpistemoinsvdd_xmetal;
	long	nbpistemoinsvss_ymetal, nbpistemoinsvss_xmetal;
	long	nbpistemoinsalim_sup, wreelalim_sup, nbpistemoinsalim_inf , wreelalim_inf, pistealim;
	long	largmetalpiste, pistefin, pistefinpardefaut;
	/* stocker la derniere piste libre pour chaque face */
	int	face;
	char	metalpiste;

	LST_SEGMENT * segpiste;
	LST_EQUIPO equipo_vdd, equipo_vss, eqalim_sup, eqalim_inf;
	chain_list     * ptvdd = NULL , *ptvss = NULL,  *ptcour;
	LST_PSEUDO_CON con;
	PT_COORDONNEES c1alim_sup, c2alim_sup, c1alim_inf, c2alim_inf;
	PT_COORDONNEES c1horalim_sup, c2horalim_sup, c1horalim_inf, c2horalim_inf;
	PT_COORDONNEES c1veralim_sup, c2veralim_sup, c1veralim_inf, c2veralim_inf;

	recherche_equipo_alim(&equipo_vdd, &equipo_vss, lst_equipo);

	largeur_vddvss(equipo_vdd, equipo_vss, &wtheovdd, &wtheovss);

	if (ymetal_width > ymetal_wvia) 
		maxlarg_y = ymetal_width;
	else 
		maxlarg_y = ymetal_wvia;

	if (xmetal_width > xmetal_wvia) 
		maxlarg_x = xmetal_width;
	else 
		maxlarg_x = xmetal_wvia;

	/* ON se debrouille pour tomber sur un nombre de pistes paire */

	wreelvdd_ymetal = ((wtheovdd + pitch) / (2 * pitch )) * (2 * pitch) + maxlarg_y;
	wreelvdd_xmetal = ((wtheovdd + pitch) / (2 * pitch )) * (2 * pitch) + maxlarg_x;

	wreelvss_ymetal = ((wtheovss + pitch) / (2 * pitch )) * (2 * pitch) + maxlarg_y;
	wreelvss_xmetal = ((wtheovss + pitch) / (2 * pitch )) * (2 * pitch) + maxlarg_x;

	if (mode_debug) 
		printf("VDD largeury %5ld largeurx %5ld\n", wreelvdd_ymetal, wreelvdd_xmetal);
	if (mode_debug) 
		printf("VSS largeury %5ld largeurx %5ld\n", wreelvss_ymetal, wreelvss_xmetal);

	if (mode_debug) 
		printf("VDDpitch largeury %5ld largeurx %5ld\n", wreelvdd_ymetal / pitch, wreelvdd_xmetal / pitch);
	if (mode_debug) 
		printf("VSSpitch largeury %5ld largeurx %5ld\n", wreelvss_ymetal / pitch, wreelvss_xmetal / pitch);

	if (mode_debug) 
		printf("COEUR width %ld height %ld\n", lecoeur.width, lecoeur.height);

	nbpistemoinsvdd_ymetal = ((wtheovdd + pitch) / (2 * pitch ));
	nbpistemoinsvdd_xmetal = ((wtheovdd + pitch) / (2 * pitch ));
	nbpistemoinsvss_ymetal = ((wtheovdd + pitch) / (2 * pitch ));
	nbpistemoinsvss_xmetal = ((wtheovdd + pitch) / (2 * pitch ));

	if (mode_debug) 
		printf("VDDretirepiste largeury %5ld largeurx %5ld\n", nbpistemoinsvdd_ymetal, nbpistemoinsvdd_xmetal);
	if (mode_debug) 
		printf("VSSretirepiste largeury %5ld largeurx %5ld\n", nbpistemoinsvss_ymetal, nbpistemoinsvss_xmetal);

	/*-------------------------- POSE DES COURONNES D'ALIM -------------------------------*/

	/* recherche de la derniere piste libre vers la barre de plot */

	alloue_coord(0L, 0, &c1horalim_sup); 
	alloue_coord(0L, 0, &c2horalim_sup);
	alloue_coord(0L, 0, &c1veralim_sup); 
	alloue_coord(0L, 0, &c2veralim_sup);
	alloue_coord(0L, 0, &c1horalim_inf); 
	alloue_coord(0L, 0, &c2horalim_inf);
	alloue_coord(0L, 0, &c1veralim_inf); 
	alloue_coord(0L, 0, &c2veralim_inf);

	/*    REPRESENTATION DES 2 COURONNES D ALIM SUPERIEURE ET INFERIEURE                      

 c1horalim_sup                    alim_sup                  c2horalim_sup
 c2veralim_sup +-------------------------------------------+c2veralim_sup
               |                                           |
               |                  alim_inf                 | 
               |c1horalim_inf +--------------+c2horalim_inf|
               |c2veralim_inf |              |c2horalim_inf|
               |              |              |             |
               |              |              |             |
               |              |              |             |
               |              |              |             |
               |              |              |             |
               |c1horalim_inf |              |c2horalim_inf|
               |c1veralim_sup +--------------+c1horalim_inf|
               |                                           |
               |                                           | 
 c1horalim_sup |                                           |c2horalim_sup
 c1veralim_sup +-------------------------------------------+c1veralim_sup

                                                                                  */

	for (face = 0 ; face < NB_FACES; face++) {
		if (0 != tab_plots[face].width) {
			pistefin = tab_plots[face].coord.piste - 2; /* On part de apres le deport */

			switch (face) {
			case NORD:
			case SUD :
				segpiste = segx_occ;
				c1horalim_sup->xabs = lecoeur.coord.xabs;
				c2horalim_sup->xabs = lecoeur.coord.xabs + lecoeur.width;
				metalpiste = xmetal;
				largmetalpiste = xmetal_width;
				break;

			case EST  :
			case OUEST:
				segpiste = segy_occ;
				c1horalim_sup->yabs = lecoeur.coord.yabs;
				c2horalim_sup->yabs = lecoeur.coord.yabs + lecoeur.height;
				metalpiste = ymetal;
				largmetalpiste = ymetal_width;
				break;
			}

			while ((0 != pistefin) && (!segment_libre(c1horalim_sup, c2horalim_sup, pistefin, pistefin, face,
			     SEG_PISTE, segpiste, metalpiste)))
				pistefin--;

			if (0 == pistefin) 
				ringerreur(ERR_NOPISTE, &face);
			tabpiste[face] = pistefinpardefaut = pistefin;
		}  else 
			tabpiste[face] = 0; /* pas de barre de plots, on ne sait pas */

	}

	for (face = 0; face < NB_FACES; face++) /* maintenant on sait, valeur par defaut  */
		if (0 == tabpiste[face]) 
			tabpiste[face] = pistefinpardefaut;

	/*----------------------- PLACEMENT DES COURONNES -------------------------------------*/

	for (face = 0 ; face < NB_FACES; face++) {
		switch (face) {
		case NORD:
		case SUD :
			segpiste = segx_occ;
			metalpiste = xmetal;
			largmetalpiste = xmetal_width;
			if (coursup == eq_vdd) {
				nbpistemoinsalim_sup = nbpistemoinsvdd_xmetal;
				wreelalim_sup = wreelvdd_xmetal;
				eqalim_sup    = equipo_vdd;
				nbpistemoinsalim_inf = nbpistemoinsvss_xmetal;
				wreelalim_inf = wreelvss_xmetal;
				eqalim_inf    = equipo_vss;
			} else
			 {
				nbpistemoinsalim_sup = nbpistemoinsvss_xmetal;
				wreelalim_sup = wreelvss_xmetal;
				eqalim_sup    = equipo_vss;
				nbpistemoinsalim_inf = nbpistemoinsvdd_xmetal;
				wreelalim_inf = wreelvdd_xmetal;
				eqalim_inf    = equipo_vdd;
			}
			c1veralim_sup->yabs = lecoeur.coord.yabs - ((tabpiste[SUD] - nbpistemoinsalim_sup) * pitch);  
			c1veralim_sup->xabs = 0;
			c2veralim_sup->yabs = lecoeur.coord.yabs + lecoeur.height + ((tabpiste[NORD] - nbpistemoinsalim_sup) *
			    pitch); 
			c2veralim_sup->xabs = 0;

			c1veralim_inf->yabs = c1veralim_sup->yabs + ((nbpistemoinsalim_sup + nbpistemoinsalim_inf + 2) *
			    pitch); 
			c1veralim_inf->xabs = 0;
			c2veralim_inf->yabs = c2veralim_sup->yabs - ((nbpistemoinsalim_sup + nbpistemoinsalim_inf + 2) *
			    pitch); 
			c2veralim_inf->xabs = 0;

			c1alim_sup = c1horalim_sup;
			c2alim_sup = c2horalim_sup;
			c1alim_inf = c1horalim_inf;
			c2alim_inf = c2horalim_inf;
			break;

		case EST  :
		case OUEST:
			segpiste = segy_occ;
			metalpiste = ymetal;
			largmetalpiste = ymetal_width;
			if (coursup == eq_vdd) {
				nbpistemoinsalim_sup = nbpistemoinsvdd_ymetal;
				wreelalim_sup = wreelvdd_ymetal;
				eqalim_sup    = equipo_vdd;
				nbpistemoinsalim_inf = nbpistemoinsvss_ymetal;
				wreelalim_inf = wreelvss_ymetal;
				eqalim_inf    = equipo_vss;
			} else
			 {
				nbpistemoinsalim_sup = nbpistemoinsvss_ymetal;
				wreelalim_sup = wreelvss_ymetal;
				eqalim_sup    = equipo_vss;
				nbpistemoinsalim_inf = nbpistemoinsvdd_ymetal;
				wreelalim_inf = wreelvdd_ymetal;
				eqalim_inf    = equipo_vdd;
			}
			c1horalim_sup->xabs = lecoeur.coord.xabs - ((tabpiste[OUEST] - nbpistemoinsalim_sup) * pitch); 
			c1horalim_sup->yabs = 0 ;
			c2horalim_sup->xabs = lecoeur.coord.xabs + lecoeur.width + ((tabpiste[EST] - nbpistemoinsalim_sup) *
			    pitch); 
			c2horalim_sup->yabs = 0;
			c1horalim_inf->xabs = c1horalim_sup->xabs + ((nbpistemoinsalim_sup + nbpistemoinsalim_inf + 2) *
			    pitch); 
			c1horalim_inf->yabs = 0;
			c2horalim_inf->xabs = c2horalim_sup->xabs - ((nbpistemoinsalim_sup + nbpistemoinsalim_inf + 2) *
			    pitch); 
			c2horalim_inf->yabs = 0;

			c1alim_sup = c1veralim_sup;
			c2alim_sup = c2veralim_sup;
			c1alim_inf = c1veralim_inf;
			c2alim_inf = c2veralim_inf;

			break;
		} /* fin du switch */

		pistefin  = tabpiste[face]; /* derniere piste libre */
		piste_sup[face] = pistealim = pistefin - nbpistemoinsalim_sup ;

		/*----------------------------- ALIM COURONNE SUPERIEURE ------------------------------*/
		/* faux segment */

		for (; pistefin > pistealim; pistefin--)
			alloue_etchaine_segment(c1alim_sup, c2alim_sup, pistefin, pistefin, face, SEG_PISTE, segpiste, largmetalpiste,
			     metalpiste, FAUX_SEG, AVEC_VIA, eqalim_sup);

		/* vrai segment */

		alloue_etchaine_segment(c1alim_sup, c2alim_sup, pistealim, pistealim, face, SEG_PISTE, segpiste, wreelalim_sup,
		     metalpiste, VRAI_SEG, AVEC_VIA, eqalim_sup);

		/* faux segment */

		for (pistefin = pistealim - 1; pistefin >= pistealim - nbpistemoinsalim_sup; pistefin--)
			alloue_etchaine_segment(c1alim_sup, c2alim_sup, pistefin, pistefin, face, SEG_PISTE, segpiste, largmetalpiste,
			     metalpiste, FAUX_SEG, AVEC_VIA, eqalim_sup);

		/*----------------------------- ALIM COURONNE INFERIEURE ------------------------------*/

		pistefin --;
		piste_inf[face] = 	pistealim = pistefin - nbpistemoinsalim_inf;

		/* faux segments */

		for (; pistefin > pistealim; pistefin--)
			alloue_etchaine_segment(c1alim_inf, c2alim_inf, pistefin, pistefin, face, SEG_PISTE, segpiste, largmetalpiste,
			     metalpiste, FAUX_SEG, AVEC_VIA, eqalim_inf);

		/* vrai segment */

		alloue_etchaine_segment(c1alim_inf, c2alim_inf, pistealim, pistealim, face, SEG_PISTE, segpiste, wreelalim_inf,
		     metalpiste, VRAI_SEG, AVEC_VIA, eqalim_inf);

		/* faux segments */

		for (pistefin = pistealim - 1; pistefin > pistealim - nbpistemoinsalim_inf - 1; pistefin--)
			alloue_etchaine_segment(c1alim_inf, c2alim_inf, pistefin, pistefin, face, SEG_PISTE, segpiste, largmetalpiste,
			     metalpiste, FAUX_SEG, AVEC_VIA, eqalim_inf);
	} /* fin du for */

}

/*-------------------------------------------------------------------------------------*/

void tire_etdeport_alim(coursup, piste_sup, piste_inf, lst_equipo, tab_plots, segx_occ, segy_occ, tabpiste)
char	*coursup;
long	piste_sup[NB_FACES];
long	piste_inf[NB_FACES];
LST_EQUIPO  lst_equipo;
BARRE_PLOTS tab_plots[NB_FACES];
LST_SEGMENT segx_occ[NB_FACES];
LST_SEGMENT segy_occ[NB_FACES];
long	tabpiste[NB_FACES];
{
	LST_EQUIPO equipo_vdd, equipo_vss;

	recherche_equipo_alim(&equipo_vdd, &equipo_vss, lst_equipo);
	tire_etdeport_unealim(coursup, eq_vdd, piste_sup, piste_inf, equipo_vdd, tab_plots, segx_occ, segy_occ, tabpiste);
	tire_etdeport_unealim(coursup, eq_vss, piste_sup, piste_inf, equipo_vss, tab_plots, segx_occ, segy_occ, tabpiste);

}

/*--------------------------------------------------------------------------------------*/

/* cette procedure tire les fils d'une alim sur la couronne precedemment posees et traite
   les deports eventuels                                                                */
/* On peut se servir de tabpiste pour poser des faux segments, au cas ou on 
   tire une alim ds le mauvais layer, ceci pour eviter des croisements  
   (courts-circuits) avec les deports eventuels de plots */

void tire_etdeport_unealim(coursup, eq_alim, piste_sup, piste_inf, equipo, tab_plots, segx_occ, segy_occ, tabpiste)
char	*coursup;
char	*eq_alim;
long	piste_sup[NB_FACES];
long	piste_inf[NB_FACES];
LST_EQUIPO  equipo;
BARRE_PLOTS tab_plots[NB_FACES];
LST_SEGMENT segx_occ[NB_FACES];
LST_SEGMENT segy_occ[NB_FACES];
long	tabpiste[NB_FACES];
{
	LST_EQUIPO     eqalim_sup, eqalim_inf;
	chain_list     * ptcour;
	LST_PSEUDO_CON con;
	LST_EQUIPO     eq;
	PT_COORDONNEES c1, c2;
	long	p1, p2, *tabpistealim, pistealim, largmetalpiste, nbpistemoinsfil, pistefin;
	long	largmetalcol, piste, largeur;
	char	niveaucol, niveaupiste;
	LST_SEGMENT    * segcol;
	LST_SEGMENT    * segpiste;
	int	visavis;

	/* traitement de une alim  */

	if (mode_debug) 
		printf("Traitement segment alim %s\n", eq_alim);

	ptcour = equipo->lst_con;

	if (coursup == eq_alim) 
		tabpistealim = piste_sup;
	else 
		tabpistealim = piste_inf;

	while (ptcour != NULL) {
		con = (LST_PSEUDO_CON) ptcour->DATA;
		switch (con->face) {
		case NORD:
		case SUD :
			niveaucol = ymetal;
			niveaupiste = xmetal;
			segcol = segy_occ;
			segpiste = segx_occ;
			largmetalpiste = xmetal_width;
			largmetalcol   = ymetal_width;
			break;

		case EST  :
		case OUEST:
			niveaucol = xmetal;
			niveaupiste = ymetal;
			segcol = segx_occ;
			segpiste = segy_occ;
			largmetalpiste = ymetal_width;
			largmetalcol   = xmetal_width;
			break;
		} /* FIN DU SWITCH */

		if ((con->coeur_plot == PLOT_CON) && (con->deport != NULL)) {
			if (con->nom_con != coursup) /* foutu, on est oblige de deporter arghh */ {
				/* deport layer uniquement */

				if (mode_debug) 
					printf("POSEDEPORTALIM %s\n", con->nom_con);

				c1 = c2 = con->coord; /* segment col */
				p1 = con->deport->piste; /* piste calculee precedemment */
				p2 = tab_plots[con->face].coord.piste;

				/* ici ce n'est pas la peine de poser des faux segments, car ils
      ont deja ete poses dans deport_alim() */
				if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->layer))
					alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->largeur,
					     con->layer, VRAI_SEG, AVEC_VIA, equipo) ;
				else 
					ringerreur(ERR_SEGDEPORT, (void * )con);

				/* reste du fil jusqu'a la couronne */

				p2 = p1;
				p1 = tabpistealim[con->face];

				if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, niveaucol))
					alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->largeur,
					     niveaucol, VRAI_SEG, AVEC_VIA, equipo);
				else 
					ringerreur(ERR_SEGDEPORT, (void * )con);
			} /* fin trt deport  layer  plot */  else /* on tire le fil d'alim ds le mauvais layer */ 			 {
				c1 = c2 = con->coord;
				p1 = tabpistealim[con->face];
				p2 = tab_plots[con->face].coord.piste;

				/* reste du fil jusqu'a la couronne */

				/* ALLOCATION DE FAUX SEGMENTS CAR MAUVAIS LAYER TIRE */
				for (piste = tab_plots[con->face].coord.piste; piste > (tabpiste[con->face] + 1); piste--)
					if (segment_libre(c1, c2, piste, piste, con->face, SEG_PISTE, segpiste, niveaupiste))
						alloue_etchaine_segment(c1, c2, piste, piste, con->face, SEG_PISTE, segpiste,
						     largmetalpiste, niveaupiste, FAUX_SEG, AVEC_VIA, equipo);
					else 
						ringerreur(ERR_TIREALIM, con);

				if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->layer))
					alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->largeur,
					     con->layer, VRAI_SEG, AVEC_VIA, equipo);
				else 
					ringerreur(ERR_SEGDEPORT, (void * )con);
			} /* fin du else */
		} /* fin trt deport plot */ else
		 {
			if ((COEUR_CON == con->coeur_plot) && (con->deport != NULL)) /* deport coeur */ {
				if (mode_debug) 
					printf("deport coeur %s xdep %ld ydep %ld piste %ld face %d width %ld\n", con->nom_con,
					     con->deport->xabs, con->deport->yabs, con->deport->piste, (int)con->face, con->largeur);
				if (con->layer != niveaucol)  /* deport layer */ {
					if (mode_debug) 
						printf("SEGPOSEDEPORTALIM %s\n", con->nom_con);

					c1 = c2 = con->coord; /* segment col */
					p1 = 0; 
					p2 = con->deport->piste;

					if ((con->face == NORD) || (con->face == SUD)) {
						if ((con->deport)->xabs == (con->coord)->xabs)
							p2 = con->deport->piste; /* piste calculee precedemment */
						else 
							p2 = (con->largeur + pitch) / pitch;
					} else
					 {
						if ((con->deport)->yabs == (con->coord)->yabs)
							p2 = con->deport->piste; /* piste calculee precedemment */
						else 
							p2 = (con->largeur + pitch) / pitch;
					}

					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->layer))
						alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->largeur,
						     con->layer, VRAI_SEG, AVEC_VIA, equipo);
					else 
						ringerreur(ERR_SEGDEPORT, (void * )con);

					if (mode_debug) 
						printf("seg colonne mauvais layer tire \n");

					/* Allocation de faux segments */
					if (con->largeur > largmetalcol) {
						for (piste = 1; piste <= (p2 + (con->largeur / 2 + pitch) / pitch); piste++)
							alloue_etchaine_segment(c1, c2, piste, piste, con->face, SEG_PISTE,
							     segpiste, largmetalpiste, niveaupiste, FAUX_SEG, AVEC_VIA, equipo);
					}

				} /* fin trt changement layer */  else { 
					p1 = 0; 
					p2 = 0; 
					c1 = c2 = con->coord;	
				}

				/* pose du reste de fil sur la couronne d'alim */

				if (con->largeur < largmetalcol) 
					largeur =  largmetalcol;
				else 
					largeur = con->largeur;

				if ((con->face == NORD) || (con->face == SUD)) {
					if ((con->deport)->xabs == (con->coord)->xabs) /* fil direct sur couronne */ {
						p1 = p2;
						p2 = tabpistealim[con->face];
						visavis = 0;
					} else 
						visavis = 1; /* vis  a vis d'alim */

				} else				 {
					if ((con->deport)->yabs == (con->coord)->yabs) /* fil direct sur couronne */ {
						p1 = p2;
						p2 = tabpistealim[con->face];
						visavis = 0;
					}  else 
						visavis = 1; /* vis  a vis d'alim */

				}

				if (!visavis)  /* pas d'autre deport */ {
					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, niveaucol)) {
						if (!croisementok_alimequi(con, equipo->lst_con, AVEC_TESTLAYER))
							alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol,
							     largeur, niveaucol, VRAI_SEG, AVEC_VIA, equipo);
						else
							alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol,
							     largeur, niveaucol, VRAI_SEG, SANS_VIA, equipo);
						if (mode_debug) 
							printf("seg colonne layer tire sans vis a vis \n");
					}  else 
						ringerreur(ERR_SEGDEPORT, (void * )con);
				}  else /* Pas de chance , il faut traiter vis a vis d'alim */				 {
					if (mode_debug) 
						printf("vis a vis d'alim a traiter\n");
					pistefin = piste_inf[con->face];
					c1 = con->coord; 
					c2 = con->deport;

					while ((0 != pistefin) && (!segment_libre(c1, c2, pistefin, pistefin, con->face,
					    SEG_PISTE, segpiste, niveaupiste)))
						pistefin--;

					if (0 == pistefin) 
						ringerreur(ERR_NOPISTE, &(con->face));

					nbpistemoinsfil = ((con->largeur + pitch) / (2 * pitch ));
					pistealim = pistefin - nbpistemoinsfil;

					c2 = con->coord; 
					p1 = p2; 
					p2 = pistealim; /* colonne tiree */
					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, niveaucol))
						alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, largeur,
						     niveaucol, VRAI_SEG, AVEC_VIA, equipo);
					else 
						ringerreur(ERR_SEGDEPORT, (void * )con);

					c2 = con->deport;

					/* deport piste */
					/* faux segment */

					for (; pistefin > pistealim; pistefin--)
						alloue_etchaine_segment(c1, c2, pistefin, pistefin, con->face, SEG_PISTE,
						     segpiste, largmetalpiste, niveaupiste, FAUX_SEG, AVEC_VIA, equipo);

					/* vrai segment */

					alloue_etchaine_segment(c1, c2, pistealim, pistealim, con->face, SEG_PISTE, segpiste,
					     largeur, niveaupiste, VRAI_SEG, AVEC_VIA, equipo);

					/* faux segment */

					for (pistefin = pistealim - 1; pistefin >= (pistealim - nbpistemoinsfil); pistefin--)
						alloue_etchaine_segment(c1, c2, pistefin, pistefin, con->face, SEG_PISTE,
						     segpiste, largmetalpiste, niveaupiste, FAUX_SEG, AVEC_VIA, equipo);

					/* dernier col tiree */
					c1 = c2 = con->deport; 
					p1 = pistealim; 
					p2 = tabpistealim[con->face];
					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, niveaucol))
						alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, largeur,
						     niveaucol, VRAI_SEG, AVEC_VIA, equipo);
					else 
						ringerreur(ERR_SEGDEPORT, (void * )con);
				} /* fin trt vis a vis */
			} /* fin trt du fil deporte du coeur */   else /* trt du fil d'alim sans aucun deport */			 {

				/* reste du fil jusqu'a la couronne */

				c1 = c2 = con->coord;

				if (con->coeur_plot == PLOT_CON) {
					p2 = tab_plots[con->face].coord.piste; 
					p1 = tabpistealim[con->face];
				}  else {
					p1 = 0; 
					p2 = tabpistealim[con->face];
				}

				if (COEUR_CON == con->coeur_plot) {
					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->layer)) {
						if (!croisementok_alimequi(con, equipo->lst_con, AVEC_TESTLAYER))
							alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol,
							     con->largeur, con->layer, VRAI_SEG, AVEC_VIA, equipo);
						else
							alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol,
							     con->largeur, con->layer, VRAI_SEG, SANS_VIA, equipo);
					}  else 
						ringerreur(ERR_SEGDEPORT, (void * )con);
				} else
				 {
					if (segment_libre(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->layer))
						alloue_etchaine_segment(c1, c2, p1, p2, con->face, SEG_COL, segcol, con->largeur,
						     con->layer, VRAI_SEG, AVEC_VIA, equipo);

					else 
						ringerreur(ERR_SEGDEPORT, (void * )con);
				}

			} /* fin trt plot ou coeur alim sans deport */
		} /* fin du if coeur */

		ptcour = ptcour->NEXT;
	} /* fin du while */

}

