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