37aacfac72ee2fdc7dc4c592c82b33fde85d1cb0
[occt.git] / src / IGESFile / structiges.c
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 <stdlib.h>
22 #include <string.h>
23
24 #include "igesread.h"
25
26 /*   Structures temporaires IGES (enregistrement des entites et parametres)
27      Comprennent : les declarations, et la gestion de l'entite en cours  */
28
29 static int nbparts;
30 static int nbparams;
31
32 /*                Liste de parametres IGES (header ou current part)        */
33 static struct parlist *curlist;
34 static struct parlist *starts;   /*  Start Section du fichier IGES  */
35 static struct parlist *header;   /*  Entete du fichier IGES  */
36
37
38 /*                Declaration d'une portion de Directory IGES              */
39 static struct dirpart *curp;
40
41 struct dirpart *iges_get_curp (void)
42 {
43   return curp;
44 }
45
46 /*                   Declaration d'un parametre IGES (Psect)              */
47 static struct oneparam {
48   struct oneparam *next;
49   int typarg;
50   char *parval;
51 } *curparam;
52
53 #define Maxparts 1000
54 static struct dirpage {
55   int used;
56   struct dirpage *next;
57   struct dirpart  parts[Maxparts];
58 } *firstpage = NULL;
59
60 #define Maxpar 20000
61 static struct parpage {    /* une page de parametres ; cf AddParam */
62   struct parpage* next;
63   int             used;
64   struct oneparam params[Maxpar+1];
65 } *oneparpage;
66
67
68 static int curnumpart = 0;
69 static struct dirpage *curpage;
70
71
72 /*           ROUTINES UTILITAIRES de traitement des textes (char*)          */
73
74 /*     Gestion du texte courant : c'est un texte alloue dynamiquement
75        iges_newchar en alloue un (jete le precedent alloue si pas lu)
76        rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
77        rec_settext en force un autre en jetant le precedent (idem rec_newtext)
78        tandis que rec_newtext alloue un texte, sans lien avec le courant
79 */
80
81 #define Maxcar 10000
82
83   static struct carpage {
84     struct carpage* next;        /*  chainage des pages de caracteres  */
85     int             used;        /*  place deja prise  */
86     char  cars[Maxcar+1];        /*  page de caracteres  */
87   } *onecarpage;
88
89   static char* restext = NULL ;  /* texte courant  (allocation dynamique) */
90 /*  static int   resalloc = 0 ; */    /*   alloue (memoire a liberer) ou non   */
91
92 /*    Utilitaire : Reservation de caracteres
93       Remplace suite de mini-malloc par gestion de page   */
94
95 char* iges_newchar (char* newtext, int lentext)
96 {
97   int i, lnt;
98   if ((lnt = onecarpage->used) > Maxcar-lentext-1) {  /* allouer nouvelle page */
99     struct carpage *newpage;
100     unsigned int sizepage = sizeof(struct carpage);
101     if (lentext >= Maxcar) sizepage += (lentext+1 - Maxcar);
102     newpage = (struct carpage*) malloc (sizepage);
103     newpage->next = onecarpage;
104     onecarpage = newpage;
105     lnt = onecarpage->used = 0;
106   }
107   restext  = onecarpage->cars + lnt;
108   onecarpage->used = (lnt + lentext + 1);
109 /*   strcpy   */
110   for (i = lentext-1; i >= 0; i --) restext[i] = newtext[i];
111   restext[lentext] = '\0';
112   return (restext);
113 }
114
115
116 /*             FICHIER  IGES  Proprement Dit             */
117
118 /*             Initialisation de l'enregistrement d'un fichier            */
119 void iges_initfile()
120 {
121   onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
122   onecarpage->used = 0; onecarpage->next = NULL;  restext = NULL;
123   oneparpage = (struct parpage*) malloc ( sizeof(struct parpage) );
124   oneparpage->used = 0; oneparpage->next = NULL;
125
126   starts = (struct parlist*) malloc ( sizeof(struct parlist) );
127   starts->first = starts->last = NULL; starts->nbparam = 0;
128   header = (struct parlist*) malloc ( sizeof(struct parlist) );
129   header->first = header->last = NULL; header->nbparam = 0;
130
131   curlist = starts;    /* On commence a enregistrer la start section */
132   nbparts = nbparams = 0;
133   firstpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
134   firstpage->next = NULL; firstpage->used = 0;
135   curpage = firstpage;
136 }  
137
138 /*   Passage au Header (Global Section), lecture comme ecriture    */
139 void iges_setglobal()
140 {  if (curlist == header) return;  curlist = header;    curparam = curlist->first;  }
141
142
143 /*   Definition et Selection d'un nouveau dirpart   */
144
145 void iges_newpart(int numsec)
146 {
147   if (curpage->used >= Maxparts) {
148     struct dirpage* newpage;
149     newpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
150     newpage->next = NULL; newpage->used = 0;
151     curpage->next = newpage; curpage = newpage;
152   }
153   curnumpart = curpage->used;
154   curp = &(curpage->parts[curnumpart]);
155   curlist = &(curp->list);
156   curp->numpart = numsec; curlist->nbparam = 0;
157   curlist->first = curlist->last = NULL;
158   curpage->used ++;  nbparts ++;
159 }
160
161
162 /*   Selection du dirpart dnum, correspond a numsec en Psect   */
163
164 void iges_curpart (int dnum)
165 {
166   if (curp == NULL) return;
167   if (dnum == curp->numpart) return;
168   if (curnumpart < curpage->used - 1) curnumpart ++;
169   else {
170     if (curpage->next == NULL) curpage = firstpage;
171     else curpage = curpage->next;
172     curnumpart = 0;
173   }
174   curp = &(curpage->parts[curnumpart]);
175   curlist = &(curp->list);
176   if (dnum == curp->numpart) return;
177   curpage = firstpage;
178   while (curpage != NULL) {
179     int i; int nbp = curpage->used;
180     for (i = 0; i < nbp; i ++) {
181       if (curpage->parts[i].numpart == dnum) {
182         curnumpart = i;
183         curp = &(curpage->parts[i]);
184         curlist = &(curp->list);
185         return;
186       }
187     }
188     curpage = curpage->next;
189   }
190   curp = NULL;    /*  pas trouve  */
191 }
192
193
194 /*     Definition d'un nouveau parametre    */
195 /*   (manque la gestion d'un Hollerith sur plusieurs lignes)   */
196
197 /*   longval : longueur de parval, incluant le zero final   */
198 void iges_newparam (int typarg, int longval, char *parval)
199 {
200   char *newval;
201   if (curlist == NULL) return;      /*  non defini : abandon  */
202   newval = iges_newchar(parval,longval);
203 /*  curparam = (struct oneparam*) malloc ( sizeof(struct oneparam) );  */
204   if (oneparpage->used > Maxpar) {
205     struct parpage* newparpage;
206     newparpage = (struct parpage*) malloc ( sizeof(struct parpage) );
207     newparpage->next = oneparpage; newparpage->used = 0;
208     oneparpage = newparpage;
209   }
210   curparam = &(oneparpage->params[oneparpage->used]);
211   oneparpage->used ++;
212   curparam->typarg = typarg;
213   curparam->parval = newval;
214   curparam->next = NULL;
215   if (curlist->first == NULL) curlist->first = curparam;
216   else curlist->last->next = curparam;
217   curlist->last = curparam;
218   curlist->nbparam ++;
219   nbparams ++;
220 }
221
222 /*     Complement du parametre courant (cf Hollerith sur +ieurs lignes)    */
223 void iges_addparam (int longval, char* parval)
224 {
225   char *newval, *oldval; int i;
226   size_t long0;
227   if (longval <= 0) return;
228   oldval = curparam->parval;
229   long0 = strlen(oldval);
230 /*  newval = (char*) malloc(long0+longval+1);  */
231   newval = iges_newchar("",(int)long0+longval+1);
232   for (i = 0; i < long0;   i ++) newval[i] = oldval[i];
233   for (i = 0; i < longval; i ++) newval[i+long0] = parval[i];
234   newval[long0+longval] = '\0';
235   curparam->parval = newval;
236 }
237
238
239 /*               Relecture : Initialiation              */
240 /*  entites relues par suite de lirpart + {lirparam}
241     lirparam initiaux : pour relire le demarrage (start section)   */
242 void iges_stats (int* nbpart, int* nbparam)
243 {
244   curpage  = firstpage; curnumpart = 0;
245   curlist  = starts;
246   curparam = curlist->first;
247   *nbpart  = nbparts;
248   *nbparam = nbparams;
249 }
250
251 /*      Lecture d'une part : retour = n0 section, 0 si fin         */
252 /* \par tabval tableau recepteur des entiers (reserver 17 valeurs) */
253 /* \par res1 res2 nom num char : transmis a part */
254 int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num, int *nbparam)
255 {
256   if (curpage == NULL) return 0;
257   curp = &(curpage->parts[curnumpart]);
258   curlist = &(curp->list);
259   *nbparam = curlist->nbparam;
260   curparam = curlist->first;
261   *tabval = &(curp->typ);    /* adresse de curp = adresse du tableau */
262   *res1 = curp->res1; *res2 = curp->res2;
263   *nom  = curp->nom;  *num  = curp->num;
264   return curp->numpart;
265 }
266
267 /*               Passage au suivant (une fois lus les parametres)          */
268 void iges_nextpart()
269 {
270   curnumpart ++;
271   if (curnumpart >= curpage->used) {  /* attention, adressage de 0 a used-1 */
272     curpage = curpage->next;
273     curnumpart = 0;
274   }
275 }
276
277 /*               Lecture parametre + passage au suivant                   */
278 int iges_lirparam (int *typarg, char* *parval)    /* renvoie 0 si fin de liste, 1 sinon */
279 {
280   if (curparam == NULL) return 0;
281   *typarg = curparam->typarg;
282   *parval = curparam->parval;
283   curparam = curparam->next;
284   return 1;
285 }
286
287 /*               Fin pour ce fichier : liberer la place                  */
288 /*    mode = 0 : tout; 1 : parametres; 2 : caracteres  */
289 void iges_finfile (int mode)
290 {
291   struct dirpage* oldpage;
292   if (mode == 0 || mode == 2) {  free (starts);  free (header);  }
293
294   if (mode == 0 || mode == 1) {
295     curpage = firstpage;
296     while (curpage != NULL) {
297       oldpage = curpage->next;
298       free (curpage);
299       curpage = oldpage;
300     }
301
302     while (oneparpage != NULL) {
303       struct parpage* oldparpage;  oldparpage = oneparpage->next;
304       free (oneparpage);
305       oneparpage = oldparpage;
306     }
307   }
308
309   if (mode == 0 || mode == 2) {
310     while (onecarpage != NULL) {
311       struct carpage* oldcarpage; oldcarpage = onecarpage->next;
312       free (onecarpage);
313       onecarpage = oldcarpage;
314     }
315   }
316 }