src/IGESFile/structiges.c

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