[occt.git] / src / IGESFile / structiges.c

/*
 Copyright (c) 1999-2014 OPEN CASCADE SAS

 This file is part of Open CASCADE Technology software library.

 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License version 2.1 as published
 by the Free Software Foundation, with special exception defined in the file
 OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 distribution for complete text of the license and disclaimer of any warranty.

 Alternatively, this file may be used under the terms of Open CASCADE
 commercial license or contractual agreement.
*/

#include <stdlib.h>
#include <string.h>

#include "igesread.h"

/*   Structures temporaires IGES (enregistrement des entites et parametres)
     Comprennent : les declarations, et la gestion de l'entite en cours  */

static int nbparts;
static int nbparams;

/*                Liste de parametres IGES (header ou current part)        */
static struct parlist *curlist;
static struct parlist *starts;   /*  Start Section du fichier IGES  */
static struct parlist *header;   /*  Entete du fichier IGES  */


/*                Declaration d'une portion de Directory IGES              */
static struct dirpart *curp;

struct dirpart *iges_get_curp (void)
{
  return curp;
}

/*                   Declaration d'un parametre IGES (Psect)              */
static struct oneparam {
  struct oneparam *next;
  int typarg;
  char *parval;
} *curparam;

#define Maxparts 1000
static struct dirpage {
  int used;
  struct dirpage *next;
  struct dirpart  parts[Maxparts];
} *firstpage = NULL;

#define Maxpar 20000
static struct parpage {    /* une page de parametres ; cf AddParam */
  struct parpage* next;
  int             used;
  struct oneparam params[Maxpar+1];
} *oneparpage;


static int curnumpart = 0;
static struct dirpage *curpage;


/*           ROUTINES UTILITAIRES de traitement des textes (char*)          */

/*     Gestion du texte courant : c'est un texte alloue dynamiquement
       iges_newchar en alloue un (jete le precedent alloue si pas lu)
       rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
       rec_settext en force un autre en jetant le precedent (idem rec_newtext)
       tandis que rec_newtext alloue un texte, sans lien avec le courant
*/

#define Maxcar 10000

  static struct carpage {
    struct carpage* next;        /*  chainage des pages de caracteres  */
    int             used;        /*  place deja prise  */
    char  cars[Maxcar+1];        /*  page de caracteres  */
  } *onecarpage;

  static char* restext = NULL ;  /* texte courant  (allocation dynamique) */
/*  static int   resalloc = 0 ; */    /*   alloue (memoire a liberer) ou non   */

/*    Utilitaire : Reservation de caracteres
      Remplace suite de mini-malloc par gestion de page   */

char* iges_newchar (char* newtext, int lentext)
{
  int i, lnt;
  if ((lnt = onecarpage->used) > Maxcar-lentext-1) {  /* allouer nouvelle page */
    struct carpage *newpage;
    unsigned int sizepage = sizeof(struct carpage);
    if (lentext >= Maxcar) sizepage += (lentext+1 - Maxcar);
    newpage = (struct carpage*) malloc (sizepage);
    newpage->next = onecarpage;
    onecarpage = newpage;
    lnt = onecarpage->used = 0;
  }
  restext  = onecarpage->cars + lnt;
  onecarpage->used = (lnt + lentext + 1);
/*   strcpy   */
  for (i = lentext-1; i >= 0; i --) restext[i] = newtext[i];
  restext[lentext] = '\0';
  return (restext);
}


/*             FICHIER  IGES  Proprement Dit             */

/*             Initialisation de l'enregistrement d'un fichier            */
void iges_initfile()
{
  onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
  onecarpage->used = 0; onecarpage->next = NULL;  restext = NULL;
  oneparpage = (struct parpage*) malloc ( sizeof(struct parpage) );
  oneparpage->used = 0; oneparpage->next = NULL;

  starts = (struct parlist*) malloc ( sizeof(struct parlist) );
  starts->first = starts->last = NULL; starts->nbparam = 0;
  header = (struct parlist*) malloc ( sizeof(struct parlist) );
  header->first = header->last = NULL; header->nbparam = 0;

  curlist = starts;    /* On commence a enregistrer la start section */
  nbparts = nbparams = 0;
  firstpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
  firstpage->next = NULL; firstpage->used = 0;
  curpage = firstpage;
}  

/*   Passage au Header (Global Section), lecture comme ecriture    */
void iges_setglobal()
{  if (curlist == header) return;  curlist = header;    curparam = curlist->first;  }


/*   Definition et Selection d'un nouveau dirpart   */

void iges_newpart(int numsec)
{
  if (curpage->used >= Maxparts) {
    struct dirpage* newpage;
    newpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
    newpage->next = NULL; newpage->used = 0;
    curpage->next = newpage; curpage = newpage;
  }
  curnumpart = curpage->used;
  curp = &(curpage->parts[curnumpart]);
  curlist = &(curp->list);
  curp->numpart = numsec; curlist->nbparam = 0;
  curlist->first = curlist->last = NULL;
  curpage->used ++;  nbparts ++;
}


/*   Selection du dirpart dnum, correspond a numsec en Psect   */

void iges_curpart (int dnum)
{
  if (curp == NULL) return;
  if (dnum == curp->numpart) return;
  if (curnumpart < curpage->used - 1) curnumpart ++;
  else {
    if (curpage->next == NULL) curpage = firstpage;
    else curpage = curpage->next;
    curnumpart = 0;
  }
  curp = &(curpage->parts[curnumpart]);
  curlist = &(curp->list);
  if (dnum == curp->numpart) return;
  curpage = firstpage;
  while (curpage != NULL) {
    int i; int nbp = curpage->used;
    for (i = 0; i < nbp; i ++) {
      if (curpage->parts[i].numpart == dnum) {
	curnumpart = i;
	curp = &(curpage->parts[i]);
	curlist = &(curp->list);
	return;
      }
    }
    curpage = curpage->next;
  }
  curp = NULL;    /*  pas trouve  */
}


/*     Definition d'un nouveau parametre    */
/*   (manque la gestion d'un Hollerith sur plusieurs lignes)   */

/*   longval : longueur de parval, incluant le zero final   */
void iges_newparam (int typarg, int longval, char *parval)
{
  char *newval;
  if (curlist == NULL) return;      /*  non defini : abandon  */
  newval = iges_newchar(parval,longval);
/*  curparam = (struct oneparam*) malloc ( sizeof(struct oneparam) );  */
  if (oneparpage->used > Maxpar) {
    struct parpage* newparpage;
    newparpage = (struct parpage*) malloc ( sizeof(struct parpage) );
    newparpage->next = oneparpage; newparpage->used = 0;
    oneparpage = newparpage;
  }
  curparam = &(oneparpage->params[oneparpage->used]);
  oneparpage->used ++;
  curparam->typarg = typarg;
  curparam->parval = newval;
  curparam->next = NULL;
  if (curlist->first == NULL) curlist->first = curparam;
  else curlist->last->next = curparam;
  curlist->last = curparam;
  curlist->nbparam ++;
  nbparams ++;
}

/*     Complement du parametre courant (cf Hollerith sur +ieurs lignes)    */
void iges_addparam (int longval, char* parval)
{
  char *newval, *oldval;
  int i, long0;
  if (longval <= 0) return;
  oldval = curparam->parval;
  long0 = (int)strlen(oldval);
/*  newval = (char*) malloc(long0+longval+1);  */
  newval = iges_newchar("",long0+longval+1);
  for (i = 0; i < long0;   i ++) newval[i] = oldval[i];
  for (i = 0; i < longval; i ++) newval[i+long0] = parval[i];
  newval[long0+longval] = '\0';
  curparam->parval = newval;
}


/*               Relecture : Initialiation              */
/*  entites relues par suite de lirpart + {lirparam}
    lirparam initiaux : pour relire le demarrage (start section)   */
void iges_stats (int* nbpart, int* nbparam)
{
  curpage  = firstpage; curnumpart = 0;
  curlist  = starts;
  curparam = curlist->first;
  *nbpart  = nbparts;
  *nbparam = nbparams;
}

/*      Lecture d'une part : retour = n0 section, 0 si fin         */
/* \par tabval tableau recepteur des entiers (reserver 17 valeurs) */
/* \par res1 res2 nom num char : transmis a part */
int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num, int *nbparam)
{
  if (curpage == NULL) return 0;
  curp = &(curpage->parts[curnumpart]);
  curlist = &(curp->list);
  *nbparam = curlist->nbparam;
  curparam = curlist->first;
  *tabval = &(curp->typ);    /* adresse de curp = adresse du tableau */
  *res1 = curp->res1; *res2 = curp->res2;
  *nom  = curp->nom;  *num  = curp->num;
  return curp->numpart;
}

/*               Passage au suivant (une fois lus les parametres)          */
void iges_nextpart()
{
  curnumpart ++;
  if (curnumpart >= curpage->used) {  /* attention, adressage de 0 a used-1 */
    curpage = curpage->next;
    curnumpart = 0;
  }
}

/*               Lecture parametre + passage au suivant                   */
int iges_lirparam (int *typarg, char* *parval)    /* renvoie 0 si fin de liste, 1 sinon */
{
  if (curparam == NULL) return 0;
  *typarg = curparam->typarg;
  *parval = curparam->parval;
  curparam = curparam->next;
  return 1;
}

/*               Fin pour ce fichier : liberer la place                  */
/*    mode = 0 : tout; 1 : parametres; 2 : caracteres  */
void iges_finfile (int mode)
{
  struct dirpage* oldpage;
  if (mode == 0 || mode == 2) {  free (starts);  free (header);  }

  if (mode == 0 || mode == 1) {
    curpage = firstpage;
    while (curpage != NULL) {
      oldpage = curpage->next;
      free (curpage);
      curpage = oldpage;
    }

    while (oneparpage != NULL) {
      struct parpage* oldparpage;  oldparpage = oneparpage->next;
      free (oneparpage);
      oneparpage = oldparpage;
    }
  }

  if (mode == 0 || mode == 2) {
    while (onecarpage != NULL) {
      struct carpage* oldcarpage; oldcarpage = onecarpage->next;
      free (onecarpage);
      onecarpage = oldcarpage;
    }
  }
}
Commit	Line	Data
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
d5f74e42	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
973c2be1	13	commercial license or contractual agreement.
b311480e	14	*/
b311480e	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;
37e640d5	221	int i, long0;
7fd59977	222	if (longval <= 0) return;
7fd59977	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	}