Problème de Core dumped, Memory Fault

**pmboutteau** · 18/03/2009, 09h42

Bonjour,

Voilà j'ai un petit souci sur un programme où je stocke une table dans une structure.

Cette table contient 46 champs.

Lorsque j'arrive à 30 variables dans mes PRO*C, j'ai un core dumped, alors qu'à 29 variables plus le reste en dur le programme tourne.

Je ne vois pas de solution.

**BainE** · 18/03/2009, 09h56

bonjour,

comme ca, ca va pas etre facile.

tu peux nous montrer le code ?

**pmboutteau** · 18/03/2009, 10h32

OK. Pour info, le but du programme est de parcourir une table et de faire des fusions d'enregistrements si chevauchement sur les dates dans une table de travail.

Le PRO*C . Dès que je rajoute TUFUMED ça fait le core dumped

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
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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
#include <string.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "commun.h"
#include "conv_typestruct.h"
 
 
/*déclaration du curseur*/
EXEC SQL DECLARE lect_tufstr CURSOR for
SELECT PREFIX,TUFUFON,to_char(TDATDEB,'YYYYMMDD'),TYPNOM,CODDIF,CODHOP,
       to_char(TDATFIN,'YYYYMMDD'),to_char(TDATMAJ,'YYYYMMDD'),TORIMAJ,
       TMESURE,TUFTUTI,TUFLIBS,TUFLIBC,TUFLIBL,TUFDCOR,TUFETAB,
       TUFCGES,TUFLBUD,TUFTACT,TUFDISC,TUFSTAR,TUFSPSY,TUFFEDE,TUFDEPT,
       TUFCRES,TUFSERV,TUFSANA,TUFCACT,TUFSPRV,TUFUMED
 
   FROM TUFSTR
   ORDER BY TUFUFON;
 
EXEC SQL INCLUDE SQLCA;
 
/*fonction d'erreur*/
void sqlerror_tufstr()
{
   if (sqlca.sqlcode != -1405)
   {
      EXEC SQL WHENEVER SQLERROR CONTINUE;
      erreur_C("%s \n","erreur sql  : erreur de lecture dans la table tufstr");
      erreur_N ("sqlcode : %d\n",sqlca.sqlcode);
      erreur_C ("Erreur Oracle %s\n",sqlca.sqlerrm.sqlerrmc);
   }
   else SQLCODE=SQL_OK;
}
 
/*-------------------------------------------------------------*/
/* But       : Lecture des enregistrements de la table tufstr  */
/*             Pour remplir WTUFSTR                            */  
/* Paramètre : entrée:                            		         */
/*                   :                            		         */
/*             sortie : structure contenant les différents     */
/*                      donnees à traiter                      */
/*                                                 		         */
/* Retour    : TRUE/FALSE                          		         */
 
int LIRE_TUFSTR(struct TUFSTR_LECT *ret)
{
   char nom_fonction[50];
   RAZ(nom_fonction);
 
   CPY("LIRE_TUFSTR",nom_fonction);
 
   int cont;
   int Indice = -1;
 
   EXEC SQL BEGIN DECLARE SECTION;
        char  prefix [2+1];          
        char tufufon [5+1];
        char tdatdeb [8+1]; 
        char typnom  [1+1];          
        char coddif  [2+1];          
        char codhop  [3+1];
        char tdatfin [8+1];
        char tdatmaj [8+1];
        char torimaj [6+1];          
        int  tmesure;
        char tuftuti [1+1];          
        char tuflibs [25+1];         
        char tuflibc [10+1];
        char tuflibl [50+1];         
        char tufdcor [4+1];          
        char tufetab [2+1];
        char tufcges [2+1];          
        char tuflbud [1+1];          
        char tuftact [2+1];          
        char tufdisc [4+1];          
        char tufstar [6+1];          
        char tufspsy [4+1];          
        char tuffede [4+1];          
        char tufdept [4+1];
        char tufcres [4+1];       
        char tufserv [4+1];          
        char tufsana [10+1];
        char tufcact [4+1]; 
        char tufsprv [5+1];     
        char tufumed [4+1];    
 
	EXEC SQL END DECLARE SECTION;
 
	EXEC SQL WHENEVER SQLERROR DO sqlerror_tufstr();
 
	debut_fct (nom_fonction,4);
 
  niv_printf(3,"",nom_fonction,"Lecture TUFSTR \n");
 
	EXEC SQL OPEN lect_tufstr;
 
	SQLCODE=SQL_OK;	
	cont=TRUE;
	int aucune_donnee = 0;
 
  while ((SQLCODE == SQL_OK) && (cont == TRUE))
	{ 
        RAZ(prefix);
      	RAZ(tufufon);
        RAZ(tdatdeb);
        RAZ(typnom);
        RAZ(coddif);
        RAZ(codhop);
        RAZ(tdatfin);
        RAZ(tdatmaj);
        RAZ(torimaj);
        RAZ(tuftuti);
        RAZ(tuflibs);
        RAZ(tuflibc);
        RAZ(tuflibl);
        RAZ(tufdcor);
        RAZ(tufetab); 
        RAZ(tufcges);
        RAZ(tuflbud);
        RAZ(tuftact);
        RAZ(tufdisc);
        RAZ(tufstar);
        RAZ(tufspsy); 
        RAZ(tuffede);
        RAZ(tufdept);
        RAZ(tufcres);
        RAZ(tufserv);
        RAZ(tufsana);
        RAZ(tufcact);
        RAZ(tufsprv);
        RAZ(tufumed);
 
      EXEC SQL FETCH lect_tufstr INTO
        prefix,	
	      tufufon,
        tdatdeb,
        typnom,
        coddif,
        codhop,
        tdatfin,
        tdatmaj,
        torimaj,
        tmesure,
        tuftuti,
        tuflibs,
        tuflibc,
        tuflibl,
        tufdcor,
        tufetab,
        tufcges,
        tuflbud,
        tuftact,
        tufdisc,
        tufstar,
        tufspsy, 
        tuffede,
        tufdept,
        tufcres,
        tufserv,
        tufsana,
        tufcact,
        tufsprv,
        tufumed;
 
      if (SQLCODE==SQL_OK)
      {
         niv_printf(5,"",nom_fonction, " - TUFUFON [%s]\n",tufufon);	
 
         Indice++;
         RAZ(ret->prefix[Indice]);   CPY(prefix,ret->prefix[Indice]);
         RAZ(ret->tufufon[Indice]);  CPY(tufufon,ret->tufufon[Indice]); 
         RAZ(ret->tdatdeb[Indice]);  CPY(tdatdeb,ret->tdatdeb[Indice]);
         RAZ(ret->typnom[Indice]);   CPY(typnom,ret->typnom[Indice]); 
         RAZ(ret->coddif[Indice]);   CPY(coddif,ret->coddif[Indice]); 
         RAZ(ret->codhop[Indice]);   CPY(codhop,ret->codhop[Indice]); 
         RAZ(ret->tdatfin[Indice]);  CPY(tdatfin,ret->tdatfin[Indice]);
         RAZ(ret->tdatmaj[Indice]);  CPY(tdatmaj,ret->tdatmaj[Indice]);
         RAZ(ret->torimaj[Indice]);  CPY(torimaj,ret->torimaj[Indice]);
         ret->tmesure[Indice]=tmesure; 
         RAZ(ret->tuftuti[Indice]);  CPY(tuftuti,ret->tuftuti[Indice]); 
         RAZ(ret->tuflibs[Indice]);  CPY(tuflibs,ret->tuflibs[Indice]); 
         RAZ(ret->tuflibc[Indice]);  CPY(tuflibc,ret->tuflibc[Indice]); 
         RAZ(ret->tuflibl[Indice]);  CPY(tuflibl,ret->tuflibl[Indice]); 
         RAZ(ret->tufdcor[Indice]);  CPY(tufdcor,ret->tufdcor[Indice]); 
         RAZ(ret->tufetab[Indice]);  CPY(tufetab,ret->tufetab[Indice]);
         RAZ(ret->tufcges[Indice]);  CPY(tufcges,ret->tufcges[Indice]);
         RAZ(ret->tuflbud[Indice]);  CPY(tuflbud,ret->tuflbud[Indice]);
         RAZ(ret->tuftact[Indice]);  CPY(tuftact,ret->tuftact[Indice]);
         RAZ(ret->tufdisc[Indice]);  CPY(tufdisc,ret->tufdisc[Indice]);
         RAZ(ret->tufstar[Indice]);  CPY(tufstar,ret->tufstar[Indice]);
         RAZ(ret->tufspsy[Indice]);  CPY(tufspsy,ret->tufspsy[Indice]); 
         RAZ(ret->tuffede[Indice]);  CPY(tuffede,ret->tuffede[Indice]); 
         RAZ(ret->tufdept[Indice]);  CPY(tufdept,ret->tufdept[Indice]);  
         RAZ(ret->tufcres[Indice]);  CPY(tufcres,ret->tufcres[Indice]);
         RAZ(ret->tufserv[Indice]);  CPY(tufserv,ret->tufserv[Indice]);
         RAZ(ret->tufsana[Indice]);  CPY(tufsana,ret->tufsana[Indice]); 
         RAZ(ret->tufcact[Indice]);  CPY(tufcact,ret->tufcact[Indice]);
         RAZ(ret->tufsprv[Indice]);  CPY(tufsprv,ret->tufsprv[Indice]);
         RAZ(ret->tufumed[Indice]);  CPY(tufumed,ret->tufumed[Indice]);        
 
         aucune_donnee = 1;
      }
 
      if((SQLCODE==NO_DATA_FOUND)&&(aucune_donnee == 0)) 
      {
         niv_printf(2,"",nom_fonction,"Aucune données trouvées.\n");
         cont = FALSE;
      } 
   }
   ret->nb_enr = Indice ;
 
   /**********************************************/
   /* fermeture du curseur de lecture            */
   /**********************************************/
	 EXEC SQL CLOSE lect_tufstr;
 
   fin_fct (nom_fonction,4);
   return (cont);
}
 
 
 
/*------------------------------------------------------------*/
/* But       : Insère les enregistrements  de wtufstr         */
/*             dans la table tufstr                           */
/*                                                            */
/* Paramètre : entrée : Une structure                         */
/*             sortie : Pas de sortie                         */
/*                                                            */
/* Retour    : TRUE/FALSE                                     */
 
 
int INS_TUFSTR(struct TUFSTR_LECT s_wtufstr)
{
   char nom_fonction[50];
   RAZ(nom_fonction);
 
   CPY("INS_TUFSTR",nom_fonction);
 
   int i = 0;
   int cont;
   int ret;
 
   debut_fct (nom_fonction,4);
 
   EXEC SQL WHENEVER SQLERROR DO sqlerror_tufstr();
 
   SQLCODE=SQL_OK;
   cont=TRUE;
 
   while ((SQLCODE == SQL_OK) && (cont == TRUE) && (i <= s_wtufstr.nb_enr))
   {
 
  niv_printf(5,s_wtufstr.tufufon[i],nom_fonction,"Insersion tufstr -  CODHOP [%s] UF [%s] \n",s_wtufstr.codhop[i],s_wtufstr.tufufon[i]);
 
 
      EXEC SQL INSERT INTO tufstr
      (
        PREFIX,
        TUFUFON,
        TDATDEB,
        TYPNOM,
        CODDIF,
        CODHOP,
        TDATFIN,
        TDATMAJ,
        TORIMAJ,
        TMESURE,
        TUFTUTI,
        TUFLIBS,
        TUFLIBC,
        TUFLIBL,
        TUFDCOR,
        TUFETAB,
        TUFCGES,
        TUFLBUD,
        TUFTACT,
        TUFDISC,
        TUFSTAR,
        TUFSPSY, 
        TUFFEDE,
        TUFDEPT,
        TUFCRES,
        TUFSERV,
        TUFSANA,
        TUFCACT,
        TUFSPRV,
        TUFUMED,
        TUFMATR,
        TUFTSSA,
        TUFTSST,
        TUFTNBI,
        TUFREGA,
        TUFREGB,
        TUFREGC, 
        TUFREGD,
        TUFREGE,
        TUFREMP, 
        TUFNTEL,
        TUFPRIN,
        TUFSAUX,
        TUFSHOP,
        TUFSIMP,
        TUFPOLE
 
      )
      VALUES
      (
        :s_wtufstr.prefix[i],
        :s_wtufstr.tufufon[i],
        to_date(:s_wtufstr.tdatdeb[i], 'YYYYMMDD'),
        :s_wtufstr.typnom[i],
        :s_wtufstr.coddif[i],
        :s_wtufstr.codhop[i],
        to_date(:s_wtufstr.tdatfin[i], 'YYYYMMDD'),
        to_date(:s_wtufstr.tdatmaj[i], 'YYYYMMDD'),
        :s_wtufstr.torimaj[i],
        :s_wtufstr.tmesure[i],
        :s_wtufstr.tuftuti[i],
        :s_wtufstr.tuflibs[i],
        :s_wtufstr.tuflibc[i],
        :s_wtufstr.tuflibl[i],
        :s_wtufstr.tufdcor[i],
        :s_wtufstr.tufetab[i],
        :s_wtufstr.tufcges[i],
        :s_wtufstr.tuflbud[i],
        :s_wtufstr.tuftact[i],
        :s_wtufstr.tufdisc[i],
        :s_wtufstr.tufstar[i],
        :s_wtufstr.tufspsy[i],
        :s_wtufstr.tuffede[i],
        :s_wtufstr.tufdept[i],
        :s_wtufstr.tufcres[i],
        :s_wtufstr.tufserv[i],
        :s_wtufstr.tufsana[i],
        :s_wtufstr.tufcact[i],
        :s_wtufstr.tufsprv[i],
        :s_wtufstr.tufumed[i],
        ' ',
        0,
        0,
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' ',
        ' '
 
 
      );
 
      if (SQLCODE==SQL_OK)
      {
         niv_printf(5," ",nom_fonction,"Insertion OK\n");
      }
      else
      {
         niv_printf(2,"",nom_fonction,"Insertion Echec - Erreur [%d]\n",SQLCODE);
         cont = FALSE;
      }
 
      EXEC SQL COMMIT;
      i++;
   }
 
   fin_fct (nom_fonction,4);
 
   return(cont);
}
 
/*---------------------------------------------------------*/
/* But       : Vide la table tufstr                        */
/*             avant remplissage par WTUFSTR               */
/*                                                         */
/* Paramètre : entrée :                                    */
/*             sortie : Pas de sortie                      */
/*                                                         */
/* Retour    : TRUE/FALSE                                  */
 
 
int DEL_TUFSTR()
{
   char nom_fonction[50];
   RAZ(nom_fonction);
 
   CPY("DEL_TUFSTR",nom_fonction);
 
   int i;
   int cont;
 
   debut_fct (nom_fonction,4);
 
   EXEC SQL WHENEVER SQLERROR DO sqlerror_tufstr();
 
   SQLCODE=SQL_OK;
   cont=TRUE;
 
   EXEC SQL TRUNCATE TABLE TUFSTR;
 
   if (SQLCODE==SQL_OK) niv_printf(5,"",nom_fonction,"Truncate OK\n");
   else
   {
      if (SQLCODE == 1403)
      niv_printf(5,"",nom_fonction,"Rien à supprimer\n");
      else
      niv_printf(2,"",nom_fonction,"Suppression Echec - Erreur [%d]\n",SQLCODE);
   }
 
   /* On commit le résultat */
   EXEC SQL COMMIT;
 
   fin_fct (nom_fonction,4);
 
   return(cont);
}

La structure

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
 
#include "define.h"
/*-----------------------------------------*/
#ifndef __CONVTYPESTRUCT__
#define __CONVTYPESTRUCT__
 
/* Structure pour la lecture de la table TUFSTR                */
/* ----------------------------------------------------------- */
struct TUFSTR_LECT
{  char  prefix [MAX_ENR_MAT][2+1];
   char tufufon [MAX_ENR_MAT][5+1];
   char tdatdeb [MAX_ENR_MAT][8+1];
   char typnom  [MAX_ENR_MAT][1+1];
   char coddif  [MAX_ENR_MAT][2+1];
   char codhop  [MAX_ENR_MAT][3+1];
   char tdatfin [MAX_ENR_MAT][8+1];
   char tdatmaj [MAX_ENR_MAT][8+1];
   char torimaj [MAX_ENR_MAT][6+1];
   int  tmesure [MAX_ENR_MAT];
   char tuftuti [MAX_ENR_MAT][1+1];
   char tuflibs [MAX_ENR_MAT][25+1];
   char tuflibc [MAX_ENR_MAT][10+1];
   char tuflibl [MAX_ENR_MAT][50+1];
   char tufdcor [MAX_ENR_MAT][4+1];
   char tufetab [MAX_ENR_MAT][2+1];
   char tufcges [MAX_ENR_MAT][2+1];
   char tuflbud [MAX_ENR_MAT][1+1];
   char tuftact [MAX_ENR_MAT][2+1];
   char tufdisc [MAX_ENR_MAT][4+1];
   char tufstar [MAX_ENR_MAT][6+1];
   char tufspsy [MAX_ENR_MAT][4+1];
   char tuffede [MAX_ENR_MAT][4+1];
   char tufdept [MAX_ENR_MAT][4+1];
   char tufcres [MAX_ENR_MAT][4+1];
   char tufserv [MAX_ENR_MAT][4+1];
   char tufsana [MAX_ENR_MAT][10+1];
   char tufcact [MAX_ENR_MAT][4+1];
   char tufsprv [MAX_ENR_MAT][5+1];
   char tufumed [MAX_ENR_MAT][4+1]; 
   int   nb_enr;
};
 
/*Structure pour l'insertion WTUFSTR */ 
struct WTUFSTR_INS
   {char  prefix [2+1];
    char tufufon [5+1];
    char tdatdeb [8+1];
    char typnom  [1+1];
    char coddif  [2+1];
    char codhop  [3+1];
    char tdatfin [8+1];
    char tdatmaj [8+1];
    char torimaj [6+1];
    int  tmesure ;
    char tuftuti [1+1];
    char tuflibs [25+1];
    char tuflibc [10+1];
    char tuflibl [50+1];
    char tufdcor [4+1];
    char tufetab [2+1];
    char tufcges [2+1];
    char tuflbud [1+1];
    char tuftact [2+1];
    char tufdisc [4+1];
    char tufstar [6+1];
    char tufspsy [4+1];
    char tuffede [4+1];
    char tufdept [4+1];
    char tufcres [4+1];
    char tufserv [4+1];
    char tufsana [10+1];
    char tufcact [4+1];
    char tufsprv [5+1];
    char tufumed [4+1];   
};
 
#endif

LE C

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
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
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "commun.h"
#include "conv_typestruct.h"
 
void fin_traitement(int retour)
{
   char date1[20];
   char heure1[20];	
 
   RAZ(date1);
   RAZ(heure1);
   fct_date(date1);
   fct_heure(heure1);
   niv_printf(4,"","fusion_TUFSTR_princ.c","\n");
   niv_printf(1,"","fusion_TUFSTR_princ.c","\n");
   niv_printf(1,"","fusion_TUFSTR_princ.c","                #################################\n");
   niv_printf(4,"","fusion_TUFSTR_princ.c","                #                               #\n");
   if(retour == 1) 
   niv_printf(1,"","fusion_TUFSTR_princ.c","                #   => Mise en Forme:  SUCCES   #\n");
   else 
   niv_printf(1,"","fusion_TUFSTR_princ.c","                #   => Mise en Forme:  ECHEC    #\n");
   niv_printf(1,"","fusion_TUFSTR_princ.c","                #                      ======   #\n");
   niv_printf(4,"","fusion_TUFSTR_princ.c","                #                               #\n");
   niv_printf(1,"","fusion_TUFSTR_princ.c","                #################################\n");
   niv_printf(1,"","fusion_TUFSTR_princ.c","\n");	
   niv_printf(1,"","fusion_TUFSTR_princ.c","Fin Mise en Forme pour RPPS  %s:%s\n",date1,heure1);
   niv_printf(1,"","fusion_TUFSTR_princ.c","########################################################################\n");
 
   fin_fct ("fusion_TUFSTR_princ.c",1);
 
   exit(0);
}
 
 
 
/* ---------------------------------------------------------------- */
/*                                                                  */
/*                           Initialisation                         */
/*                                                                  */
/* ---------------------------------------------------------------- */
void fusion ()
{
   debut_fct ("Fusion",4);
   /* Variables diverses pour les boucles et les resultat de fonctions */
   int ret;
   int i,j;
   i=0;
   j=0;
 
   /*Structure contenant TUFSTR */
   struct TUFSTR_LECT s_TUFSTR;
   /*Structure contenant TUFSTR */
   struct TUFSTR_LECT s_WTUFSTR;
 
   /*Structure de la tempo WTUFSTR */ 
   struct WTUFSTR_INS zo_wtufstr;
 
   /*Initialisation de la structure */
       RAZ(zo_wtufstr.prefix);
       RAZ(zo_wtufstr.tufufon);
       RAZ(zo_wtufstr.tdatdeb);
       RAZ(zo_wtufstr.typnom);
       RAZ(zo_wtufstr.coddif);
       RAZ(zo_wtufstr.codhop);
       RAZ(zo_wtufstr.tdatfin);
       RAZ(zo_wtufstr.tdatmaj);
       RAZ(zo_wtufstr.torimaj); 
       RAZ(zo_wtufstr.tuftuti);
       RAZ(zo_wtufstr.tuflibs);
       RAZ(zo_wtufstr.tuflibc);
       RAZ(zo_wtufstr.tuflibl);
       RAZ(zo_wtufstr.tufdcor);
       RAZ(zo_wtufstr.tufetab);
       RAZ(zo_wtufstr.tufcges);
       RAZ(zo_wtufstr.tuflbud);
       RAZ(zo_wtufstr.tuftact);
       RAZ(zo_wtufstr.tufdisc);
       RAZ(zo_wtufstr.tufstar);
       RAZ(zo_wtufstr.tufspsy); 
       RAZ(zo_wtufstr.tuffede);
       RAZ(zo_wtufstr.tufdept);
       RAZ(zo_wtufstr.tufcres);
       RAZ(zo_wtufstr.tufserv);
       RAZ(zo_wtufstr.tufsana);
       RAZ(zo_wtufstr.tufcact);
       RAZ(zo_wtufstr.tufsprv);
       RAZ(zo_wtufstr.tufumed);
 
 
   /* On vide WTUFSTRE par précaution                      */
   ret = DEL_WTUFSTR();  
 
   /* Lecture de TUFSTR plus stockage dans la structure  */  
   ret = LIRE_TUFSTR(&s_TUFSTR);
 
   /* boucle de lecture sur la structure TUFSTR             */
   /* si Appareillage avec WTUFSTR => Test sur les périodes */
   /* Suivant le test on insère ou on MAJ WTUFSTR           */
   /* Si non Appareillage on insère WTUFSTR                 */ 
 
   /* On stocke dans la tempo de WTUFSTR les données du     */
   /* premier enreg lu dans TUFSTR                          */
 
   if (s_TUFSTR.nb_enr != -1)
   /* on a au moins une donnée dans TUFSTR */
    {niv_printf(5,"","Fusion","Stockage du premier enreg de TUFSTR\n");
     CPY(s_TUFSTR.prefix[0],zo_wtufstr.prefix);
     CPY(s_TUFSTR.tufufon[0],zo_wtufstr.tufufon);
     CPY(s_TUFSTR.tdatdeb[0],zo_wtufstr.tdatdeb);
     CPY(s_TUFSTR.typnom[0],zo_wtufstr.typnom);
     CPY(s_TUFSTR.coddif[0],zo_wtufstr.coddif);
     CPY(s_TUFSTR.codhop[0],zo_wtufstr.codhop);
     CPY(s_TUFSTR.tdatfin[0],zo_wtufstr.tdatfin);
     CPY(s_TUFSTR.tdatmaj[0],zo_wtufstr.tdatmaj);
     CPY(s_TUFSTR.torimaj[0],zo_wtufstr.torimaj);
     zo_wtufstr.tmesure=s_TUFSTR.tmesure[0];
     CPY(s_TUFSTR.tuftuti[0],zo_wtufstr.tuftuti);
     CPY(s_TUFSTR.tuflibs[0],zo_wtufstr.tuflibs);
     CPY(s_TUFSTR.tuflibc[0],zo_wtufstr.tuflibc);
     CPY(s_TUFSTR.tuflibl[0],zo_wtufstr.tuflibl);
     CPY(s_TUFSTR.tufdcor[0],zo_wtufstr.tufdcor);
     CPY(s_TUFSTR.tufetab[0],zo_wtufstr.tufetab);
     CPY(s_TUFSTR.tufcges[0],zo_wtufstr.tufcges);
     CPY(s_TUFSTR.tuflbud[0],zo_wtufstr.tuflbud);
     CPY(s_TUFSTR.tuftact[0],zo_wtufstr.tuftact);
     CPY(s_TUFSTR.tufdisc[0],zo_wtufstr.tufdisc);
     CPY(s_TUFSTR.tufstar[0],zo_wtufstr.tufstar);
     CPY(s_TUFSTR.tufspsy[0],zo_wtufstr.tufspsy);
     CPY(s_TUFSTR.tuffede[0],zo_wtufstr.tuffede);
     CPY(s_TUFSTR.tufdept[0],zo_wtufstr.tufdept);
     CPY(s_TUFSTR.tufcres[0],zo_wtufstr.tufcres);
     CPY(s_TUFSTR.tufserv[0],zo_wtufstr.tufserv);
     CPY(s_TUFSTR.tufsana[0],zo_wtufstr.tufsana);
     CPY(s_TUFSTR.tufcact[0],zo_wtufstr.tufcact);
     CPY(s_TUFSTR.tufsprv[0],zo_wtufstr.tufsprv);
     CPY(s_TUFSTR.tufumed[0],zo_wtufstr.tufumed);
 
 
     niv_printf(5,"","Fusion","Fin du Stockage du premier enreg de TUFSTR\n");
 
     niv_printf(5,"","Fusion","Début de l'appareillage\n");  
 
 
   for (i=1;i<=s_TUFSTR.nb_enr;i++)
   {/* Test d'égalité sauf sur TDATDEB, TDATFIN et TDATMAJ*/
        niv_printf(5,"","Fusion","Appareillage sur la donnée [%d]\n",i);  
        if ((strcmp(s_TUFSTR.prefix[i],zo_wtufstr.prefix)==0) &&
        (strcmp(s_TUFSTR.tufufon[i],zo_wtufstr.tufufon)==0) &&
        (strcmp(s_TUFSTR.typnom[i],zo_wtufstr.typnom)==0) &&
        (strcmp(s_TUFSTR.coddif[i],zo_wtufstr.coddif)==0) &&
        (strcmp(s_TUFSTR.codhop[i],zo_wtufstr.codhop)==0) &&
        (strcmp(s_TUFSTR.torimaj[i],zo_wtufstr.torimaj)==0) &&
        (s_TUFSTR.tmesure[i]==zo_wtufstr.tmesure) &&
        (strcmp(s_TUFSTR.tuftuti[i],zo_wtufstr.tuftuti)==0) &&
        (strcmp(s_TUFSTR.tuflibs[i],zo_wtufstr.tuflibs)==0) &&
        (strcmp(s_TUFSTR.tuflibc[i],zo_wtufstr.tuflibc)==0) &&
        (strcmp(s_TUFSTR.tuflibl[i],zo_wtufstr.tuflibl)==0) &&
        (strcmp(s_TUFSTR.tufdcor[i],zo_wtufstr.tufdcor)==0) &&
        (strcmp(s_TUFSTR.tufetab[i],zo_wtufstr.tufetab)==0) &&
        (strcmp(s_TUFSTR.tufcges[i],zo_wtufstr.tufcges)==0) &&
        (strcmp(s_TUFSTR.tuflbud[i],zo_wtufstr.tuflbud)==0) &&
        (strcmp(s_TUFSTR.tuftact[i],zo_wtufstr.tuftact)==0) &&
        (strcmp(s_TUFSTR.tufdisc[i],zo_wtufstr.tufdisc)==0) &&
        (strcmp(s_TUFSTR.tufstar[i],zo_wtufstr.tufstar)==0) &&
        (strcmp(s_TUFSTR.tufspsy[i],zo_wtufstr.tufspsy)==0) &&
        (strcmp(s_TUFSTR.tuffede[i],zo_wtufstr.tuffede)==0) &&
        (strcmp(s_TUFSTR.tufdept[i],zo_wtufstr.tufdept)==0) &&
        (strcmp(s_TUFSTR.tufcres[i],zo_wtufstr.tufcres)==0) &&
        (strcmp(s_TUFSTR.tufserv[i],zo_wtufstr.tufserv)==0) &&
        (strcmp(s_TUFSTR.tufsana[i],zo_wtufstr.tufsana)==0) &&
        (strcmp(s_TUFSTR.tufcact[i],zo_wtufstr.tufcact)==0) &&
        (strcmp(s_TUFSTR.tufsprv[i],zo_wtufstr.tufsprv)==0) &&
        (strcmp(s_TUFSTR.tufumed[i],zo_wtufstr.tufumed)==0))     
        {
          /* on a égalité, on test le chevauchement entre la       */
          /* date de début de TUFSTR et la date de fin de WTUFSTR  */      
          /* Si chevauchement ou égalité alors on fusionne dans    */ 
          /* WTUFSTR en faisant une MAJ de la ligne                */
          /* Si on n'a pas de Chevauchement on insère dans WTUFSTR */
          if (strcmp(s_TUFSTR.tdatdeb[i],zo_wtufstr.tdatfin)<0 ||
              strcmp(s_TUFSTR.tdatdeb[i],zo_wtufstr.tdatfin)==0)
 
              /* reste le test où DatDeb = DatFin + 1 jour */
 
              {/*Nous avons ici Chevauchement ou égalité */
               /* on met à jour les dates dans la tempo  */
               CPY(s_TUFSTR.tdatfin[i],zo_wtufstr.tdatfin);                                     
              } 
          else
              {/* on insert l'enregistrement car non chevauchement */
               ret = INS_WTUFSTR(zo_wtufstr);
               /* on met dans la tempo ce qu'on vient de lire */
               CPY(s_TUFSTR.prefix[i],zo_wtufstr.prefix);
               CPY(s_TUFSTR.tufufon[i],zo_wtufstr.tufufon);
               CPY(s_TUFSTR.tdatdeb[i],zo_wtufstr.tdatdeb);
               CPY(s_TUFSTR.typnom[i],zo_wtufstr.typnom);  
               CPY(s_TUFSTR.coddif[i],zo_wtufstr.coddif);  
               CPY(s_TUFSTR.codhop[i],zo_wtufstr.codhop);  
               CPY(s_TUFSTR.tdatfin[i],zo_wtufstr.tdatfin);
               CPY(s_TUFSTR.tdatmaj[i],zo_wtufstr.tdatmaj);
               CPY(s_TUFSTR.torimaj[i],zo_wtufstr.torimaj);
               zo_wtufstr.tmesure=s_TUFSTR.tmesure[i];     
               CPY(s_TUFSTR.tuftuti[i],zo_wtufstr.tuftuti);
               CPY(s_TUFSTR.tuflibs[i],zo_wtufstr.tuflibs);
               CPY(s_TUFSTR.tuflibc[i],zo_wtufstr.tuflibc);
               CPY(s_TUFSTR.tuflibl[i],zo_wtufstr.tuflibl);
               CPY(s_TUFSTR.tufdcor[i],zo_wtufstr.tufdcor);
               CPY(s_TUFSTR.tufetab[i],zo_wtufstr.tufetab);
               CPY(s_TUFSTR.tufcges[i],zo_wtufstr.tufcges);
               CPY(s_TUFSTR.tuflbud[i],zo_wtufstr.tuflbud);
               CPY(s_TUFSTR.tuftact[i],zo_wtufstr.tuftact);
               CPY(s_TUFSTR.tufdisc[i],zo_wtufstr.tufdisc);
               CPY(s_TUFSTR.tufstar[i],zo_wtufstr.tufstar);
               CPY(s_TUFSTR.tufspsy[i],zo_wtufstr.tufspsy);
               CPY(s_TUFSTR.tuffede[i],zo_wtufstr.tuffede);
               CPY(s_TUFSTR.tufdept[i],zo_wtufstr.tufdept);
               CPY(s_TUFSTR.tufcres[i],zo_wtufstr.tufcres);
               CPY(s_TUFSTR.tufserv[i],zo_wtufstr.tufserv);
               CPY(s_TUFSTR.tufsana[i],zo_wtufstr.tufsana);
               CPY(s_TUFSTR.tufcact[i],zo_wtufstr.tufcact);
               CPY(s_TUFSTR.tufsprv[i],zo_wtufstr.tufsprv);
 
 
              }     
        } 
        else
          /* pas d'égalité, on insère la ligne dans WTUFSTR */    
        {
          ret = INS_WTUFSTR(zo_wtufstr);
          /* on met dans la tempo ce qu'on vient de lire */
          CPY(s_TUFSTR.prefix[i],zo_wtufstr.prefix);
          CPY(s_TUFSTR.tufufon[i],zo_wtufstr.tufufon);
          CPY(s_TUFSTR.tdatdeb[i],zo_wtufstr.tdatdeb);
          CPY(s_TUFSTR.typnom[i],zo_wtufstr.typnom);  
          CPY(s_TUFSTR.coddif[i],zo_wtufstr.coddif);  
          CPY(s_TUFSTR.codhop[i],zo_wtufstr.codhop);  
          CPY(s_TUFSTR.tdatfin[i],zo_wtufstr.tdatfin);
          CPY(s_TUFSTR.tdatmaj[i],zo_wtufstr.tdatmaj);
          CPY(s_TUFSTR.torimaj[i],zo_wtufstr.torimaj);
          zo_wtufstr.tmesure=s_TUFSTR.tmesure[i];     
          CPY(s_TUFSTR.tuftuti[i],zo_wtufstr.tuftuti);
          CPY(s_TUFSTR.tuflibs[i],zo_wtufstr.tuflibs);
          CPY(s_TUFSTR.tuflibc[i],zo_wtufstr.tuflibc); 
          CPY(s_TUFSTR.tuflibl[i],zo_wtufstr.tuflibl);
          CPY(s_TUFSTR.tufdcor[i],zo_wtufstr.tufdcor);
          CPY(s_TUFSTR.tufetab[i],zo_wtufstr.tufetab);
          CPY(s_TUFSTR.tufcges[i],zo_wtufstr.tufcges);
          CPY(s_TUFSTR.tuflbud[i],zo_wtufstr.tuflbud);
          CPY(s_TUFSTR.tuftact[i],zo_wtufstr.tuftact);
          CPY(s_TUFSTR.tufdisc[i],zo_wtufstr.tufdisc);
          CPY(s_TUFSTR.tufstar[i],zo_wtufstr.tufstar);
          CPY(s_TUFSTR.tufspsy[i],zo_wtufstr.tufspsy);
          CPY(s_TUFSTR.tuffede[i],zo_wtufstr.tuffede);
          CPY(s_TUFSTR.tufdept[i],zo_wtufstr.tufdept);
          CPY(s_TUFSTR.tufcres[i],zo_wtufstr.tufcres);
          CPY(s_TUFSTR.tufserv[i],zo_wtufstr.tufserv);
          CPY(s_TUFSTR.tufsana[i],zo_wtufstr.tufsana);
          CPY(s_TUFSTR.tufcact[i],zo_wtufstr.tufcact);
          CPY(s_TUFSTR.tufsprv[i],zo_wtufstr.tufsprv);
 
 
        }
 
      }  
      niv_printf(3,"","Fusion","Fin de l'appareillage\n");
      /* On vide TUFSTRE avant d'y intégrer WTUFSTR            */
      ret = DEL_TUFSTR();     
 
      /* On recopie ce qu'on a dans WTUFSTR dans TUFSTR        */
      /* on relit WTUFSTR au préalable                         */
      /* on passe en paramètre de l'insertion les données de   */
      /* WTUFSTR                                               */
      ret = LIRE_WTUFSTR(&s_WTUFSTR);
      ret = INS_TUFSTR(s_WTUFSTR); 
 
      /* On vide WTUFSTR pour laisser la Base propre           */
      /*ret = DEL_WTUFSTR(); */
    }
   fin_fct ("Fusion",4);
}
 
/* -------------------------------- */
/* Programme principal              */
/* -------------------------------- */
void main()
{
/* Lecture dans l'environnement du niveau de débuggage */
   niveau = atoi (getenv ("FIPNIV"));
/* Initialisation du niveau d'indentation */
   d_niv_indentation = 0;
/* Lecture dans l'environnement du code hopital */
   RAZ(genfile);
   sprintf (genfile    , "%s", getenv("FIPFILE"));
 
/* ----------------------------- */
/* Ouverture du fichier de trace */
/* ----------------------------- */
   if( !(debug_file=fopen(genfile,"at") ) )
   {
      fprintf(stderr,"Ouverture Fichier '%s' RESULTAT Impossible\n",genfile);
      fprintf(stderr,"Faire un EXPORT FIPFILE=chemin/nom\n");
      fin_traitement(0);
   } 
 
   debut_fct ("Programme Principal",4);
   /* ----------------------------- */
   /* Connection à la base ORACLE   */
   /* ----------------------------- */
   niv_printf(3,"","Fusion","Connexion à la base\n");
   fConnect();
 
   fusion ();
   fin_fct ("Programme Principal",4);
 }

**souviron34** · 18/03/2009, 11h17

déjà on s'arrête là :

Code :

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

1
2
3
 
void fusion ()
{

n'est pas une déclaration valide...

Ce serait :

Code :

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

1
2
void fusion ( void )
{

**pmboutteau** · 18/03/2009, 11h25

et ça peut expliquer le dump?

**souviron34** · 18/03/2009, 11h41

pas forcément, mais ça ne rend pas la lecture plus facile, d'autant plus que ce n'est pas le seul endroit :

Code :

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

1
2
3
4
5
6
void main()
{
...
   if( !(debug_file=fopen(genfile,"at") ) )
...
}

devrait être

Code :

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

1
2
3
4
5
6
7
int main ( void )
{
...
   if( (debug_file=fopen(genfile,"at") ) == NULL  )
...
  return EXIT_SUCCESS ;
}

etc etc...

D'autre part, il serait bon que tu isoles pour nous un peu mieux là où ça plante..

Tu peux pas debugger un peu toi-même ? mettre des fprintf(syderr ou quelque chose ?

Parce que là de toutes façons on ne peut pas reproduire..Faut SQL, la base, etc etc..

**pmboutteau** · 18/03/2009, 11h51

J'ai un fichier de trace qui se remplit via les nivprintf et debut_fct, fin_fct.

Quand ça tourne bien, ma trace se remplit.

Quand j'ai le core dumped ça plante dès fusion.

Code :

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

1
2
3
4
5
[4];[      ];[Programme Principal                     ];   Debut fonction : Programme Principal 
[3];[      ];[Fusion                                  ];      Connexion à la base
[5];[      ];[connect.pc :fConnect                    ];         Debut fonction : connect.pc :fConnect 
[3];[      ];[connect.pc :fConnect                    ];            Connexion à la base réussie
[5];[      ];[connect.pc :fConnect                    ];         Fin fonction : connect.pc :fConnect

Même quand je mets une trace juste au début de fusion, il ne m'affiche rien. Il plante dans l'appel on dirait.

**souviron34** · 18/03/2009, 11h57

déjà être conforme à la norme C de déclaration des fonctions ne ferait pas de mal : passage de paramètres (même vides) et type.

Ensuite, tu es conscient que ce n'est qu'en C99 qu'on a le droit de mettre des instructions avant des déclarations ( des print par exemple ? ). Compiles-tu en C99 ?

**souviron34** · 18/03/2009, 11h59

Envoyé par pmboutteau

Code :

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

1
2
3
4
[4];[      ];[Programme Principal                     ];   Debut fonction : Programme Principal 
[3];[      ];[Fusion                                  ];      Connexion à la base[5];[      ];[connect.pc :fConnect                    ];         Debut fonction : connect.pc :fConnect 
[3];[      ];[connect.pc :fConnect                    ];            Connexion à la base réussie
[5];[      ];[connect.pc :fConnect                    ];         Fin fonction : connect.pc :fConnect

et ça, ça veut pas dire qu'il rentre dans fusion ??

**pmboutteau** · 18/03/2009, 13h32

Nom c'est une chaine que je lui ai passé. Donc on est toujours avant l'appel de fusion dans le main.

En ce qui concerne le C99, je ne sais pas.

**souviron34** · 18/03/2009, 14h40

alors

suit déjà la norme pour les appels / déclarations de fonctions.
met tes printf après les déclarations de variables
utilises plutôt fprintf ( stderr, ... ), qui est synchrone, que printf, qui n'est pas synchrone

Et reviens nous dire après où tu en es..

**pmboutteau** · 18/03/2009, 14h46

ok merci pour les tuyaux.

Là je suis sur un autre projet mais quand je reviens dessus ,je le normaliserai et je vous dirai quoi.

**LittleWhite** · 19/03/2009, 00h49

Envoyé par souviron34

déjà on s'arrête là :

Code :

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

1
2
3
 
void fusion ()
{

n'est pas une déclaration valide...

Ce serait :

Code :

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

1
2
void fusion ( void )
{

Je ne vois pas en quoi ce n'est pas valide.
Même un compilateur avec tout warnings activés et autre pedantic et -ansi, il ne renvoit pas d'erreur.
Après, pour la visibilité, je suis plutot d'accord, le void est préférable, quoique , c'est quelque chose que tout le monde sait ( ) équivalent à (void)

**souviron34** · 19/03/2009, 00h54

Envoyé par LittleWhite

Je ne vois pas en quoi ce n'est pas valide.
Même un compilateur avec tout warnings activés et autre pedantic et -ansi, il ne renvoit pas d'erreur.
Après, pour la visibilité, je suis plutot d'accord, le void est préférable, quoique , c'est quelque chose que tout le monde sait ( ) équivalent à (void)

c'est vrai pour l'appel..

Pas pour la déclaration...

(comme int main (void) et non int main() )

**Médinoc** · 19/03/2009, 11h01

Souviron,

Bien que mon opinion soit la même que la tienne sur ce sujet (je mets systématiquement le void),
J'ai lu plusieurs fois sur ce forum que dans la définition, void fusion() était équivalent à void fusion(void), et que la différence n'était présente que dans la déclaration.

**souviron34** · 19/03/2009, 11h24

quelle différence fais-tu entre définition et déclaration ??

La définition serait ce qu'il y a dans le fichier d'entête ?

**Médinoc** · 19/03/2009, 11h33

Ben non, l'inverse: La définition, c'est quand il y a le corps de la fonction avec.

En gros, d'après ce que j'ai lu ici, ces deux lignes seraient fonctionnellement identiques:

Code C :

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

1
2
3
4
5
6
/* impl_toto.c */
int toto() { return 42; }
 
/*ou*/
 
int toto(void) { return 42; }

Mais pas celles-ci:

Code C :

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

1
2
3
4
5
6
/* toto.h */
int toto();
 
/*ou*/
 
int toto(void);

PS: Note qu'on est tous d'accord sur le sujet que les déclarations du second code ne font PAS la même chose. C'est au sujet du premier code qu'il y a divergence d'opinion.

**souviron34** · 19/03/2009, 11h50

je pense que si tu compiles avec le flag -Wstrict_prototypes tu te feras jeter...

**Médinoc** · 19/03/2009, 14h30

Je viens de tester, et tu as raison: gcc me jette.

Au passage, je viens de voir à quel point MinGW sux:
Si je compile en -Wall -Wextra -pedantic, j'ai des erreurs sur les long long (-Wno-long-long les désactive) et sur les fichiers d'en-tête standard (qui contiennent une directive #include_next)
Edit: OK, un petit -Wno-system-headers corrige le truc.
C'est toujours mieux que les missing initializers, qui dans la version 3.4.2, sont compris dans -Wextra mais pas désactivables...
Edit2: Ah, ben non en fait. Il n'avait pas recompilé. -Wno-system-headers ne change rien du tout...
Edit3: OK, en fait les headers système n'étaient pas déclarés en tant que tel, ce qui est désormais corrigé.

**pmboutteau** · 25/03/2009, 10h54

Me revoilà sur le sujet.

J'ai épuré au maximum le code et voici quand le core se déclenche. Dès que je mets le if avec le strcmp.

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
int fusion ()
{
   /* Variables diverses pour les boucles et les resultat de fonctions */
   int ret;
   int i,j;
   i=0;
   j=0;
 
   /*Structure contenant TUFSTR avant fusion */
   struct TUFSTR_LECT s_TUFSTR;
   /*Structure contenant TUFSTR après fusion */
   struct TUFSTR_LECT s_WTUFSTR;
 
   debut_fct ("Fusion",4);
 
   /* On vide WTUFSTR par précaution */
   ret = DEL_WTUFSTR();  
 
   /* Lecture de TUFSTR plus stockage dans la structure */  
   ret = LIRE_TUFSTR(&s_TUFSTR);
 
   /* boucle de lecture sur la structure TUFSTR */
   /* si Appareillage avec WTUFSTR => Test sur les périodes */
   /* Suivant le test on insère ou on MAJ WTUFSTR */
   /* Si non Appareillage on insère WTUFSTR */ 
 
   if (s_TUFSTR.nb_enr != -1)
   {
   /* on a au moins une donnée dans TUFSTR */
   /* Recopie du rang 0 de s_TUFSTR dans le rang 0 de s_WTUFSTR */
   niv_printf(5,"","Fusion","Rang initial de l'appareillage\n"); 
 
   niv_printf(5,"","Fusion","Début de l'appareillage\n");  
    for (i=0;i<=s_TUFSTR.nb_enr;i++)
      {niv_printf(5,"","Fusion","Appareillage sur la donnée [%d]\n",i);  
       if (strcmp(s_TUFSTR.prefix[i],s_WTUFSTR.prefix[j])==0)
       {
       /* Egalité => Test le chevauchement entre la */
        /* date de début de s_TUFSTR[i] et */
        /* la date de fin de s_WTUFSTR[j]  */      
        /* Si chevauchement ou égalité ou datedeb=datfin+1 jours */
        /* alors on fusionne en faisant une MAJ de [j] avec [i] */
        /* Si on n'a pas de Chevauchement */ 
        /* Ecriture dans j+1 */
        niv_printf(3,"","Fusion","Test des Dates\n");
       }/*
       else
       {*/
       /* Pas Egalité, Ecriture dans j+1*/
        niv_printf(3,"","Fusion","Pas d'égalité\n");
       /*}*/
       niv_printf(3,"","Fusion","Fin de l'appareillage\n");
      }    
   }
   fin_fct ("Fusion",4);
   return(1);
}

Problème de Core dumped, Memory Fault

C

Discussions similaires

Partager

Partager