code pour lecture de fichier

**gege87270** · 24/10/2007, 09h39

En tout cas merci pour ton aide.

Si tu peux me tracer la démarche générale, avec l'intégration d'un main, ça m'arrangerait.

**Médinoc** · 24/10/2007, 09h46

Eh bien, la démarche générale, c'est de passer à EnvoyerLigneEnBase() une structure contenant toutes les informations nécessaires pour envoyer la chaîne à Oracle.

Typiquement, faire la connexion dans le main(), remplir la structure avec les champs qui vont bien, et passer le tout à la fonction LireFichier().
On pourra aussi s'orienter vers le second axe de développement que j'avais mentionné: La prise de paramètres (comme le nom de fichier et/ou la valeur de proc) en ligne de commande.

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/* ... */
struct param
{
	int proc;
	/* + données nécessaires pour la base de données */
	/* ... */
};
 
int EnvoyerLigneEnBase(char const * ligne, int num, void * autre)
{
	struct param *pParams = autre;
	int proc = pParams->proc;
 
	/* ... */
}
 
/* ... */
 
int main(int argc, char *argv[])
{
	struct param params;
	/* Lire les paramètres. */
	/* ... */
 
	/* Se connecter à la base Oracle */
	/* ... */
 
	params.proc = ...
	LireFichier( ... , &params );
 
	/* Se déconnecter de la base Oracle */
	/* ... */
 
	return 0;
}

**gege87270** · 24/10/2007, 09h52

Super,

Je dois m'absenter ce matin, mais je regardes ça cette après midi. J'essaie de remplir un peu ton code avec mes paramètres, je te le fais passer pour avoir ton avis.

**Sve@r** · 24/10/2007, 11h15

Envoyé par gege87270

je crois que j'ai répondu en même temps que toi. Mon dernier post concerné ton post précedent.

Je suis intéressé par le shell dont tu m'as parlé..

Essaye de citer les réponses auxquelles tu réponds car sinon on ne s'en sortira pas.
Personnellement moi je dis que faire ça en C c'est faisable mais très compliqué et faut passer par des langages plus adaptés à ce genre de cas (shell, python) et/ou des outils déjà fait (sed/awk/tr) avec intéraction possible (shell/awk, shell/sed, python/tr etc). Mais évidemment à la base faut déjà être à l'aise en prog dans ces différents langages...

**gege87270** · 24/10/2007, 13h49

Suite à ton dernier message, si tu as une idée avec un prog shell avec awk, je suis preneur.

**gege87270** · 24/10/2007, 16h10

Voilà le code que je viens de modifier.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ... */
struct param
{
 int proc;
 char cUser[80],cPasswd[80];
 char sessionid [21];
 
 /* + données nécessaires pour la base de données */
 /* ... */
};
 
int EnvoyerLigneEnBase(char const * ligne, int num, void * autre)
{
 struct param *pParams = autre;
 int proc = pParams->proc;
 
 /* ... */
}
 
/* ... */
 
int LireFichierOuvert(FILE *pFichierIn, void * autre)
{
 /* Le tableau de 90 caractères: fgets() va y mettre la ligne lue du fichier. */
 char bufLigne[90];
 int numLigne = 1;
 
 /* fgets() est la fonction standard de lecture d'une ligne dans un fichier ouvert.
    Elle retourne NULL en cas d'erreur.
    Si elle réussit à lire une ligne complet, le retour à la ligne (\n) sera dedans.
    Si la ligne est trop grande pour le buffer, elle sera tronquée avant. */
 while(fgets(bufLigne, 90, pFichierIn) != NULL)
 {
  /* Ici, buf contient une ligne terminée par un \n */
 
  /* Recherche du \n pour le supprimer:
     strchr() est la fonction standard de recherche d'un caractère dans une chaîne.
     Elle prend un pointeur de chaîne de caractères et un caractère en paramètre.
     Elle retourne l'adresse du caractère dans la chaîne, ou NULL si elle ne l'a pas trouvé. */
  char * pLF = strchr(bufLigne, '\n');
 
  /* Si on l'a trouvé, on le vire.
     Sinon, c'est soit une erreur, soit la dernière ligne. */
  if(pLF != NULL)
  {
   /* \n trouvé: Tronque la chaîne juste avant */
   *pLF = '\0';
  }
  else if(strlen(bufLigne) == 90-1)
  {
   /* strlen() donne la longueur d'une chaîne de caractère (sans le caractère nul à la fin).
      Si cette longueur est égale à la taille du buffer moins 1, c'est que le buffer est plein à ras bord. */
   return -1; /* ERREUR: La ligne était trop longue. */
  }
  else
  {
   /* Pas de \n mais ligne pas trop longue:
      Ce doit être la dernière. */
 
   /* On ne fait rien ici. */
  }
 
  /* Traitement de la ligne */
  if( EnvoyerLigneEnBase(bufLigne, numLigne, autre) < 0 )
   return -1;
  numLigne++;
 }
 return 0;
}
 
int main(int argc, char *argv[])
{
 struct param params;
 /* Lire les paramètres. */
 /* ... */
 
 /* Se connecter à la base Oracle */
 strcpy(cUser.arr,"******");
    SETLEN(cUser);
    strcpy(cPasswd.arr,"*******");
    SETLEN(cPasswd);
    EXEC SQL CONNECT :cUser IDENTIFIED BY :cPasswd;
    printf("Execution programme <%s> en cours....\n"
    ,argv[0]);
    strcpy(sortie,argv[3]);
    fs = fopen(sortie,"w");
 
 params.proc = sessionid;
 LireFichier( sessionid , &params );
 
 /* Se déconnecter de la base Oracle */
 /* ... */
 
 return 0;
}

Tu remarqueras que je n'ai pas trop avancé. J'ai compilé le code avec Dev C++ ça à l'air de fonctionner mis à part la partie int main(int argc, char *argv[]).

**Médinoc** · 24/10/2007, 16h21

OK, examen rapide:

Tu devrais désormais pouvoir utiliser pParams->sessionid dans EnvoyerLigneEnBase().
Dans le main(), on ne sait pas quels sont les types de cUser et cPasswd, ils ont l'air de ne pas être déclarés.
Dans le main(), le premier paramètre de LireFichier() ne doit pas être sessionid mais le nom du fichier à lire.
Une minute: Tu SAIS te servir de Pro*C, au moins ?

**gege87270** · 24/10/2007, 16h26

Pour le Pro*C je devrait m'en sortir pourquoi ?

**Médinoc** · 24/10/2007, 16h38

Parce que j'ai vu le code avec les argv[3] alors qu'on n'a pas encore définit ce que le programme devrait prendre en ligne de commande.
Et il me fait penser à du "copier-coller au hasard", surtout qu'il utilise des variables non-déclarées et ouvre un fichier en écriture pour des raisons qui m'échappent...

**gege87270** · 24/10/2007, 16h47

Bien vu, c'est que j'ai fait des test dans un shell et tu as raison j'ai recopié bêtement sans réfléchir.
Voilà en fait ce que j'ai modifié

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#include <stdio.h>
#include <stdlib.h>
 
/* ... */
struct param
{
 int proc;
 
 char sessionid [21];
 
 /* + données nécessaires pour la base de données */
 /* ... */
};
 
int EnvoyerLigneEnBase(char const * ligne, int num, void * autre)
{
 struct param *pParams = autre;
 int proc = pParams->sessionid;
 
 /* ... */
}
 
/* ... */
 
int LireFichierOuvert(FILE *pFichierIn, void * autre)
{
 /* Le tableau de 90 caractères: fgets() va y mettre la ligne lue du fichier. */
 char bufLigne[90];
 int numLigne = 1;
 
 /* fgets() est la fonction standard de lecture d'une ligne dans un fichier ouvert.
    Elle retourne NULL en cas d'erreur.
    Si elle réussit à lire une ligne complet, le retour à la ligne (\n) sera dedans.
    Si la ligne est trop grande pour le buffer, elle sera tronquée avant. */
 while(fgets(bufLigne, 90, pFichierIn) != NULL)
 {
  /* Ici, buf contient une ligne terminée par un \n */
 
  /* Recherche du \n pour le supprimer:
     strchr() est la fonction standard de recherche d'un caractère dans une chaîne.
     Elle prend un pointeur de chaîne de caractères et un caractère en paramètre.
     Elle retourne l'adresse du caractère dans la chaîne, ou NULL si elle ne l'a pas trouvé. */
  char * pLF = strchr(bufLigne, '\n');
 
  /* Si on l'a trouvé, on le vire.
     Sinon, c'est soit une erreur, soit la dernière ligne. */
  if(pLF != NULL)
  {
   /* \n trouvé: Tronque la chaîne juste avant */
   *pLF = '\0';
  }
  else if(strlen(bufLigne) == 90-1)
  {
   /* strlen() donne la longueur d'une chaîne de caractère (sans le caractère nul à la fin).
      Si cette longueur est égale à la taille du buffer moins 1, c'est que le buffer est plein à ras bord. */
   return -1; /* ERREUR: La ligne était trop longue. */
  }
  else
  {
   /* Pas de \n mais ligne pas trop longue:
      Ce doit être la dernière. */
 
   /* On ne fait rien ici. */
  }
 
  /* Traitement de la ligne */
  if( EnvoyerLigneEnBase(bufLigne, numLigne, autre) < 0 )
   return -1;
  numLigne++;
 }
 return 0;
}
 
int main(int argc, char *argv[])
{
 struct param params;
 /* Lire les paramètres. */
 /* ... */
 
 /* Se connecter à la base Oracle */
 
 
 params.proc = sessionid;
 LireFichier( sessionid , &params );
 
 /* Se déconnecter de la base Oracle */
 /* ... */
 
 return 0;
}

**Sve@r** · 24/10/2007, 17h03

Envoyé par gege87270

Suite à ton dernier message, si tu as une idée avec un prog shell avec awk, je suis preneur.

Exemple fichier

-----------------------------------------------------------------
Le 23/10/2007
Limoges,
Code client : Xp00014

Facture
_________________________________________________________
Ref | Désignation |Prix HT | Prix TTC |
_________________________________________________________
a |xxxxxxxxxxxxxxxxxxxx |10.25 |15.64 |

_________________________________________________________
Total : 15.64
-----------------------------------------------------------------

Pas vraiment évident au premier abord surtout qu'on ne sait pas trop ce que tu veux récupérer comme info. Moi, je partirais sur une analyse shell ligne par ligne avec évaluation de la ligne où je me trouve selon un indicateur de position

Un exemple de base tapé un peu à la va-vite

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#!/bin/sh
 
# Stockage du fichier en buffer 3
exec 3<fichier.txt
 
# Traitement du buffer 3 (le fichier) ligne par ligne
while read lig 0<&3
do
     # Evaluation de la position en fonction de la ligne
     if test "`echo $lig |cut -c1-5`" = "-----"
     then
           # On est sur un début où une fin (cela dépend de la position précédente)
           if test "$pos" = "debut"
           then
                 pos="fin"
                 # Ici on peut rajouter un traitement pour clore la facture
           else
                 pos="debut"
                 unset facture
                 # Ici on peut rajouter un traitement pour initier la facture
           fi
 
           # La ligne a été traitée - On passe à la suivante
           continue
     fi
 
     # Si on est sur la ligne "Code client"
     if test "`echo $lig |cut -c1-11`" = "Code client"
     then
           # Récupération du code client (ce qu'il y a après les ":")
           codeClient=`echo $lig |cut -f2 -d:`
 
            # Donc ici on peut traiter le code client
            ...
 
           # La ligne a été traitée - On passe à la suivante
           continue
      fi
 
      # Si on est sur la ligne "Ref"
     if test "`echo $lig |cut -c1-3`" = "Ref"
     then
          # On entre dans le mode "ligne facture" qui s'achèvera sur "total"
          facture="in"
 
           # La ligne a été traitée - On passe à la suivante
           continue
      fi
 
      # Si on est dans le mode "facture"
      if test "$facture" = "in"
      then
            # Si la ligne contient des pipes
            if echo $lig |grep "|" 1>/dev/null
            then
                 # On est sur une ligne de facturation - On l'analyse
                 ref=`echo $lig |cut -f1 -d"|"`
                 designation=`echo $lig |cut -f2 -d"|"`
                 ht=`echo $lig |cut -f3 -d"|"`
                 ttc=`echo $lig |cut -f4 -d"|"`
 
                 # Traitement des infos récupérées
                 ...
 
                 # La ligne a été traitée - On passe à la suivante
                 continue
            fi
 
           # Si la ligne contient le mot "Total"
            if echo $lig |grep "Total" 1>/dev/null
            then
                 # On est sur le total de la facturation - On l'analyse
                 total=`echo $lig |cut -f2 -d":"`
 
                 # Traitement du total récupéré
                 ...
 
                 # On quitte le mode "ligne facture"
                 unset facture
 
                 # La ligne a été traitée - On passe à la suivante
                 continue
            fi
       fi
 
       # etc etc etc (chaque ligne ayant une caractéristique peut être récupérée...
done

Bon, c'est assez lourdeau comme style de programmation mais faut dire que ton fichier est assez pourri dans son genre. Surtout que je me base pour l'écrire sur des items qui peuvent changer avec le temps (si demain le patron décide qu'une facture doit avoir des "+++++" à la place des "-------" ben le script => poubelle).
Ceci me fait dire que peut-être tu as un défaut dans ta conception. Peut-être tu pourrais essayer de remonter plus haut à la source pour essayer de récupérer les infos là où elles sont avant qu'un programme annexe que tu ne maîtrises pas les traite pour en générer ce fichier boiteux que toi tu devras analyser et ingérer.

Bien entendu j'ose espérer que tu as aussi quelques bonnes bases en shell pour pouvoir faire ce travail car c'est pas à la portée du premier débutant venu...

**Médinoc** · 24/10/2007, 17h08

Envoyé par gege87270

Bien vu, c'est que j'ai fait des test dans un shell et tu as raison j'ai recopié bêtement sans réfléchir.
Voilà en fait ce que j'ai modifié

<snip>

Euh... C'est encore pire qu'avant...

**gege87270** · 25/10/2007, 08h17

Sve@r,

l'exemple que je donne est pourri je le reconnais, mais c'était pour donner une idée de la structure de mes fichiers d'édition. En aucun cas cela reflète la réalité. Les éditions se font sur des feuillets près imprimés, seules les infos sont éditées. Je n'ai pas besoin de tenir compte des --- ou des ____.

Ce qui m'intéresse c'est de lire ces fichiers en séquentiel, et lorsque je trouve un \n ou un ^L je copie la ligne pour l'insérer dans une table sous ORACLE.

MEDICOC,

Je pense sans offenser sve@r que ta méthode est la bonne. Si tu pouvais affiner le code que tu as déjà conçu, ça me serait d'une grande utilité.

Merci à vous deux.

**Médinoc** · 25/10/2007, 09h41

J'ai affiné un peu mon code, en indiquant les fonctions où tu devais mettre le code en Pro*C (voir les commentaires en majuscules).
J'ai également ajouté le code de lecture des paramètres en ligne de commande. Le programme s'emploie ainsi (exemple) :

Code X :

Sélectionner tout - Visualiser dans une fenêtre à part

programme.exe "C:\MonFichierTexte.txt" 42

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
/* ===============================================================
   Inclusions de fichiers d'en-tête de la bibliothèque standard */
 
#include <stdio.h>  /* Fonctions d'entrées/sorties (fichiers etc.) */
#include <string.h> /* Fonctions sur les chaînes de caractères */
#include <stdlib.h> /* Principales fonctions de biblio standard. */
 
 
/* ========================
   Structures de données */
 
struct param
{
	int proc;
	/* + données nécessaires pour la base de données */
	char sessionid[21];
 
	/* ... */
};
 
 
/* =========================
   Fonctions du programme */
 
/* ------------------------------------------------
   Fonction pour se connecter à la base de données.
   Il n'y a rien dedans, puisque je ne sais pas comment on fait.
   
Paramètres:
	sessionid : [out] ID de session. Le buffer doit faire 21 caractères exactement.	
Retourne 0 si OK, -1 si erreur. */
int ConnexionBaseDonnees(char sessionid[21])
{
	/* ICI, TU DOIS METTRE LE CODE EN Pro*C PERMETTANT DE SE CONNECTER À LA BASE
	   ET DE METTRE L'ID DE SESSION DANS sessionid.
	   JE NE PEUX PAS LE FAIRE, CAR JE NE CONNAIS PAS Pro*C */
	return 0;
}
 
/* ---------------------------------------------------
   Fonction pour se déconnecter de la base de données.
   Il n'y a rien dedans, puisque je ne sais pas comment on fait.
   
Paramètres:
	sessionid : [in] ID de session.	
Retourne 0 si OK, -1 si erreur. */
int DeconnexionBaseDonnees(char sessionid[21])
{
	/* ICI, TU DOIS METTRE LE CODE EN Pro*C PERMETTANT DE SE DECONNECTER DE LA BASE
	   GRACE AU sessionid DE LA STRUCTURE.
	   JE NE PEUX PAS LE FAIRE, CAR JE NE CONNAIS PAS Pro*C */
	return 0;
}
 
/* --------------------------------------------------
   Fonction pour envoyer la ligne en base de données.
   Il n'y a rien dedans, puisque je ne sais pas comment on fait.
   
Paramètres:
	ligne : [in] La ligne lue (c'est un pointeur const sur le premier caractère de la ligne)	
	num   : [in] Numéro de ligne.
	autre : [in] Paramètre utilisateur passé à LireFichier().
Retourne 0 si OK, -1 si erreur. */
int EnvoyerLigneEnBase(char const * ligne, int num, void * autre)
{
	struct param *pParams = autre;
	int proc = pParams->proc;
 
	/* ICI, TU DOIS METTRE LE CODE EN Pro*C PERMETTANT D'INSERER LA LIGNE EN BASE
	   GRACE AU sessionid DE LA STRUCTURE.
	   JE NE PEUX PAS LE FAIRE, CAR JE NE CONNAIS PAS Pro*C */
	return 0;
}
 
/* ----------------------------------------------------------------------------
   Fonction pour lire sur le fichier ouvert.
   La fonction lit chaque ligne du fichier pour son buffer de 90 caractères.
   Ensuite, elle cherche le caractère de retour à la ligne dedans,
   le supprime s'il est là (si les lignes sont bien limitées à 86 caractères, 
   il sera forcément là, sauf pour la dernière ligne) puis appelle
   la fonction EnvoyerLigneEnBase() sur la ligne lue.
 
Paramètres:
	pFichierIn : [in] Le fichier ouvert (c'est un FILE*, on n'a pas besoin de savoir ce qu'il y a dedans)   
	autre      : [bypass] Paramètre à passer à EnvoyerLigneEnBase()
Retourne 0 si OK, -1 si erreur. */
int LireFichierOuvert(FILE *pFichierIn, void * autre)
{
	/* Le tableau de 90 caractères: fgets() va y mettre la ligne lue du fichier. */
	char bufLigne[90];
	int numLigne = 1;
 
	/* fgets() est la fonction standard de lecture d'une ligne dans un fichier ouvert.
	   Elle retourne NULL en cas d'erreur.
	   Si elle réussit à lire une ligne complet, le retour à la ligne (\n) sera dedans.
	   Si la ligne est trop grande pour le buffer, elle sera tronquée avant. */
	while(fgets(bufLigne, 90, pFichierIn) != NULL)
	{
		/* Ici, buf contient une ligne terminée par un \n */
 
		/* Recherche du \n pour le supprimer:
		   strchr() est la fonction standard de recherche d'un caractère dans une chaîne.
		   Elle prend un pointeur de chaîne de caractères et un caractère en paramètre.
		   Elle retourne l'adresse du caractère dans la chaîne, ou NULL si elle ne l'a pas trouvé. */
		char * pLF = strchr(bufLigne, '\n');
 
		/* Si on l'a trouvé, on le vire.
		   Sinon, c'est soit une erreur, soit la dernière ligne. */
		if(pLF != NULL)
		{
			/* \n trouvé: Tronque la chaîne juste avant */
			*pLF = '\0';
		}
		else if(strlen(bufLigne) == 90-1)
		{
			/* strlen() donne la longueur d'une chaîne de caractère (sans le caractère nul à la fin).
			   Si cette longueur est égale à la taille du buffer moins 1, c'est que le buffer est plein à ras bord. */
			return -1; /* ERREUR: La ligne était trop longue. */
		}
		else
		{
			/* Pas de \n mais ligne pas trop longue:
			   Ce doit être la dernière. */
 
			/* On ne fait rien ici. */
		}
 
		/* Traitement de la ligne */
		if( EnvoyerLigneEnBase(bufLigne, numLigne, autre) < 0 )
			return -1;
		numLigne++;
	}
	return 0;
}
 
 
/* ----------------------------------------------------------------------------
   Fonction pour ouvrir un fichier et le lire:
   Cette fonction ouvre le fichier dont on lui passe le nom,
   elle obtient alors un pointeur de fichier ouvert.
   Alors elle appelle la fonciton LireFichierOuvert() sur ce pointeur.
 
Paramètres:
	nomFich : [in] Nom du fichier à lire (c'est en fait un pointeur sur le premier caractère du nom)
	autre   : [bypass] Paramètre à passer à EnvoyerLigneEnBase()
Retourne 0 si OK, -1 si erreur. */
int LireFichier(char const *nomFich, void * autre)
{
	/* Valeur qui sera retournée par la fonction.
	   Si l'ouverture échoue, elle restera à -1 (erreur). */
	int ret = -1;
	/* Variable qui contiendra le pointeur de fichier ouvert, retourné par fopen() */
	FILE * pFichier = NULL;
 
	/* fopen() est la fonction standard pour ouvrir un fichier.
	Elle retourne un pointeur de fichier ouvert, ou NULL si l'ouverture échoue. */
	pFichier = fopen(nomFich, "r");
 
	if(pFichier != NULL)
	{
		/* Le pointeur n'est pas NULL, l'ouverture a donc réussi. */
 
		/* puts() : Une fonction standard toute bète pour afficher un message. */
		puts("Lecture du fichier...");
 
		ret = LireFichierOuvert(pFichier, autre);
 
		/* fclose() : Fonction pour fermer un fichier ouvert.
		Il ne faut pas l'utiliser si le pointeur est NULL. */
		fclose(pFichier);
	}
	else
	{
		/* Le pointeur est NULL, l'ouverture a échoué. */
 
		puts("Echec d'ouverture.");
	}
	return ret;
}
 
int main(int argc, char * argv[])
{
	struct param params;
	char const * nomFichier = NULL;
	long proc = 0;
 
	/* Lire les paramètres. */
	/* Paramètres: On va dire nom du fichier en premier paramètre, valeur de proc en second. */
	if(argc < 3)
	{
		puts("Pas assez de paramètres.");
		return 1;
	}
	nomFichier = argv[1];
	proc = strtol(argv[2], NULL, 10);
 
	/* Connexion à la base de données */
	if( ConnexionBaseDonnees(params.sessionid) < 0)
	{
		puts("Echec de connexion");
		return 1;
	}
 
	/* Traitement du fichier */
	params.proc = (int)proc;
	LireFichier(nomFichier, &params);
 
	/* Déconnexion de la base de sonnées. */
	DeconnexionBaseDonnees(params.sessionid);
	return 0;
}

Note: Ça compile, mais je n'ai pas testé.

**gege87270** · 25/10/2007, 10h47

Mon collègue va prendre la suite du développement, notamment pour le pro*C. Bien évidemment je te tiens informé de la suite, et si ça t'intéresse, je te ferais passer le code complet.

Merci encore pour ton aide précieuse.

code pour lecture de fichier

C

Discussions similaires

Partager

Partager