0024284: Some trivial warnings produced by ICC 14
[occt.git] / src / StepFile / recfile.pc
1 /* 
2  Copyright (c) 1999-2012 OPEN CASCADE SAS
3
4  The content of this file is subject to the Open CASCADE Technology Public
5  License Version 6.5 (the "License"). You may not use the content of this file
6  except in compliance with the License. Please obtain a copy of the License
7  at http://www.opencascade.org and read it completely before using this file.
8
9  The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10  main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11
12  The Original Code and all software distributed under the License is
13  distributed on an "AS IS" basis, without warranty of any kind, and the
14  Initial Developer hereby disclaims all such warranties, including without
15  limitation, any warranties of merchantability, fitness for a particular
16  purpose or non-infringement. Please see the License for the specific terms
17  and conditions governing the rights and limitations under the License.
18
19 */ 
20
21 #include "stdio.h"
22 #include "string.h"
23 #include "stdlib.h"
24 #if defined(HAVE_MALLOC_H)
25 #include "malloc.h"
26 #endif
27 #include "recfile.ph" 
28 /*  enregistrement d'un fichier d'interface sous forme de records
29     gere les scopes
30
31     Ce fichier comprend 3 parties
32     - les routines traitant les char*, avec la notion de texte courant
33     - les declarations des donnees de travail proprement dites pour le fichier
34     - le corps des programmes d'enregistrement
35 */
36
37
38 /*           ROUTINES UTILITAIRES de traitement des textes (char*)          */
39
40 /*     Gestion du texte courant : c'est un texte alloue dynamiquement
41        rec_restext en alloue un (jete le precedent alloue si pas lu)
42        rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
43        rec_settext en force un autre en jetant le precedent (idem rec_newtext)
44        tandis que rec_newtext alloue un texte, sans lien avec le courant
45 */
46
47 #define Maxcar 50000
48
49   static struct carpage {
50     struct carpage* next;        /*  chainage des pages de caracteres  */
51     int             used;        /*  place deja prise  */
52     char  cars[Maxcar+1];        /*  page de caracteres  */
53   } *onecarpage;
54
55   static char* restext = NULL ;  /* texte courant  (allocation dynamique) */
56   /* static int   resalloc = 0 ;*/    /*   alloue (memoire a liberer) ou non   */
57
58 static char txt_cart_p[]   = "CARTESIAN_POINT";
59
60 void rec_restext(char* newtext, int lentext)         /* destine a etre appele de l'exterieur */
61 {
62   char *res, *text;
63   if(strcmp(newtext,txt_cart_p)==0) {
64     restext = txt_cart_p;
65     return;
66   }
67   
68   if (onecarpage->used > Maxcar-lentext-1) {   /* allouer nouvelle page */
69     struct carpage *newpage;
70     int sizepage = sizeof(struct carpage);
71     if (lentext >= Maxcar) sizepage += (lentext+1 - Maxcar);
72     newpage = (struct carpage*) malloc (sizepage);
73     newpage->next = onecarpage;
74     onecarpage = newpage;
75     onecarpage->used = 0;
76   }
77   restext  = onecarpage->cars + onecarpage->used;
78   onecarpage->used += (lentext + 1);
79 /*   strcpy   */
80   res = restext ; text = newtext;
81   while (*text != '\0') { *res=*text ; res++ ; text++ ; }
82   *res = '\0' ;
83 }
84
85 void rec_gettext(char* *r)
86 /*  Le resultat retourne (pointeur) est destine a etre inclus dans un struct */
87 { *r = restext; }
88
89 void rec_settext(char* s)
90 /* substituer le texte courant par un autre deja alloue */
91 {  restext = s ;  }
92
93 char* rec_newtext(char* r)
94 /*  routine utilitaire creant une chaine dynamique a partir d'un char[]  */
95 {
96   char* savrestext;
97   char* s0;
98   savrestext = restext;
99   rec_restext(r,(int)strlen(r));
100   s0 = restext;
101   restext = savrestext;
102   return (s0);
103 }
104
105
106
107 static int modeprint = 0 ;  /* CONTROLE D'IMPRESSION (pour appel depuis yacc)*/
108
109 /*      DECLARATIONS des donnees de travail (en cours d'enregistrement)     */
110
111 static int  typarg ;       /* type du dernier argument lu */
112 static int  nbrec  = 0;    /* nombre total d'enregistrements de donnees */
113 static int  nbhead = 0;    /* nb de records pris par le Header */
114 static int  nbpar  = 0;    /* nb de parametres lus au total */
115 static int  yarec  = 0;    /* presence Record deja cree (1 apres Ident) */
116
117 static struct rec {          /*  DESCRIPTION D'UN RECORD  */
118   char* ident ;       /* identifieur du record  (en #12345...) ou scope-end */
119   char* type  ;       /* type du record  (peut etre sublist) */
120 /*  int nbarg ;          nombre de parametres (arguments) du record, not used */
121   struct unarg* first ;  /* 1er argument */
122 /*  struct unarg* last  ;dernier argument, not used */
123   struct rec*   next  ;  /* record suivant */
124 }  *currec ;           /* currec meme : record courant */
125
126 #define Maxrec 5000
127 static struct recpage {
128   struct recpage*  next;
129   int              used;
130   struct rec       args[Maxrec+1];
131 } *onerecpage;
132
133 static struct rec* firstrec ;  /* 1er record du fichier */
134 static struct rec* lastrec  ;  /* dernier record du fichier */
135
136 static char* curtype;          /* type dernier record (ou = sublist) */
137 static char* subarg ;          /* ident dernier record (sub-list eventuel) */
138 static int   numsub ;          /* numero de sous-liste en cours */
139
140
141 static struct unarg {          /*  DESCRIPTION D'UN ARGUMENT  */
142   int type ;     /* type de l'arg, dans une liste courte : entier, reel ... */
143   char* val ;    /* valeur alphanum de l'arg */
144   struct unarg* next ;  /* argument suivant dans la liste pour ce record */
145 }  *curarg ;
146
147 #define Maxarg 10000
148 static struct argpage {        /*  Allocation optimisee des arguments  */
149   struct argpage*  next;
150   int              used;
151   struct unarg     args[Maxarg+1];
152 } *oneargpage;
153
154
155 static struct scope {          /*  DESCRIPTION D'UN SCOPE  */
156                         /* les scopes sont empilables sans limite */
157   struct scope* prev;   /* scope precedent, auquel il faudra revenir */
158   struct rec*   rec;    /* record interrompu par le scope (a reprendre) */
159 }   *curscope ;         /*  curscope est le scope en cours */
160
161
162 /*               Constantes litterales               */
163 static char txt_sublist[]  = "/* (SUB) */" ;
164 static char txt_scope[]    = "SCOPE" ;
165 static char txt_endscope[] = "ENDSCOPE" ;
166 static char txt_nil[]      = " " ;
167 static char sub1[]         = "$1" ;  /* optimisation ... */
168 static char sub2[]         = "$2" ;
169 static char argtype1[] = "(IF#TnEHBx";  /* types arguments (2 1es lettres) */
170 static char argtype2[] = ")nlIxdnxix";
171 static char idzero[]   = "#0";
172
173
174 /*              Trace pour controle            */
175 void recfile_modeprint(int mode)
176 {  modeprint = mode;  }
177
178 static int   lastno;
179 extern int   steplineno;
180 extern int   modcom;
181 extern int   modend;
182
183 void rec_inityyll ()
184 {  
185   steplineno = 0;
186   modcom = 0;
187   modend = 0;
188   lastno = -1;
189 }
190
191
192 /*   INITIALISATION   */
193
194 void rec_debfile()
195 {
196   /*initialization of recpage*/
197   onerecpage = (struct recpage*) malloc ( sizeof(struct recpage) );
198   onerecpage->used = 0; onerecpage->next = NULL;
199
200   onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
201   onecarpage->used = 0; onecarpage->next = NULL;  restext = NULL;
202   yarec = 0;  nbhead = nbrec = nbpar = 0 ; firstrec = NULL ; lastrec = NULL ;
203   curtype = txt_sublist;
204   currec = NULL ; curarg = NULL ;
205   curscope = NULL ;
206   oneargpage = (struct argpage*) malloc ( sizeof(struct argpage) );
207   oneargpage->next = NULL; oneargpage->used = 0;
208   rec_inityyll();
209 }
210
211 /*   INTERMEDIAIRE : passage de Header a Data    */
212 void rec_finhead()  {  nbhead = nbrec;  }
213
214 /*   CONCLUSION  :  actuellement, ne fait rien   */
215
216 void rec_finfile()  {  }
217
218
219 /*   GESTION DES RECORDS   */
220
221 /*   ENREGISTRER UN RECORD (deja pret)    */
222 static void rec_new(struct rec* newrec)
223 /*  nouveau record a enregistrer  */
224 {
225  nbrec ++ ;
226  if ( firstrec == NULL ) firstrec = newrec ;
227  if ( lastrec  != NULL ) lastrec->next = newrec ;
228  lastrec = newrec ;
229 }
230
231 /*  type du dernier argument lu  */
232 void rec_typarg(int argtype)
233 {  typarg = argtype;  }
234
235 /*   ENREGISTRER UNE ENTITE (record courant)   */
236 void rec_newent()
237 {
238  rec_new(currec) ;     /*  le record courant (currec) est enregistre  */
239
240 /*  gestion des sous-listes : si currec a un suivant note (cf pointeur suite),
241     alors c'est une sous-liste et le suivant est son contenant
242     EN CE CAS, il faut memoriser cette sous-liste en argument courant
243     En effet, d'une part la liste est reconnue comme un argument, d'autre part
244     part elle se termine par ")" : c'est donc ici qu'elle sera enregistree */
245
246  rec_typarg (rec_argSub) ;
247
248  subarg = currec->ident ;      /* si sous-liste, sera argument du contenant */
249 /*                          rec_check(1) ;    */
250  currec = currec->next ;       /* si nul, c'est qu'une autre entite suit */
251  lastrec->next = NULL ;
252 }
253
254
255 static struct rec*rec_newrec()
256 {
257   struct rec* newrec;
258   if (onerecpage->used >= Maxrec) {
259     struct recpage* newrecpage;
260     newrecpage = (struct recpage*) malloc ( sizeof (struct recpage) );
261     newrecpage->next = onerecpage;
262     onerecpage = newrecpage;
263     onerecpage->used = 0;
264   }
265   newrec = &(onerecpage->args[onerecpage->used]);
266   onerecpage->used++;
267
268   return newrec;
269 }
270
271
272 /*   RECORD COURANT :   */
273
274 /*   creer et preciser l'identifieur   */
275 void rec_ident()
276 {
277   currec = rec_newrec();
278   /*currec = (struct rec*) malloc (sizeof (struct rec)) ;*/
279   /*currec->nbarg = 0 ;*/
280   rec_gettext(&(currec->ident)) ;
281   currec->next = NULL ; currec->first = NULL ; /*currec->last = NULL ;*/
282   yarec = 1;
283 }
284
285 /*   preciser le type ; demarrage de la description de l'entite  */
286 void rec_type()
287 {
288 /* Pour le header : pas d'ident, donc en simuler un : derive de rec_ident */
289   if (!yarec) {
290     /*currec = (struct rec*) malloc (sizeof (struct rec)) ;*/
291     currec = rec_newrec();
292     /*currec->nbarg = 0 ;*/
293     currec->ident = idzero;  /* Ident bidon (il en faut un ...) */
294     currec->next = NULL ; currec->first = NULL ; /*currec->last = NULL ;*/
295   }
296   rec_gettext(&(currec->type)) ;
297   yarec = numsub = 0 ;      /* debut de l'entite */
298 }
299
300 /*  type d une liste qui n est pas une entite mais un argument
301     par defaut (cf rec_deblist) il n est pas defini donc mis = "/ (SUB) /" */
302 void rec_listype()
303 {  rec_gettext(&(curtype));  }
304
305 /*  ajouter un argument (type & valeur deja connus) */
306 void rec_newarg()
307 {
308   struct unarg *newarg;
309   nbpar ++;
310   /*currec->nbarg ++ ;*/
311 /*  newarg = (struct unarg*) malloc (sizeof (struct unarg)) ;  */
312   if (oneargpage->used >= Maxarg) {
313     struct argpage* newargpage;
314     newargpage = (struct argpage*) malloc ( sizeof(struct argpage) );
315     newargpage->next = oneargpage;
316     oneargpage = newargpage;
317     oneargpage->used = 0;
318   }
319   newarg = &(oneargpage->args[oneargpage->used]);
320   oneargpage->used ++;
321
322   newarg->type = typarg ;
323   if (typarg == rec_argSub) newarg->val = subarg ;
324   else rec_gettext (&(newarg->val));
325
326 /*  if (currec->first == NULL) currec->first = newarg;
327   else currec->last->next = newarg;
328   currec->last = newarg;*/
329   if (currec->first == NULL) currec->first = newarg;
330   else {
331     struct unarg* nextarg = currec->first;
332     while(nextarg->next != NULL)
333       nextarg = nextarg->next;
334     nextarg->next = newarg;
335
336   }
337   newarg->next = NULL ;
338 /*                          rec_check(0) ;    */
339 }
340
341 /*   Ajouter une sous-liste
342
343      Une ouverture de parentheses A L'INTERIEUR d'une liste de parametres
344      signale une sous-liste : c'est une entite non identifiee, directement
345      utilisee comme argument de la liste contenante) d'un type reserve(SUB)
346
347      Elle est enregistree avec un identifieur special : '$' suivi d'un numero
348      de sous-liste dans l'entite en cours.
349
350      Son enregistrement consiste a definir un nouveau record courant, pour la
351      sous-liste, qui note comme suivant l'ancien courant, qui est son contenant
352      A la fin de la sous-liste, elle est enregistree comme toute entite (cf
353      rec_new) mais le suivant devient le nouveau courant dont l'enregistrement
354      des parametres continue
355
356      La premiere ouverture de parentheses dans l'entite est celle de la liste
357      principale de parametres et non d'une sous-liste
358 */
359
360 void rec_deblist()
361 {
362  if (numsub > 0) {            /* enregistrement d'une sous-liste */
363   /* int i ; */ struct rec* subrec ;
364     /* creation du nouvel enregistrement et chainage au precedent */
365   subrec = rec_newrec();
366   /*subrec = (struct rec*) malloc (sizeof (struct rec)) ;*/
367   switch (numsub) {
368   case 1: subrec->ident = sub1; break;
369   case 2: subrec->ident = sub2; break;
370   default: {
371     char bufsub[10];
372     if (numsub > 9) sprintf (bufsub,"$%d",numsub) ;
373     else {  bufsub[0] = '$'; bufsub[1] = (char)(numsub + 48); bufsub[2] = '\0';  }
374     subrec->ident = rec_newtext(bufsub) ;
375     }
376   }
377   subrec->type  = curtype ;
378   curtype = txt_sublist;      /* type reserve par defaut */
379   /*subrec->nbarg = 0 ;*/ subrec->next = currec ;
380   subrec->first = NULL ; /*subrec->last = NULL ;*/
381     /* les arguments de la sous-liste vont suivre ;
382        elle meme est argument de son contenant, ce qui est pris en compte
383        a la fermeture de la parenthese */
384   currec = subrec ;           /* substitution finale */
385  }
386  numsub ++ ;   /* numero de la prochaine sous-liste (la principale est en 0) */
387 /*                          rec_check(0) ;    */
388 }
389
390
391 /*   Affichage du contenu d'un record   */
392 void rec_print(struct rec* unrec)
393 {
394  int numa = 0;  int numl = 0;  int argl = 0;
395  if (unrec == NULL) {  printf ("Non defini\n") ; return;  }
396  printf ("Ident : %s  Type : %s  Nb.Arg.s : %s\n",
397           unrec->ident,unrec->type, (unrec->first ? unrec->first->val : "")) ;
398  if (modeprint < 2) return ;
399  curarg = unrec->first ;
400  while (curarg != NULL) {
401    numa ++;
402    argl = (int)strlen(curarg->val) + 18;
403    numl += argl;
404    if (numl > 132) {  printf("\n");  numl = argl;  }
405    printf ("  - Arg.%d[%c%c] : %s",
406            numa,argtype1[curarg->type],argtype2[curarg->type],curarg->val);
407    curarg = curarg->next ;
408  }
409  if (argl > 0) printf("\n");
410  return ;
411 }
412
413 /*   GESTION DES SCOPES   */
414
415 /*  Ouverture de scope :
416   un scope est un record particulier (pas de type ni d'argument)
417   d'une part il est enregistre, d'autre part il faut gerer le record en cours
418   En effet, une entite step etait en cours d'enregistrement (ident deja connu),
419   mais son type et ses arguments seront fournis apres fermeture du scope ...
420   Il faut donc la mettre de cote (c'est currec), pour la restaurer ensuite
421
422   Mais ATTENTION, il y a l'EXPORT : au ENDSCOPE, peut etre attachee une liste
423   d'Idents : ce sont les idents internes au SCOPE mais declares visibles de
424   l'exterieur du SCOPE (en plus de l''entite sur laquelle il porte)
425 */
426
427 void scope_debut()
428 {
429 /*   ouverture du scope et sauvegarde de l'entite en cours   */
430  struct scope* newscope; struct rec* unscope;
431  newscope = (struct scope*) malloc (sizeof (struct scope)) ;
432  newscope->rec  = currec ;
433  newscope->prev = curscope ;
434  curscope = newscope ;
435
436 /*   enregistrement de ce scope comme un record   */
437  unscope = rec_newrec();
438  /*unscope = (struct rec*) malloc (sizeof (struct rec)) ;*/
439  unscope->ident = txt_scope ;
440  unscope->type  = txt_nil ;
441  unscope->first = NULL;
442  /*unscope->nbarg = 0 ;*/
443  rec_new(unscope) ;
444 }
445
446 /*   Fermeture de scope :
447    La fin de scope est, comme son debut, un enregistrement special.
448    Il faut donc l'enregistrer.
449    Il faut aussi restaurer l'entite concernee par le scope, afin de terminer
450    son enregistrement (manquent ses arguments)  */
451
452 void scope_fin()
453 { struct scope* oldscope ; struct rec* unscope;
454  if (curscope == NULL) return ;   /* cela dit, c'est anormal ... */
455
456 /*   enregistrement de cette fin de scope comme un record   */
457  unscope = rec_newrec();
458 /* unscope = (struct rec*) malloc (sizeof (struct rec)) ;*/
459  unscope->ident = txt_endscope ;
460  unscope->type  = txt_nil ;
461  unscope->first = NULL;
462  /*unscope->nbarg = 0 ;*/
463
464 /*  Si on doit prendre en compte une Export List ...  */
465  if (subarg[0] == '$') {
466    if (modeprint > 0) {
467      printf("Export List : (List in Record n0 %d) -- ",nbrec);
468      rec_print(lastrec);
469    }
470    currec = unscope;
471    typarg = rec_argSub;
472    rec_newarg();
473  }
474  rec_new(unscope) ;
475
476 /*   fermeture effective du scope   */
477  currec   = curscope->rec ;      /* restaurer l'entite en cours d'enreg. */
478  yarec    = 1;
479  oldscope = curscope ;
480  curscope = oldscope->prev ;     /*  restauration de l'etat precedent  */
481  free (oldscope) ;               /*  suppression "physique"  */
482 }
483
484
485 /*   CONCLUSION  :  retour des valeurs pour constituer la liste des records,
486                     sous forme de directory / tableau
487
488      La liberation de la memoire est faite par lir_file_fin, en une fois
489 */
490
491 void lir_file_nbr(int* nbh, int* nbr, int* nbp)
492 /*  initialise le traitement et retourne la taille du directory et du header */
493 {
494  currec = firstrec ;
495 /*                       rec_check(0) ;    */
496  *nbh = nbhead;  *nbr = nbrec;  *nbp = nbpar;
497 }
498
499 void lir_file_fin(int mode)
500 /*  fin du traitement : regroupe les liberations de memoire en une phase  */
501 /*  mode = 1 : rec+arg. 2 : carpage; 3 : 1+2  */
502 {
503   if (mode & 1) {
504     while(onerecpage != NULL) {
505       struct recpage* newpage; newpage = onerecpage->next;
506       free(onerecpage);
507       onerecpage = newpage;
508     }
509
510
511 /*    struct rec* oldrec;
512     oldrec = NULL;
513     currec = firstrec;
514     while (currec != NULL) {
515       oldrec = currec;
516       currec = currec->next;*/
517 /* liberation memoire pour type & ident : si scope-endscope rien a liberer
518    si sous-liste : type pas a liberer, ident partage aussi par l'argument sera
519    libere par lui ... donc ici aussi, rien a liberer. CQFD  */
520 /*      free (oldrec) ;
521     }*/
522     while (oneargpage != NULL) {
523       struct argpage* newpage; newpage = oneargpage->next;
524       free (oneargpage);
525       oneargpage = newpage;
526     }
527   }
528   if (mode & 2) {
529     while (onecarpage != NULL) {
530       struct carpage* newpage; newpage = onecarpage->next;
531       free (onecarpage);
532       onecarpage = newpage;
533     }
534   }
535 }
536
537 int lir_file_rec(char* *ident, char* *type, int *nbarg)
538 /*   retourne les parametres du record courant
539      retour de fonction ; 1 si ok, 0 si liste epuisee   */
540 {
541  if (currec == NULL) return (0) ;
542 /*                                   rec_check(2) ;    */
543  *ident = currec->ident ;
544  *type  = currec->type ;
545  *nbarg = (currec->first != NULL);
546  curarg = currec->first ;    /* prepare lecture arg.s */
547  return (1) ;
548 }
549
550 void lir_file_finrec()
551 /*  fait le menage et passe au record suivant
552     ne pas appeler apres l'indication de fin mais apres chaque record ok !   */
553 {
554  currec = currec->next ;
555 /*                                   rec_check(2) ;   */
556 }
557
558 int lir_file_arg(int* type, char* *val)
559 /*  lit l'argument courant (au debut le 1er), fait le menage, prepare suivant
560     retourne 1 si ok, 0 si c'est fini
561     attention, suppose que nbarg > 0 ... (bref, pas de protection)   */
562 {
563  if (curarg == NULL) return (0) ;
564  *type = curarg->type ;
565  *val  = curarg->val ;
566  curarg = curarg->next ;
567  return (1) ;
568 }
569
570
571 /*   Verification de l'integrite des donnees   */
572
573 /*   Affiche ce qui ne va pas, mais aussi accede a tout : ainsi, les adresses
574      verolees aparaissent au grand jour du dbx   */
575
576 void rec_check(int mode)
577 /* mode=1 pas de controle nbrec (en cours d'enregistrement) */
578 {
579   struct rec* lerec ; struct unarg* larg ; int nr,na ;
580   lerec = firstrec ;
581   if (mode == 2) lerec = currec ;
582   nr = 0 ;
583   while (lerec != NULL) {
584     nr ++ ;
585     if (lerec->ident == NULL) printf("Record %d : ident null\n",nr) ;
586     if (lerec->type  == NULL) printf("Record %d : type  null\n",nr) ;
587     /*if (mode < 2 && (lerec->nbarg < 0 || lerec->nbarg > 10) ) printf
588       ("N.B.: Record %d : nbarg pas entre 0 & 10, vaut %d\n",nr,lerec->nbarg);
589     */
590     na = 0 ;
591     larg = lerec->first ;
592     while (larg != NULL) {
593       na ++ ;
594       if (larg->type < 0 || larg->type > 9) printf
595         ("Record %d , Arg. %d : type incorrect : %d\n",nr,na,larg->type) ;
596       if (larg->val == NULL) printf("Record %d , Arg %d : val null\n",nr,na) ;
597       larg = larg->next ;
598     }
599     /*if (na != lerec->nbarg) printf
600       ("Record %d : arglist pourrie, nb note %d relu %d\n",nr,lerec->nbarg,na) ;*/
601     lerec = lerec->next ;
602   }
603   if (mode == 0 && nr != nbrec) printf
604     ("Liste des records pourrie, nb note %d relu %d\n",nbrec,nr) ;
605 }
606
607 void steperror (char *mess);
608 int  steplex (void);
609