La Documentation de JFGG

Pgm Tableau

Programme pour mettre en tableau des données

Le source

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stddef.h>

#define MAXLIGNE 2048
#define MAXTAB 40
        
/*
#******************************************************************************************
#
# programme permettant de mettre en forme des donnees etablies a partir du script appelant
#
# Dans le script appelant constituer une variable contenant les donnees suivantes
# du style :
#  "variable contenant les donnees ; nom_de_la_colonne ; longueur de la colonne"
#  les blancs dans "nom de la colonne" doivent etre substituer par "_"
#
# Exemple :
# export Edit_Zones="\
#  nom variable1;colonne_1;10\
#  nom variable2;colonne_2;5\
#  nom variable3;colonne_3;10"
#
#   Les variables devront etre en export nom_variable="contenu" dans l appelant
#
#  Puis appeler ce programme Edit_Tableau.exe de cette maniere :
#
#  1) premier appel pour recuperer la longueur total du tableau
#      pour info total = cumul taille zones de ${Edit_Zones} - nbre de colonnes + ( 4 * nbre de colonnes )
#
#     total=`./Edit_Tableau.exe longl ${Edit_Zones}`
#
#  2) premier appel pour souligner
#     ./Edit_Tableau.exe souli ";=;$total"
#
#  3) Puis pour le titre des colonnes
#     ./Edit_Tableau.exe titre ${Edit_Zones}
#
#  4) Puis pour chaque ligne a traiter
#     ./Edit_Tableau.exe ligne ${Edit_Zones}
#
#  5) En fin de traitement pour fermer le tableau
#     ./Edit_Tableau.exe souli ";=;$total"
#
#  Exemple du resultat obtenu :
# 
#  ======================================  }  ./Edit_Tableau.exe souli ";=;34"
#  | colonne 1  | colonne 2 | colonne 3 |  }  ./Edit_Tableau.exe titre ${Edit_Zones}
#  ======================================  }  ./Edit_Tableau.exe souli ";=;34"
#  | valeur  1  | valeur  2 | valeur  3 |  }  ./Edit_Tableau.exe ligne ${Edit_Zones}
#  | valeur  1  | valeur  2 | valeur  3 |  }  ./Edit_Tableau.exe ligne ${Edit_Zones}
#  ======================================  }  ./Edit_Tableau.exe souli ";=;34"
#
*/

int tab( char *, char *, char *, int, int, char *);
int Form_Num( char *);

main (int argc,char *argv[])
{
char *ps, *pd, *pp, *pc, *pt, *pf ;

char fsouli[MAXLIGNE] ;
char ftitre[MAXLIGNE] ;
char fligne[MAXLIGNE] ;
char colvar[80] ;
char colnom[80] ;
char collong[9] ;
char tnombre[MAXTAB] ;
char ttrav[MAXTAB] ;
char fonct[6] ;
char *tfonct[] = { "longl", "souli", "titre", "ligne" } ;

int i, k, l, pos, taille, totaille, nombre, maxligne=MAXLIGNE, maxtab=MAXTAB ;

/* Fichier contenant l usage du trt */
FILE *fp;
char fnom[80] ;
char *fpnom = fnom;
        char ligne[200] ;

/******** usage du trt si pas de parametres ****************/
  if ( argc == 1 )
  {
/********** nom du fichier usage = nom du programme .txt*/
        strcpy(fnom,argv[0]);
        pc=fnom + ( strlen(argv[0]) - 3 );
        strcpy(pc,"txt") ;
       
/* Controle existance du fichier usage */
        if ((fp = fopen(fpnom, "r")) == NULL)
            {
               printf(" Probleme lecture fichier usage <%s> code <%s>\n", fpnom, fp);
               exit(1) ;
            }
         else
            {
                printf("\n");
                 while (fgets(ligne, sizeof(ligne), fp) != NULL)
                  {
                     printf("%s", ligne);
                  }
                  fclose(fp);
                  exit(1) ;
            }
  }

/******** init variable  et tableaux *********/
pc=ftitre ;
        pos=0 ;
        totaille=0 ;

memset(fsouli,'\0',sizeof(fsouli)) ;
     memset(ftitre,'\0',sizeof(ftitre)) ;
     memset(fligne,'\0',sizeof(fligne)) ;

/********** recuperer fonction a realiser **********/

memset(fonct,'\0',sizeof(fonct)) ;
     strcpy(fonct,argv[1]) ;
     pf=fonct ;
     int j=0 ;
     for ( i=0 ; i < 4 ; ++i )
     {
          if ( strcmp(tfonct[i],fonct) == 0 )
          {
              j=1 ;
              i=4 ;
          }
     }

if ( j == 0 )
     {
        printf("Fonction <%s> non valide %s\n", fonct);
        exit(9) ;
     }

/* trt  */
          
for ( i=2 ; i<argc ; ++i )
{
         pp=argv[i] ;
                pd=pp ;

memset(colvar,'\0',sizeof(colvar));
                memset(colnom,'\0',sizeof(colnom));
                memset(collong,'\0',sizeof(collong)); 
/*  parm1 */

pd=memchr( pp,';', strlen(pp) ) ;
         l=strlen(pp) - strlen(pd) ;
         strncpy(colvar,pp,l) ;
         pp=++pd ;

/*  parm2 */
         pd=memchr(pp,';',strlen(pp)) ;
         l=strlen(pp) - strlen(pd) ;
         strncpy(colnom,pp,l) ;
         pp=++pd ;

/*  parm3 */
         strcpy(collong,pp) ;
         taille=atoi(collong) ;

/******* tester si chaine numerique **************/
          for (l=0 ; l < strlen(collong) ; ++l )
          {
              if ( isdigit(collong[l]) == 0 )
             {
               printf(" Colonne longueur ; valeur numerique attendu et recu : %s\n", collong);
               exit(9) ;
             }
          }

if ( taille >= ( MAXLIGNE + 3) )
          {
               printf(" Colonne longueur ; valeur %s > %d \n", collong, maxtab);
               exit(9) ;
          }

/******************************************/

/*** si demande soulignement uniquement*****/
if ( strcmp(argv[1],"souli") == 0 && argc == 3 )
{
pc=fsouli ;
memset(pc,' ',taille) ;
memset(++pc,colnom[0],taille + 1);

printf("%s\n", fsouli);
exit(0) ;
}

/************ Autre choix ***************/

/* la valeur devient ce qui est donne en nom col et de longueur la taille donnee */
if ( strcmp(argv[1],"souli") == 0 && argc > 3 )
{
l=colnom[0] ;
pc=colnom ;
/*  if ( i == 2 ) strncpy(pc," ",1) ; */
memset(++pc,l,taille) ;
}

/****************** remplir table ftitre */
     ps=colnom ;
/*** remplacer les _ par des blancs ******/
     for ( l=0 ; l < strlen(ps) ; ++l )
     {
        if ( colnom[l] == '_' )
          {
              colnom[l] = ' ' ;
          }
     }
     pc=&ftitre[pos] ;
     pt=ftitre ;

k=tab( ps, pc, pt, pos, taille, pf);

/******************* remplir table fligne */
     nombre=1 ;
     memset(ttrav,'\0',sizeof(ttrav)) ;
     memset(tnombre,'\0',sizeof(tnombre)) ;

ps=getenv(colvar) ;
     if ( ps == 0 )
     {
        ps=ttrav ;
        strncpy(ps,"?",1) ;
     }
     else
     {
/*** si nombre cadrer a droite avec separateur de milliers */
        if ( taille < MAXTAB )
        {     
          nombre=0 ;
                 strncpy(tnombre,ps,sizeof(tnombre)) ;

/******* tester si chaine numerique **************/
          for (l=0 ; l < strlen(ps) ; ++l )
          {
              if ( isdigit(tnombre[l]) == 0 ) /****   if ( tnombre[l] < '0' || tnombre[l] > '9' ) ******/
             {
               nombre = 1 ;
             ps=getenv(colvar) ;
               break ;
             }
          }          
         }

/************ cadrer ce champ numerique ***********/
         if ( nombre == 0 )
         {
            strcpy(tnombre,ps) ;
            ps=tnombre ;

Form_Num(tnombre) ;
            if ( strlen(tnombre) > taille )
            {
              ps=getenv(colvar) ;
            }
            else
            {
                  memset(ttrav,' ',taille);
                  l=taille - strlen(tnombre) ;
                  ps=&ttrav[l] ;
                  strcpy(ps,tnombre);
                  ps=ttrav ;
            }
          }
      }

pc=&fligne[pos] ;
     pt=fligne ;

k=tab( ps, pc, pt, pos, taille, pf);

pos=k ;
            totaille=totaille + taille + 3 ;

/* Tester si totaille > MAXLIGNE rejet **/
         if ( totaille > ( MAXLIGNE - 3 ) )
         {
                 printf(" Taille ligne a editer %d > maxi autoriser %d \n", totaille, maxligne );
                 exit(9);
         }

/* Fin prise en compte parametres */        
        
}

/********************  editer titre ligne et fin du tableau */

totaille=totaille ;

/*** si demande longueur ligne *****/
if ( strcmp(argv[1],"longl") == 0 )
{
printf("%i", totaille);
exit(0) ;
}

if ( strcmp(argv[1],"titre") == 0 )
{
printf("%s\n", ftitre);
}

/******************************************/
if ( strcmp(argv[1],"ligne") == 0 )
{
printf("%s\n", fligne);
}

/******************************************/
if ( strcmp(argv[1],"souli") == 0 )
{
printf("%s\n", ftitre);
}

exit(0);
}

/****************** FONCTIONS *****************************************/

int tab( char *ps, char *pc, char *pt, int pos, int taille, char *pf)
{
/* remplir table demandee pt */

int lg;
        char *pr ;

/******** debut du tableau ***********/

lg = strlen(ps);

if ( pos == 0 )
                {
                 pc=pt ;
                 strcpy(pc," | ") ;
                 pos=3 ;
                        pc=pt + pos ;
                }

/************* remplir valeur de la colonne ************/
         memset(pc,' ',taille) ;
         strcpy(pc,ps) ;

if ( lg < taille)
         {
                 pos=pos + lg ;
                 pc=pt + pos ;
                 memset(pc,' ',(taille - lg)) ;
                 pos=pos + (taille - lg) ;
         }
         else
         {
/*    Si on veut finir le champ avec ... si valeur > a celle donnee dans tableau */
                   if ( lg > taille && strcmp(pf,"souli") != 0 )
                   {
                        pr=pc + taille - 3 ;
                        memset(pr,'.',3) ;
                   }
                 pos=pos + taille ;
         }

/******** separateur de colonne du tableau ***********/
         pc=pt + pos ;
         strcpy(pc," | ") ;
         pos=pos + 3 ;

return(pos) ;
}

int Form_Num(char *pnombre)
{
/*
     Presente une donnee separee par un un blanc tous les x caracteres
     ex.:  MForme 1000 3
     Resultat : 1 000
*/

char *plu ;
        char *pok;
char nblu[MAXTAB+1] ;
char nbok[MAXTAB+7] ;
        
int i, j, k, pas;

/* Pas pour separation des donnees */

pas=3 ;

plu=nblu;
pok=nbok;

memset(nblu,'\0',sizeof(nblu));
        memset(pok,'\x20',sizeof(nbok));

sprintf(plu,"%s",pnombre);

/****  retrait des zeros devant *********/
        for (i=0 ; nblu[i] == '0' && i < (strlen(plu) - 1) ; ++i)  { nblu[i] = ' '  ; }

i=strlen(plu) ;
        j=i + ( i / pas ) ;

plu=&nblu[i];
pok=&nbok[j];
        k=0 ;
              
for (k=0 ; i>-1 ; --i, --j, ++k, --plu, --pok)
{

if ( k > pas )
         {
                        k=1 ; --j ; --pok ;
         }

*pok = *plu ; 
}

/* resultat  */
plu=&nblu[0];
pok=&nbok[0];

sprintf(pnombre,"%s",pok);
return(0) ;
}

ScriptTab

#!/bin/sh

#===== Zones et titre des colonnes du tableau
export Edit_Zones="\
 nom_variable1;colonne_1;15\
 nom_variable2;colonne_2;15\
 nom_variable3;colonne_3;15"

#===== Zones pour sous titre
export Edit_Stitre="\
 ;Sous_colonne_1;15\
 ;_______|______;15\
 ;Sous_colonne_3;15"

#===== Zones pour sous titre
export Edit_SStitre="\
 ;;15\
 ;-;15\
 ;;15"

#===== Zones pour sous titre
export Edit_Sligne="\
 ;-;15\
 ;-;15\
 ;-;15"
#=======Pour les traits de separation
#======= 15+15+15+(4*3)-3=54
export souli=";=;`./Edit_Tableau.exe longl ${Edit_Zones}`"

#=========== Tableau simple
 ./Edit_Tableau.exe souli ${souli}
 ./Edit_Tableau.exe titre ${Edit_Zones}
 ./Edit_Tableau.exe souli ${souli}

i=0
export nom_variable1="nom_variable1"
export nom_variable2="nom_variable2"
export nom_variable3="nom_variable3"
  while [ $i -lt 3 ]
  do
       ./Edit_Tableau.exe ligne ${Edit_Zones}
    (( i+=1 ))
  done

./Edit_Tableau.exe souli ${souli}

#=========== Avec sous titre et autre soulignement
export souli=";#;`./Edit_Tableau.exe longl ${Edit_Zones}`"

echo " "

./Edit_Tableau.exe souli ${souli}
 ./Edit_Tableau.exe titre ${Edit_Zones}
 ./Edit_Tableau.exe souli ${Edit_SStitre}
 ./Edit_Tableau.exe titre ${Edit_Stitre}
 ./Edit_Tableau.exe souli ${souli}

./Edit_Tableau.exe souli ${souli}

exit

Resultat

 

 =======================================================
 | colonne 1       | colonne 2       | colonne 3       |
 =======================================================
 | nom_variable1   | nom_variable2   | nom_variable3   |
 | nom_variable1   | nom_variable2   | nom_variable3   |
 | nom_variable1   | nom_variable2   | nom_variable3   |
 =======================================================
 
 #######################################################
 | colonne 1       | colonne 2       | colonne 3       |
 |                 | --------------- |                 |
 | Sous colonne 1  |        |        | Sous colonne 3  |
 #######################################################
 | nom_variable1   | nom_variable2   | nom_variable3   |
 | --------------- | --------------- | --------------- |
 | nom_variable1   | nom_variable2   | nom_variable3   |
 | --------------- | --------------- | --------------- |
 | nom_variable1   | nom_variable2   | nom_variable3   |
 | --------------- | --------------- | --------------- |
 #######################################################

^ Top

Previous page: Pgm read write
Page suivante : Recuperer parametres HTML POST