src/StepFile/recfile.pc

   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 "stdio.h"
  22 #include "string.h"
  23 #include "stdlib.h"
  24 #if defined(HAVE_MALLOC_H)
  25 #include "malloc.h"
  26 #endif
  27 #include "recfile.ph"
  28 /*  enregistrement d'un fichier d'interface sous forme de records
  29     gere les scopes
  30
  31     Ce fichier comprend 3 parties
  32     - les routines traitant les char*, avec la notion de texte courant
  33     - les declarations des donnees de travail proprement dites pour le fichier
  34     - le corps des programmes d'enregistrement
  35 */
  36
  37
  38 /*           ROUTINES UTILITAIRES de traitement des textes (char*)          */
  39
  40 /*     Gestion du texte courant : c'est un texte alloue dynamiquement
  41        rec_restext en alloue un (jete le precedent alloue si pas lu)
  42        rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
  43        rec_settext en force un autre en jetant le precedent (idem rec_newtext)
  44        tandis que rec_newtext alloue un texte, sans lien avec le courant
  45 */
  46
  47 #define Maxcar 50000
  48
  49   static struct carpage {
  50     struct carpage* next;        /*  chainage des pages de caracteres  */
  51     int             used;        /*  place deja prise  */
  52     char  cars[Maxcar+1];        /*  page de caracteres  */
  53   } *onecarpage;
  54
  55   static char* restext = NULL ;  /* texte courant  (allocation dynamique) */
  56   /* static int   resalloc = 0 ;*/    /*   alloue (memoire a liberer) ou non   */
  57
  58 static char txt_cart_p[]   = "CARTESIAN_POINT";
  59
  60 void rec_restext(newtext,lentext)         /* destine a etre appele de l'exterieur */
  61 char* newtext; int lentext;
  62 {
  63   char *res, *text;
  64   if(strcmp(newtext,txt_cart_p)==0) {
  65     restext = txt_cart_p;
  66     return;
  67   }
  68
  69   if (onecarpage->used > Maxcar-lentext-1) {   /* allouer nouvelle page */
  70     struct carpage *newpage;
  71     int sizepage = sizeof(struct carpage);
  72     if (lentext >= Maxcar) sizepage += (lentext+1 - Maxcar);
  73     newpage = (struct carpage*) malloc (sizepage);
  74     newpage->next = onecarpage;
  75     onecarpage = newpage;
  76     onecarpage->used = 0;
  77   }
  78   restext  = onecarpage->cars + onecarpage->used;
  79   onecarpage->used += (lentext + 1);
  80 /*   strcpy   */
  81   res = restext ; text = newtext;
  82   while (*text != '\0') { *res=*text ; res++ ; text++ ; }
  83   *res = '\0' ;
  84 }
  85
  86 void rec_gettext(r)
  87 char* *r ;
  88 { *r = restext; }
  89 /*  Le resultat retourne (pointeur) est destine a etre inclus dans un struct */
  90
  91 void rec_settext(s)
  92 char* s ;    /* substituer le texte courant par un autre deja alloue */
  93 {  restext = s ;  }
  94
  95 char* rec_newtext(r)
  96 /*  routine utilitaire creant une chaine dynamique a partir d'un char[]  */
  97 char* r ;
  98 {
  99   char* savrestext; char* s0;
 100   savrestext = restext;
 101   rec_restext(r,strlen(r)); s0 = restext;
 102   restext = savrestext;
 103   return (s0);
 104 }
 105
 106
 107
 108 static int modeprint = 0 ;  /* CONTROLE D'IMPRESSION (pour appel depuis yacc)*/
 109
 110 /*      DECLARATIONS des donnees de travail (en cours d'enregistrement)     */
 111
 112 static int  typarg ;       /* type du dernier argument lu */
 113 static int  nbrec  = 0;    /* nombre total d'enregistrements de donnees */
 114 static int  nbhead = 0;    /* nb de records pris par le Header */
 115 static int  nbpar  = 0;    /* nb de parametres lus au total */
 116 static int  yarec  = 0;    /* presence Record deja cree (1 apres Ident) */
 117
 118 static struct rec {          /*  DESCRIPTION D'UN RECORD  */
 119   char* ident ;       /* identifieur du record  (en #12345...) ou scope-end */
 120   char* type  ;       /* type du record  (peut etre sublist) */
 121 /*  int nbarg ;          nombre de parametres (arguments) du record, not used */
 122   struct unarg* first ;  /* 1er argument */
 123 /*  struct unarg* last  ;dernier argument, not used */
 124   struct rec*   next  ;  /* record suivant */
 125 }  *currec ;           /* currec meme : record courant */
 126
 127 #define Maxrec 5000
 128 static struct recpage {
 129   struct recpage*  next;
 130   int              used;
 131   struct rec       args[Maxrec+1];
 132 } *onerecpage;
 133
 134 static struct rec* firstrec ;  /* 1er record du fichier */
 135 static struct rec* lastrec  ;  /* dernier record du fichier */
 136
 137 static char* curtype;          /* type dernier record (ou = sublist) */
 138 static char* subarg ;          /* ident dernier record (sub-list eventuel) */
 139 static int   numsub ;          /* numero de sous-liste en cours */
 140
 141
 142 static struct unarg {          /*  DESCRIPTION D'UN ARGUMENT  */
 143   int type ;     /* type de l'arg, dans une liste courte : entier, reel ... */
 144   char* val ;    /* valeur alphanum de l'arg */
 145   struct unarg* next ;  /* argument suivant dans la liste pour ce record */
 146 }  *curarg ;
 147
 148 #define Maxarg 10000
 149 static struct argpage {        /*  Allocation optimisee des arguments  */
 150   struct argpage*  next;
 151   int              used;
 152   struct unarg     args[Maxarg+1];
 153 } *oneargpage;
 154
 155
 156 static struct scope {          /*  DESCRIPTION D'UN SCOPE  */
 157                         /* les scopes sont empilables sans limite */
 158   struct scope* prev;   /* scope precedent, auquel il faudra revenir */
 159   struct rec*   rec;    /* record interrompu par le scope (a reprendre) */
 160 }   *curscope ;         /*  curscope est le scope en cours */
 161
 162
 163 /*               Constantes litterales               */
 164 static char txt_sublist[]  = "/* (SUB) */" ;
 165 static char txt_scope[]    = "SCOPE" ;
 166 static char txt_endscope[] = "ENDSCOPE" ;
 167 static char txt_nil[]      = " " ;
 168 static char sub1[]         = "$1" ;  /* optimisation ... */
 169 static char sub2[]         = "$2" ;
 170 static char argtype1[] = "(IF#TnEHBx";  /* types arguments (2 1es lettres) */
 171 static char argtype2[] = ")nlIxdnxix";
 172 static char idzero[]   = "#0";
 173
 174
 175 /*              Trace pour controle            */
 176 void recfile_modeprint(mode)
 177 int mode ;
 178 {  modeprint = mode;  }
 179
 180 static int   lastno;
 181 extern int   steplineno;
 182 extern int   modcom;
 183 extern int   modend;
 184
 185 void rec_inityyll ()
 186 {
 187   steplineno = 0;
 188   modcom = 0;
 189   modend = 0;
 190   lastno = -1;
 191 }
 192
 193
 194 /*   INITIALISATION   */
 195
 196 void rec_debfile()
 197 {
 198   /*initialization of recpage*/
 199   onerecpage = (struct recpage*) malloc ( sizeof(struct recpage) );
 200   onerecpage->used = 0; onerecpage->next = NULL;
 201
 202   onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
 203   onecarpage->used = 0; onecarpage->next = NULL;  restext = NULL;
 204   yarec = 0;  nbhead = nbrec = nbpar = 0 ; firstrec = NULL ; lastrec = NULL ;
 205   curtype = txt_sublist;
 206   currec = NULL ; curarg = NULL ;
 207   curscope = NULL ;
 208   oneargpage = (struct argpage*) malloc ( sizeof(struct argpage) );
 209   oneargpage->next = NULL; oneargpage->used = 0;
 210   rec_inityyll();
 211 }
 212
 213 /*   INTERMEDIAIRE : passage de Header a Data    */
 214 void rec_finhead()  {  nbhead = nbrec;  }
 215
 216 /*   CONCLUSION  :  actuellement, ne fait rien   */
 217
 218 void rec_finfile()  {  }
 219
 220
 221 /*   GESTION DES RECORDS   */
 222
 223 /*   ENREGISTRER UN RECORD (deja pret)    */
 224 void static rec_new(newrec)
 225 struct rec* newrec ;    /*  nouveau record a enregistrer  */
 226 {
 227  nbrec ++ ;
 228  if ( firstrec == NULL ) firstrec = newrec ;
 229  if ( lastrec  != NULL ) lastrec->next = newrec ;
 230  lastrec = newrec ;
 231 }
 232
 233 /*  type du dernier argument lu  */
 234 void rec_typarg(argtype)
 235 int argtype ;
 236 {  typarg = argtype;  }
 237
 238 /*   ENREGISTRER UNE ENTITE (record courant)   */
 239 void rec_newent()
 240 {
 241  rec_new(currec) ;     /*  le record courant (currec) est enregistre  */
 242
 243 /*  gestion des sous-listes : si currec a un suivant note (cf pointeur suite),
 244     alors c'est une sous-liste et le suivant est son contenant
 245     EN CE CAS, il faut memoriser cette sous-liste en argument courant
 246     En effet, d'une part la liste est reconnue comme un argument, d'autre part
 247     part elle se termine par ")" : c'est donc ici qu'elle sera enregistree */
 248
 249  rec_typarg (rec_argSub) ;
 250
 251  subarg = currec->ident ;      /* si sous-liste, sera argument du contenant */
 252 /*                          rec_check(1) ;    */
 253  currec = currec->next ;       /* si nul, c'est qu'une autre entite suit */
 254  lastrec->next = NULL ;
 255 }
 256
 257
 258 static struct rec*rec_newrec()
 259 {
 260   struct rec* newrec;
 261   if (onerecpage->used >= Maxrec) {
 262     struct recpage* newrecpage;
 263     newrecpage = (struct recpage*) malloc ( sizeof (struct recpage) );
 264     newrecpage->next = onerecpage;
 265     onerecpage = newrecpage;
 266     onerecpage->used = 0;
 267   }
 268   newrec = &(onerecpage->args[onerecpage->used]);
 269   onerecpage->used++;
 270
 271   return newrec;
 272 }
 273
 274
 275 /*   RECORD COURANT :   */
 276
 277 /*   creer et preciser l'identifieur   */
 278 void rec_ident()
 279 {
 280   currec = rec_newrec();
 281   /*currec = (struct rec*) malloc (sizeof (struct rec)) ;*/
 282   /*currec->nbarg = 0 ;*/
 283   rec_gettext(&(currec->ident)) ;
 284   currec->next = NULL ; currec->first = NULL ; /*currec->last = NULL ;*/
 285   yarec = 1;
 286 }
 287
 288 /*   preciser le type ; demarrage de la description de l'entite  */
 289 void rec_type()
 290 {
 291 /* Pour le header : pas d'ident, donc en simuler un : derive de rec_ident */
 292   if (!yarec) {
 293     /*currec = (struct rec*) malloc (sizeof (struct rec)) ;*/
 294     currec = rec_newrec();
 295     /*currec->nbarg = 0 ;*/
 296     currec->ident = idzero;  /* Ident bidon (il en faut un ...) */
 297     currec->next = NULL ; currec->first = NULL ; /*currec->last = NULL ;*/
 298   }
 299   rec_gettext(&(currec->type)) ;
 300   yarec = numsub = 0 ;      /* debut de l'entite */
 301 }
 302
 303 /*  type d une liste qui n est pas une entite mais un argument
 304     par defaut (cf rec_deblist) il n est pas defini donc mis = "/ (SUB) /" */
 305 void rec_listype()
 306 {  rec_gettext(&(curtype));  }
 307
 308 /*  ajouter un argument (type & valeur deja connus) */
 309 void rec_newarg()
 310 {
 311   struct unarg *newarg;
 312   nbpar ++;
 313   /*currec->nbarg ++ ;*/
 314 /*  newarg = (struct unarg*) malloc (sizeof (struct unarg)) ;  */
 315   if (oneargpage->used >= Maxarg) {
 316     struct argpage* newargpage;
 317     newargpage = (struct argpage*) malloc ( sizeof(struct argpage) );
 318     newargpage->next = oneargpage;
 319     oneargpage = newargpage;
 320     oneargpage->used = 0;
 321   }
 322   newarg = &(oneargpage->args[oneargpage->used]);
 323   oneargpage->used ++;
 324
 325   newarg->type = typarg ;
 326   if (typarg == rec_argSub) newarg->val = subarg ;
 327   else rec_gettext (&(newarg->val));
 328
 329 /*  if (currec->first == NULL) currec->first = newarg;
 330   else currec->last->next = newarg;
 331   currec->last = newarg;*/
 332   if (currec->first == NULL) currec->first = newarg;
 333   else {
 334     struct unarg* nextarg = currec->first;
 335     while(nextarg->next != NULL)
 336       nextarg = nextarg->next;
 337     nextarg->next = newarg;
 338
 339   }
 340   newarg->next = NULL ;
 341 /*                          rec_check(0) ;    */
 342 }
 343
 344 /*   Ajouter une sous-liste
 345
 346      Une ouverture de parentheses A L'INTERIEUR d'une liste de parametres
 347      signale une sous-liste : c'est une entite non identifiee, directement
 348      utilisee comme argument de la liste contenante) d'un type reserve(SUB)
 349
 350      Elle est enregistree avec un identifieur special : '$' suivi d'un numero
 351      de sous-liste dans l'entite en cours.
 352
 353      Son enregistrement consiste a definir un nouveau record courant, pour la
 354      sous-liste, qui note comme suivant l'ancien courant, qui est son contenant
 355      A la fin de la sous-liste, elle est enregistree comme toute entite (cf
 356      rec_new) mais le suivant devient le nouveau courant dont l'enregistrement
 357      des parametres continue
 358
 359      La premiere ouverture de parentheses dans l'entite est celle de la liste
 360      principale de parametres et non d'une sous-liste
 361 */
 362
 363 void rec_deblist()
 364 {
 365  if (numsub > 0) {            /* enregistrement d'une sous-liste */
 366   /* int i ; */ struct rec* subrec ;
 367     /* creation du nouvel enregistrement et chainage au precedent */
 368   subrec = rec_newrec();
 369   /*subrec = (struct rec*) malloc (sizeof (struct rec)) ;*/
 370   switch (numsub) {
 371   case 1: subrec->ident = sub1; break;
 372   case 2: subrec->ident = sub2; break;
 373   default: {
 374     char bufsub[10];
 375     if (numsub > 9) sprintf (bufsub,"$%d",numsub) ;
 376     else {  bufsub[0] = '$'; bufsub[1] = numsub + 48; bufsub[2] = '\0';  }
 377     subrec->ident = rec_newtext(bufsub) ;
 378     }
 379   }
 380   subrec->type  = curtype ;
 381   curtype = txt_sublist;      /* type reserve par defaut */
 382   /*subrec->nbarg = 0 ;*/ subrec->next = currec ;
 383   subrec->first = NULL ; /*subrec->last = NULL ;*/
 384     /* les arguments de la sous-liste vont suivre ;
 385        elle meme est argument de son contenant, ce qui est pris en compte
 386        a la fermeture de la parenthese */
 387   currec = subrec ;           /* substitution finale */
 388  }
 389  numsub ++ ;   /* numero de la prochaine sous-liste (la principale est en 0) */
 390 /*                          rec_check(0) ;    */
 391 }
 392
 393
 394 /*   Affichage du contenu d'un record   */
 395 void rec_print(unrec)
 396 struct rec* unrec ;
 397 {
 398  int numa = 0;  int numl = 0;  int argl = 0;
 399  if (unrec == NULL) {  printf ("Non defini\n") ; return;  }
 400  printf ("Ident : %s  Type : %s  Nb.Arg.s : %s\n",
 401           unrec->ident,unrec->type, (unrec->first ? unrec->first->val : "")) ;
 402  if (modeprint < 2) return ;
 403  curarg = unrec->first ;
 404  while (curarg != NULL) {
 405    numa ++;  argl = strlen(curarg->val) + 18;  numl += argl;
 406    if (numl > 132) {  printf("\n");  numl = argl;  }
 407    printf ("  - Arg.%d[%c%c] : %s",
 408            numa,argtype1[curarg->type],argtype2[curarg->type],curarg->val);
 409    curarg = curarg->next ;
 410  }
 411  if (argl > 0) printf("\n");
 412  return ;
 413 }
 414
 415 /*   GESTION DES SCOPES   */
 416
 417 /*  Ouverture de scope :
 418   un scope est un record particulier (pas de type ni d'argument)
 419   d'une part il est enregistre, d'autre part il faut gerer le record en cours
 420   En effet, une entite step etait en cours d'enregistrement (ident deja connu),
 421   mais son type et ses arguments seront fournis apres fermeture du scope ...
 422   Il faut donc la mettre de cote (c'est currec), pour la restaurer ensuite
 423
 424   Mais ATTENTION, il y a l'EXPORT : au ENDSCOPE, peut etre attachee une liste
 425   d'Idents : ce sont les idents internes au SCOPE mais declares visibles de
 426   l'exterieur du SCOPE (en plus de l''entite sur laquelle il porte)
 427 */
 428
 429 void scope_debut()
 430 {
 431 /*   ouverture du scope et sauvegarde de l'entite en cours   */
 432  struct scope* newscope; struct rec* unscope;
 433  newscope = (struct scope*) malloc (sizeof (struct scope)) ;
 434  newscope->rec  = currec ;
 435  newscope->prev = curscope ;
 436  curscope = newscope ;
 437
 438 /*   enregistrement de ce scope comme un record   */
 439  unscope = rec_newrec();
 440  /*unscope = (struct rec*) malloc (sizeof (struct rec)) ;*/
 441  unscope->ident = txt_scope ;
 442  unscope->type  = txt_nil ;
 443  unscope->first = NULL;
 444  /*unscope->nbarg = 0 ;*/
 445  rec_new(unscope) ;
 446 }
 447
 448 /*   Fermeture de scope :
 449    La fin de scope est, comme son debut, un enregistrement special.
 450    Il faut donc l'enregistrer.
 451    Il faut aussi restaurer l'entite concernee par le scope, afin de terminer
 452    son enregistrement (manquent ses arguments)  */
 453
 454 void scope_fin()
 455 { struct scope* oldscope ; struct rec* unscope;
 456  if (curscope == NULL) return ;   /* cela dit, c'est anormal ... */
 457
 458 /*   enregistrement de cette fin de scope comme un record   */
 459  unscope = rec_newrec();
 460 /* unscope = (struct rec*) malloc (sizeof (struct rec)) ;*/
 461  unscope->ident = txt_endscope ;
 462  unscope->type  = txt_nil ;
 463  unscope->first = NULL;
 464  /*unscope->nbarg = 0 ;*/
 465
 466 /*  Si on doit prendre en compte une Export List ...  */
 467  if (subarg[0] == '$') {
 468    if (modeprint > 0) {
 469      printf("Export List : (List in Record n0 %d) -- ",nbrec);
 470      rec_print(lastrec);
 471    }
 472    currec = unscope;
 473    typarg = rec_argSub;
 474    rec_newarg();
 475  }
 476  rec_new(unscope) ;
 477
 478 /*   fermeture effective du scope   */
 479  currec   = curscope->rec ;      /* restaurer l'entite en cours d'enreg. */
 480  yarec    = 1;
 481  oldscope = curscope ;
 482  curscope = oldscope->prev ;     /*  restauration de l'etat precedent  */
 483  free (oldscope) ;               /*  suppression "physique"  */
 484 }
 485
 486
 487 /*   CONCLUSION  :  retour des valeurs pour constituer la liste des records,
 488                     sous forme de directory / tableau
 489
 490      La liberation de la memoire est faite par lir_file_fin, en une fois
 491 */
 492
 493 void lir_file_nbr(nbh,nbr,nbp)
 494 int* nbh; int* nbr; int* nbp;
 495 /*  initialise le traitement et retourne la taille du directory et du header */
 496 {
 497  currec = firstrec ;
 498 /*                       rec_check(0) ;    */
 499  *nbh = nbhead;  *nbr = nbrec;  *nbp = nbpar;
 500 }
 501
 502 void lir_file_fin(mode)
 503 int mode;
 504 /*  fin du traitement : regroupe les liberations de memoire en une phase  */
 505 /*  mode = 1 : rec+arg. 2 : carpage; 3 : 1+2  */
 506 {
 507   if (mode & 1) {
 508     while(onerecpage != NULL) {
 509       struct recpage* newpage; newpage = onerecpage->next;
 510       free(onerecpage);
 511       onerecpage = newpage;
 512     }
 513
 514
 515 /*    struct rec* oldrec;
 516     oldrec = NULL;
 517     currec = firstrec;
 518     while (currec != NULL) {
 519       oldrec = currec;
 520       currec = currec->next;*/
 521 /* liberation memoire pour type & ident : si scope-endscope rien a liberer
 522    si sous-liste : type pas a liberer, ident partage aussi par l'argument sera
 523    libere par lui ... donc ici aussi, rien a liberer. CQFD  */
 524 /*      free (oldrec) ;
 525     }*/
 526     while (oneargpage != NULL) {
 527       struct argpage* newpage; newpage = oneargpage->next;
 528       free (oneargpage);
 529       oneargpage = newpage;
 530     }
 531   }
 532   if (mode & 2) {
 533     while (onecarpage != NULL) {
 534       struct carpage* newpage; newpage = onecarpage->next;
 535       free (onecarpage);
 536       onecarpage = newpage;
 537     }
 538   }
 539 }
 540
 541 int lir_file_rec(ident,type,nbarg)
 542 /*   retourne les parametres du record courant
 543      retour de fonction ; 1 si ok, 0 si liste epuisee   */
 544 char* *ident ; char* *type ; int *nbarg ;
 545 {
 546  if (currec == NULL) return (0) ;
 547 /*                                   rec_check(2) ;    */
 548  *ident = currec->ident ;
 549  *type  = currec->type ;
 550  *nbarg = (currec->first != NULL);
 551  curarg = currec->first ;    /* prepare lecture arg.s */
 552  return (1) ;
 553 }
 554
 555 void lir_file_finrec()
 556 /*  fait le menage et passe au record suivant
 557     ne pas appeler apres l'indication de fin mais apres chaque record ok !   */
 558 {
 559  currec = currec->next ;
 560 /*                                   rec_check(2) ;   */
 561 }
 562
 563 int lir_file_arg(type,val)
 564 int* type ; char* *val ;
 565 /*  lit l'argument courant (au debut le 1er), fait le menage, prepare suivant
 566     retourne 1 si ok, 0 si c'est fini
 567     attention, suppose que nbarg > 0 ... (bref, pas de protection)   */
 568 {
 569  if (curarg == NULL) return (0) ;
 570  *type = curarg->type ;
 571  *val  = curarg->val ;
 572  curarg = curarg->next ;
 573  return (1) ;
 574 }
 575
 576
 577 /*   Verification de l'integrite des donnees   */
 578
 579 /*   Affiche ce qui ne va pas, mais aussi accede a tout : ainsi, les adresses
 580      verolees aparaissent au grand jour du dbx   */
 581
 582 void rec_check(mode)
 583 int mode ;       /* =1 pas de controle nbrec (en cours d'enregistrement) */
 584 {
 585   struct rec* lerec ; struct unarg* larg ; int nr,na ;
 586   lerec = firstrec ;
 587   if (mode == 2) lerec = currec ;
 588   nr = 0 ;
 589   while (lerec != NULL) {
 590     nr ++ ;
 591     if (lerec->ident == NULL) printf("Record %d : ident null\n",nr) ;
 592     if (lerec->type  == NULL) printf("Record %d : type  null\n",nr) ;
 593     /*if (mode < 2 && (lerec->nbarg < 0 || lerec->nbarg > 10) ) printf
 594       ("N.B.: Record %d : nbarg pas entre 0 & 10, vaut %d\n",nr,lerec->nbarg);
 595     */
 596     na = 0 ;
 597     larg = lerec->first ;
 598     while (larg != NULL) {
 599       na ++ ;
 600       if (larg->type < 0 || larg->type > 9) printf
 601         ("Record %d , Arg. %d : type incorrect : %d\n",nr,na,larg->type) ;
 602       if (larg->val == NULL) printf("Record %d , Arg %d : val null\n",nr,na) ;
 603       larg = larg->next ;
 604     }
 605     /*if (na != lerec->nbarg) printf
 606       ("Record %d : arglist pourrie, nb note %d relu %d\n",nr,lerec->nbarg,na) ;*/
 607     lerec = lerec->next ;
 608   }
 609   if (mode == 0 && nr != nbrec) printf
 610     ("Liste des records pourrie, nb note %d relu %d\n",nbrec,nr) ;
 611 }
 612
 613 void steperror (char *mess);
 614 int  steplex (void);
 615