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