src/IGESFile/structiges.c

   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
   7  under the terms of the GNU Lesser General Public 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 <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
  90 char* iges_newchar (char* newtext, int lentext)
  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
 140 void iges_newpart(int numsec)
 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
 159 void iges_curpart (int dnum)
 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   */
 193 void iges_newparam (int typarg, int longval, char *parval)
 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)    */
 218 void iges_addparam (int longval, char* parval)
 219 {
 220   char *newval, *oldval;
 221   int i, long0;
 222   if (longval <= 0) return;
 223   oldval = curparam->parval;
 224   long0 = (int)strlen(oldval);
 225 /*  newval = (char*) malloc(long0+longval+1);  */
 226   newval = iges_newchar("",long0+longval+1);
 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)   */
 237 void iges_stats (int* nbpart, int* nbparam)
 238 {
 239   curpage  = firstpage; curnumpart = 0;
 240   curlist  = starts;
 241   curparam = curlist->first;
 242   *nbpart  = nbparts;
 243   *nbparam = nbparams;
 244 }
 245
 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)
 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                   */
 273 int iges_lirparam (int *typarg, char* *parval)    /* renvoie 0 si fin de liste, 1 sinon */
 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  */
 284 void iges_finfile (int mode)
 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 }