Open64: osprey/libcif/cifbinread.c Source File

00001 /*
00002 
00003   Copyright (C) 2000, 2001 Silicon Graphics, Inc.  All Rights Reserved.
00004 
00005   This program is free software; you can redistribute it and/or modify it
00006   under the terms of version 2.1 of the GNU Lesser General Public License 
00007   as published by the Free Software Foundation.
00008 
00009   This program is distributed in the hope that it would be useful, but
00010   WITHOUT ANY WARRANTY; without even the implied warranty of
00011   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
00012 
00013   Further, this software is distributed without any warranty that it is
00014   free of the rightful claim of any third person regarding infringement 
00015   or the like.  Any license provided herein, whether implied or 
00016   otherwise, applies only to this software file.  Patent licenses, if
00017   any, provided herein do not apply to combinations of this program with 
00018   other software, or any other product whatsoever.  
00019 
00020   You should have received a copy of the GNU Lesser General Public 
00021   License along with this program; if not, write the Free Software 
00022   Foundation, Inc., 59 Temple Place - Suite 330, Boston MA 02111-1307, 
00023   USA.
00024 
00025   Contact information:  Silicon Graphics, Inc., 1600 Amphitheatre Pky,
00026   Mountain View, CA 94043, or:
00027 
00028   http://www.sgi.com
00029 
00030   For further information regarding this notice, see:
00031 
00032   http://oss.sgi.com/projects/GenInfo/NoticeExplan
00033 
00034 */
00035 
00036 
00037 static char USMID[] = "@(#) libcif/cifbinread.c 30.8  07/26/96 07:19:13";
00038 
00039 
00040 /*
00041  *  _Cif_binread reads the variable portions of a binary CIF record based
00042  *  on the record type.
00043  */
00044 
00045 #define CIF_VERSION 3
00046 
00047 #ifdef _ABSOFT
00048 #include "cif.h"
00049 #else
00050 #include <cif.h>
00051 #endif
00052 
00053 #include <memory.h>
00054 #include <stdio.h>
00055 #include <assert.h>
00056 
00057 #include "cif_int.h"
00058 
00059 extern void free(void *ptr);
00060 
00061 /* --------------------------------------------------------------------------
00062  * read_strlist reads in an array of strings.
00063  * --------------------------------------------------------------------------
00064  */
00065 static int
00066 read_strlist (cifd, ns, sp, fd)
00067 int cifd;         /* CIF descriptor */
00068 int ns;           /* number of strings in array */
00069 char ***sp;         /* address of pointer to array of string pointers */
00070 FILE *fd;
00071 {
00072   register int i;
00073   register char **cp;       /* pointer to array of string pointrs */
00074   register int mode;        /* memory management mode */
00075   short slen[100];          /* array of string lengths */
00076 
00077   if (fread ((char *)slen, sizeof(short), ns, fd) != ns) IO_ERROR;
00078   mode = _Cif_filetbl[cifd].mode;
00079   cp = *sp = (char **)_Cif_space[mode] (ns * sizeof(char *), cifd);
00080   if (cp == NULL)
00081     return (CIF_NOMEM);
00082   for (i = 0; i < ns; i++) {
00083     cp[i] = _Cif_space[mode] (slen[i]+1, cifd);
00084     if (cp[i] == NULL)
00085       return (CIF_NOMEM);
00086     if (fread (cp[i], sizeof(char), slen[i], fd) != slen[i]) IO_ERROR;
00087     (cp[i])[slen[i]] = '\0';
00088   }
00089   return (0);
00090 }
00091 
00092 /* --------------------------------------------------------------------------
00093  * _Cif_binread
00094  * --------------------------------------------------------------------------
00095  */
00096 int
00097 _Cif_binread
00098 #ifdef __STDC__
00099 (int cifd, int rtype, struct Cif_generic *cr, FILE *fd)
00100 #else
00101 (cifd, rtype, cr, fd)
00102 int cifd;
00103 int rtype;
00104 struct Cif_generic *cr;
00105 FILE *fd;
00106 #endif
00107 {
00108 
00109   register int i, n;
00110   register char *cp;
00111   register long *lp;
00112   register int mode;
00113   unsigned char c;
00114 
00115   mode = _Cif_filetbl[cifd].mode;
00116 
00117   switch (rtype) {
00118 
00119   case CIF_CALLSITE:
00120     if ((n = CIFCS(cr)->nargs) > 0) {
00121       lp= CIFCS(cr)->argids= (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00122       if (lp == NULL)
00123         return (CIF_NOMEM);
00124       if (fread ((char *)lp, sizeof(long), n, fd) != n) IO_ERROR;
00125     }
00126     break;
00127 
00128   case CIF_CIFHDR:
00129     CIFHDR(cr)->canpos = _Cif_filetbl[cifd].seek;
00130     CIFHDR(cr)->form = BINARY_CIF_FORMAT;
00131     break;
00132 
00133   case CIF_COMBLK:
00134     if (_Cif_filetbl[cifd].return_version == 1) {
00135 
00136       n = CIFCB1(cr)->nlen;
00137       cp = CIFCB1(cr)->name = _Cif_space[mode] (n+1, cifd);
00138       if (cp == NULL)
00139           return (CIF_NOMEM);
00140       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00141       cp[n] = '\0';
00142     }
00143     else { /* version 2 */
00144 
00145         n = CIFCB(cr)->nlen;
00146       cp = CIFCB(cr)->name = _Cif_space[mode] (n+1, cifd);
00147       if (cp == NULL)
00148           return (CIF_NOMEM);
00149       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00150       cp[n] = '\0';
00151           }
00152     break;
00153 
00154   case CIF_CONST:
00155     n = CIFCON(cr)->nlen;
00156     cp = CIFCON(cr)->name = _Cif_space[mode] (n+1, cifd);
00157     if (cp == NULL)
00158       return(CIF_NOMEM);
00159     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00160     cp[n] = '\0';
00161     n = CIFCON(cr)->vlen;
00162     cp = CIFCON(cr)->value = _Cif_space[mode] (n+1, cifd);
00163     if (cp == NULL)
00164       return(CIF_NOMEM);
00165     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00166     cp[n] = '\0';
00167 
00168     if (CIFCON(cr)->origform) {
00169       n = CIFCON(cr)->olen;
00170       cp = CIFCON(cr)->oform = _Cif_space[mode] (n+1, cifd);
00171 
00172       if (cp == NULL)
00173         return(CIF_NOMEM);
00174       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00175       cp[n] = '\0';
00176     }
00177 
00178 
00179     break;
00180 
00181   case CIF_ENTRY:
00182     if ((n = CIFENTRY(cr)->nargs) > 0) {
00183       lp = CIFENTRY(cr)->argids = (long *) _Cif_space[mode]
00184                                                (sizeof(long)*n, cifd);
00185       if (lp == NULL)
00186         return (CIF_NOMEM);
00187       if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00188     }
00189     n = CIFENTRY(cr)->nlen;
00190     cp = CIFENTRY(cr)->name = _Cif_space[mode] (n+1, cifd);
00191     if (cp == NULL)
00192       return (CIF_NOMEM);
00193     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00194     cp[n] = '\0';
00195     break;
00196 
00197   case CIF_FILE:
00198     if (_Cif_filetbl[cifd].return_version < 3) {
00199       int onlen = CIFFILE(cr)->onlen;
00200       /* do NOT move this line down!
00201          On 32-bit architectures like sparc
00202          CIFFILE(cr)->onlen and CIFFILE1(cr)->name
00203          occupy the same space, so this MUST be done first */
00204 
00205       n = CIFFILE1(cr)->nlen;
00206       cp = CIFFILE1(cr)->name = _Cif_space[mode] (n+1, cifd);
00207       if (cp == NULL)
00208           return (CIF_NOMEM);
00209       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00210       cp[n] = '\0';
00211 
00212 
00213       if (_Cif_filetbl[cifd].version == 3) {
00214 
00215         /* Read and discard the original file name which exists in
00216          * in a V3 CIF but not in V1 or V2 */
00217 
00218         char *tmp;
00219         tmp = _Cif_space[mode] (onlen +1, cifd);
00220         if (tmp == NULL)
00221       return (CIF_NOMEM);
00222         if (fread (tmp, sizeof(char), onlen, fd) != onlen) IO_ERROR;
00223       }
00224     }
00225     else { /* Version 3 CIF */
00226 
00227       n = CIFFILE(cr)->nlen;
00228       cp = CIFFILE(cr)->name = _Cif_space[mode] (n+1, cifd);
00229       if (cp == NULL)
00230           return (CIF_NOMEM);
00231       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00232       cp[n] = '\0';
00233 
00234       if (_Cif_filetbl[cifd].version == 3) {
00235         n = CIFFILE(cr)->onlen;
00236         if (n > 0) {
00237           cp = CIFFILE(cr)->oname = _Cif_space[mode] (n+1, cifd);
00238           if (cp == NULL)
00239         return (CIF_NOMEM);
00240           if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00241           cp[n] = '\0';
00242         }
00243       }
00244       else {
00245         CIFFILE(cr)->oname = (char *) NULL;
00246       }
00247     }
00248     break;
00249 
00250   case CIF_LABEL:
00251     n = CIFLABEL(cr)->nlen;
00252     cp = CIFLABEL(cr)->name = _Cif_space[mode] (n+1, cifd);
00253     if (cp == NULL)
00254       return (CIF_NOMEM);
00255     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00256     cp[n] = '\0';
00257     break;
00258 
00259   case CIF_ORIG_CMD:
00260     n = CIFOCMD(cr)->nlen;
00261     cp = CIFOCMD(cr)->name = _Cif_space[mode] (n+1, cifd);
00262     if (cp == NULL)
00263       return (CIF_NOMEM);
00264     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00265     cp[n] = '\0';
00266     break;
00267 
00268   case CIF_CDIR:
00269     n = CIFCDIR(cr)->nids;
00270     lp = CIFCDIR(cr)->ids = (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00271     if (lp == NULL)
00272       return (CIF_NOMEM);
00273     if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00274     break;
00275 
00276   case CIF_CDIR_DOSHARED:
00277     n = CIFCDIRDO(cr)->nids;
00278     lp = CIFCDIRDO(cr)->ids = (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00279     if (lp == NULL)
00280       return (CIF_NOMEM);
00281     if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00282     break;
00283 
00284         case CIF_GEOMETRY:
00285     if ((n = CIFGEOM(cr)->ndims) > 0) {
00286       CIFGEOM(cr)->dim =
00287         (struct Cif_geometry_dim *)_Cif_space[mode](sizeof(struct Cif_geometry_dim)*n, cifd);
00288       if (CIFGEOM(cr)->dim == NULL)
00289         return (CIF_NOMEM);
00290       if (fread ((char *)CIFGEOM(cr)->dim, GEOM_SSIZE, n, fd) != n) IO_ERROR;
00291     }
00292     n = CIFGEOM(cr)->nlen;
00293     if (n > 0) {
00294         cp = CIFGEOM(cr)->name = _Cif_space[mode] (n+1, cifd);
00295       if (cp == NULL)
00296           return (CIF_NOMEM);
00297       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00298       cp[n] = '\0';
00299     }
00300     break;
00301 
00302   case CIF_MESSAGE:
00303 
00304     if (_Cif_filetbl[cifd].return_version < 3) {
00305 
00306       if (_Cif_filetbl[cifd].version == 3) {
00307 
00308         /* Read and discard the scoping unit name which exists
00309          * in a V3 CIF but not in V1 or V2 */
00310 
00311         char *tmp;
00312         n = CIFMSG(cr)->nlen;
00313         tmp = _Cif_space[mode] (n +1, cifd);
00314         if (tmp == NULL)
00315       return (CIF_NOMEM);
00316         if (fread (tmp, sizeof(char), n, fd) != n) IO_ERROR;
00317       }
00318 
00319       if (CIFMSG1(cr)->nargs > 0) {
00320         if ((i= read_strlist (cifd,
00321             (int) CIFMSG1(cr)->nargs,
00322             &CIFMSG1(cr)->args, fd)) < 0)
00323       return (i);
00324       }
00325     }
00326     else { /* Version 3 CIF */
00327       if (_Cif_filetbl[cifd].version == 3) {
00328         n = CIFMSG(cr)->nlen;
00329         if (n > 0) {
00330           cp = CIFMSG(cr)->name = _Cif_space[mode] (n+1, cifd);
00331           if (cp == NULL)
00332         return (CIF_NOMEM);
00333           if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00334           cp[n] = '\0';
00335         }
00336       }
00337       else {
00338         CIFMSG(cr)->name = (char *) NULL;
00339       }
00340       if (CIFMSG(cr)->nargs > 0) {
00341         if ((i= read_strlist (cifd,
00342             (int) CIFMSG(cr)->nargs,
00343             &CIFMSG(cr)->args, fd)) < 0)
00344       return (i);
00345       }
00346     }
00347 
00348     break;
00349 
00350   case CIF_MISC_OPTS:
00351 
00352     if (_Cif_filetbl[cifd].return_version == 1) {
00353 
00354       if ((n = CIFMO1(cr)->nmsgs) > 0) {
00355         lp= CIFMO1(cr)->msgno= (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
00356         if (lp == NULL)
00357           return (CIF_NOMEM);
00358         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00359       }
00360       if (CIFMO1(cr)->ncdirs > 0) {
00361         if ((i= read_strlist (cifd, (int) CIFMO1(cr)->ncdirs, &CIFMO1(cr)->cdirs, fd)) < 0)
00362           return (i);
00363       }
00364       n = CIFMO1(cr)->onlen;
00365       cp = CIFMO1(cr)->objname = _Cif_space[mode] (n+1, cifd);
00366       if (cp == NULL)
00367         return (CIF_NOMEM);
00368       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00369       cp[n] = '\0';
00370       n = CIFMO1(cr)->cnlen;
00371       cp = CIFMO1(cr)->calname = _Cif_space[mode] (n+1, cifd);
00372       if (cp == NULL)
00373         return (CIF_NOMEM);
00374       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00375       cp[n] = '\0';
00376       n = CIFMO1(cr)->inlen;
00377       cp = CIFMO1(cr)->inname = _Cif_space[mode] (n+1, cifd);
00378       if (cp == NULL)
00379         return (CIF_NOMEM);
00380       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00381       cp[n] = '\0';
00382     }
00383     else {  /* a v2 cif */
00384 
00385       if ((n = CIFMO(cr)->nmsgs) > 0) {
00386         lp= CIFMO(cr)->msgno= (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
00387         if (lp == NULL)
00388           return (CIF_NOMEM);
00389         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00390       }
00391       if (CIFMO(cr)->ncdirs > 0) {
00392         if ((i= read_strlist (cifd, (int) CIFMO(cr)->ncdirs, &CIFMO(cr)->cdirs, fd)) < 0)
00393           return (i);
00394       }
00395       n = CIFMO(cr)->onlen;
00396       cp = CIFMO(cr)->objname = _Cif_space[mode] (n+1, cifd);
00397       if (cp == NULL)
00398         return (CIF_NOMEM);
00399       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00400       cp[n] = '\0';
00401       n = CIFMO(cr)->cnlen;
00402       cp = CIFMO(cr)->calname = _Cif_space[mode] (n+1, cifd);
00403       if (cp == NULL)
00404         return (CIF_NOMEM);
00405       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00406       cp[n] = '\0';
00407       n = CIFMO(cr)->inlen;
00408       cp = CIFMO(cr)->inname = _Cif_space[mode] (n+1, cifd);
00409       if (cp == NULL)
00410         return (CIF_NOMEM);
00411       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00412       cp[n] = '\0';
00413       n = CIFMO(cr)->llen;
00414       cp = CIFMO(cr)->lname = _Cif_space[mode] (n+1, cifd);
00415       if (cp == NULL)
00416         return (CIF_NOMEM);
00417       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00418       cp[n] = '\0';
00419 
00420       if (CIFMO(cr)->numincs > 0) {
00421         if ((i= read_strlist (cifd, (int) CIFMO(cr)->numincs, &CIFMO(cr)->incdirs, fd)) < 0)
00422           return (i);
00423       }
00424 
00425     }
00426 
00427     break;
00428       
00429   case CIF_NAMELIST:
00430     n = CIFNL(cr)->nlen;
00431     cp = CIFNL(cr)->name = _Cif_space[mode] (n+1, cifd);
00432     if (cp == NULL)
00433       return (CIF_NOMEM);
00434     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00435     cp[n] = '\0';
00436     n = CIFNL(cr)->nids;
00437     lp = CIFNL(cr)->ids = (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00438     if (lp == NULL)
00439       return (CIF_NOMEM);
00440     if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00441     break;
00442 
00443   case CIF_ND_MSG:
00444     if (CIFNMSG(cr)->nargs > 0) {
00445       if ((i = read_strlist (cifd, (int) CIFNMSG(cr)->nargs, &CIFNMSG(cr)->args, fd))
00446         < 0) return (i);
00447     }
00448     break;
00449 
00450   case CIF_OBJECT:
00451     if (_Cif_filetbl[cifd].return_version == 1) {
00452 
00453     if ((n = CIFOBJ1(cr)->nlen) > 0) {
00454       cp = CIFOBJ1(cr)->name = _Cif_space[mode] (n+1, cifd);
00455       if (cp == NULL)
00456         return (CIF_NOMEM);
00457       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00458       cp[n] = '\0';
00459     }
00460     if ((n = CIFOBJ1(cr)->ndims) > 0) {
00461       CIFOBJ1(cr)->dim =
00462         (struct Cif_dim *)_Cif_space[mode] (sizeof(struct Cif_dim)*n, cifd);
00463       if (CIFOBJ1(cr)->dim == NULL)
00464         return (CIF_NOMEM);
00465       if (fread ((char *)CIFOBJ1(cr)->dim, DIM_SSIZE, n, fd) != n) IO_ERROR;
00466     }
00467         }
00468     else {
00469     if ((n = CIFOBJ(cr)->nlen) > 0) {
00470       cp = CIFOBJ(cr)->name = _Cif_space[mode] (n+1, cifd);
00471       if (cp == NULL)
00472         return (CIF_NOMEM);
00473       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00474       cp[n] = '\0';
00475     }
00476     if ((n = CIFOBJ(cr)->ndims) > 0) {
00477       CIFOBJ(cr)->dim =
00478         (struct Cif_dim *)_Cif_space[mode] (sizeof(struct Cif_dim)*n, cifd);
00479       if (CIFOBJ(cr)->dim == NULL)
00480         return (CIF_NOMEM);
00481       if (fread ((char *)CIFOBJ(cr)->dim, DIM_SSIZE, n, fd) != n) IO_ERROR;
00482     }
00483         }
00484     break;
00485 
00486   case CIF_UNIT:
00487     n = CIFUNIT(cr)->nlen;
00488     cp = CIFUNIT(cr)->name = _Cif_space[mode] (n+1, cifd);
00489     if (cp == NULL)
00490       return (CIF_NOMEM);
00491     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00492     cp[n] = '\0';
00493     break;
00494 
00495   case CIF_ENDUNIT:
00496     n = CIFENDU(cr)->nlen;
00497     cp = CIFENDU(cr)->name = _Cif_space[mode] (n+1, cifd);
00498     if (cp == NULL)
00499       return (CIF_NOMEM);
00500     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00501     cp[n] = '\0';
00502     break;
00503 
00504   case CIF_USAGE:
00505     if (_Cif_filetbl[cifd].return_version == 1) {
00506 
00507       n = CIFUSAGE1(cr)->nuses;
00508       CIFUSAGE1(cr)->use =
00509         (struct Cif_use *) _Cif_space[mode] (sizeof(struct Cif_use_1)*n, cifd);
00510       if (CIFUSAGE1(cr)->use == NULL)
00511         return (CIF_NOMEM);
00512       if (fread ((char *)CIFUSAGE1(cr)->use, sizeof(struct Cif_use_1), n, fd)
00513           != n) IO_ERROR;
00514 
00515     }
00516     else { /* a v2 cif */
00517 
00518       n = CIFUSAGE(cr)->nuses;
00519       CIFUSAGE(cr)->use =
00520         (struct Cif_use *) _Cif_space[mode] (sizeof(struct Cif_use)*n, cifd);
00521       if (CIFUSAGE(cr)->use == NULL)
00522         return (CIF_NOMEM);
00523       if (fread ((char *)CIFUSAGE(cr)->use, sizeof(struct Cif_use), n, fd)
00524           != n) IO_ERROR;
00525 
00526       if (CIFUSAGE(cr)->nmembs > 0) {
00527 
00528         n = CIFUSAGE(cr)->nmembs;
00529         CIFUSAGE(cr)->membs = (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
00530         if (CIFUSAGE(cr)->membs == NULL)
00531           return (CIF_NOMEM);
00532         if (fread ((char *)CIFUSAGE(cr)->membs, sizeof(long), n, fd)
00533       != n) IO_ERROR;
00534       }
00535     }
00536     break;
00537 
00538   case CIF_FILEDIR:
00539   {
00540     struct Cif_unittbl *ut;
00541 
00542     n = CIFFDIR(cr)->nunits;
00543     ut = CIFFDIR(cr)->ut = (struct Cif_unittbl *) _Cif_space[mode]
00544                                          (sizeof(struct Cif_unittbl)*n, cifd);
00545     if (ut == NULL)
00546       return (CIF_NOMEM);
00547     (void) memset((char *)ut, 0, n * sizeof(struct Cif_unittbl));
00548     for (i = 0; i < n; i++, ut++) {
00549       if (fread ((char *)ut, UNITTBL_SSIZE, 1, fd) != 1) IO_ERROR;
00550       cp = ut->name = _Cif_space[mode] (ut->nlen+1, cifd);
00551       if (cp == NULL)
00552         return (CIF_NOMEM);
00553       if (fread (cp, sizeof(char), ut->nlen, fd) != ut->nlen) IO_ERROR;
00554       cp[ut->nlen] = '\0';
00555     }
00556     break;
00557   }
00558 
00559   case CIF_UNITDIR:
00560   {
00561     struct Cif_urectbl ur[CIF_MAXRECORD];
00562     struct Cif_urectbl *urp;
00563 
00564     n = sizeof(struct Cif_urectbl) * CIF_MAXRECORD;
00565     urp = CIFUDIR(cr)->ur = (struct Cif_urectbl *) _Cif_space[mode] (n, cifd);
00566     if (urp == NULL)
00567       return(CIF_NOMEM);
00568     (void) memset ((char *)urp, '\0', n);
00569     n = CIFUDIR(cr)->nsections;
00570     if (fread ((char *)ur, sizeof(struct Cif_urectbl), n, fd) != n)
00571       IO_ERROR;
00572     for (i = 0; i < n; i++) {
00573       urp[ur[i].rectype] = ur[i];
00574 
00575       /* mask out those records that this cif version (eg v1) doesn't know about */
00576 
00577       if (_Cif_shortsize[ur[i].rectype][_Cif_filetbl[cifd].return_version] == 0)
00578         urp[ur[i].rectype].nrecords = 0;
00579     }
00580 
00581     /* Only returns the correct number of entries for the version requested */
00582     if (_Cif_filetbl[cifd].return_version == 1)
00583       CIFUDIR(cr)->nsections = CIF_MAXRECORD_1;
00584     else
00585       CIFUDIR(cr)->nsections = CIF_MAXRECORD;
00586 
00587     break;
00588   }
00589 
00590   case CIF_C_TAG:
00591   {
00592     struct Cif_tmod *tm;
00593 
00594     n = CIFCTAG(cr)->nmods;
00595     tm = CIFCTAG(cr)->mods =
00596       (struct Cif_tmod *) _Cif_space[mode] (sizeof(struct Cif_tmod)*n, cifd);
00597     if (tm == NULL)
00598       return (CIF_NOMEM);
00599     for (i = 0; i < n; i++)
00600       if (fread ((char *)&(tm[i]), TMOD_SSIZE, 1, fd) != 1) IO_ERROR;
00601     n = CIFCTAG(cr)-> nmems;
00602     CIFCTAG(cr)->memids = (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
00603     if (CIFCTAG(cr)->memids == NULL)
00604       return (CIF_NOMEM);
00605     if (fread ((char *)CIFCTAG(cr)->memids, sizeof(long), n, fd) != n) 
00606       IO_ERROR;
00607     n = CIFCTAG(cr)->nlen;
00608     CIFCTAG(cr)->name = _Cif_space[mode](n+1, cifd);
00609     if (CIFCTAG(cr)->name == NULL)
00610       return (CIF_NOMEM);
00611     if (fread ((char *)CIFCTAG(cr)->name, sizeof(char), n, fd) != n)
00612       IO_ERROR;
00613     (CIFCTAG(cr)->name)[n] = '\0';
00614     break;
00615   }
00616 
00617   case CIF_C_OPTS:
00618     n = CIFCOPTS(cr)->nlen;
00619     CIFCOPTS(cr)->name = _Cif_space[mode](n+1, cifd);
00620     if (CIFCOPTS(cr)->name == NULL)
00621       return (CIF_NOMEM);
00622     if (fread ((char *)CIFCOPTS(cr)->name, sizeof(char), n, fd) != n)
00623       IO_ERROR;
00624     (CIFCOPTS(cr)->name)[n] = '\0';
00625     if (CIFCOPTS(cr)->nincs > 0) {
00626       if ((i = read_strlist (cifd, (int) CIFCOPTS(cr)->nincs, &CIFCOPTS(cr)->incs, fd))
00627         < 0) return (i);
00628     }
00629     if (CIFCOPTS(cr)->ndefs > 0) {
00630       if ((i = read_strlist (cifd, (int) CIFCOPTS(cr)->ndefs, &CIFCOPTS(cr)->defs, fd))
00631         < 0) return (i);
00632     }
00633     if (CIFCOPTS(cr)->nudefs > 0) {
00634       if ((i = read_strlist (cifd, (int) CIFCOPTS(cr)->nudefs, &CIFCOPTS(cr)->udefs, fd))
00635         < 0) return (i);
00636     }
00637     break;
00638 
00639   case CIF_C_MESSAGE:
00640     if (_Cif_filetbl[cifd].return_version == 1) {
00641       if (CIFCMSG1(cr)->nargs > 0) {
00642         if ((i = read_strlist (cifd, (int) CIFCMSG(cr)->nargs, &CIFCMSG(cr)->args, fd)) < 0)
00643           return (i);
00644       }
00645     }
00646     else {
00647       if (CIFCMSG(cr)->nargs > 0) {
00648         if ((i = read_strlist (cifd, (int) CIFCMSG(cr)->nargs, &CIFCMSG(cr)->args, fd)) < 0)
00649           return (i);
00650       }
00651     }
00652     break;
00653 
00654   case CIF_C_CONST:
00655     n = CIFCCON(cr)->vlen;
00656     CIFCCON(cr)->value = _Cif_space[mode](n+1, cifd);
00657     if (CIFCCON(cr)->value == NULL)
00658       return (CIF_NOMEM);
00659     if (fread ((char *)CIFCCON(cr)->value, sizeof(char), n, fd) != n)
00660       IO_ERROR;
00661     (CIFCCON(cr)->value)[n] = '\0';
00662     break;
00663 
00664   case CIF_C_ENTRY:
00665   {
00666     struct Cif_tmod *tm;
00667 
00668     if (_Cif_filetbl[cifd].return_version == 1) {
00669 
00670       n = CIFCENTRY1(cr)->nmods;
00671       tm = CIFCENTRY1(cr)->mods =
00672         (struct Cif_tmod *) _Cif_space[mode] (sizeof(struct Cif_tmod)*n, cifd);
00673       if (tm == NULL)
00674         return (CIF_NOMEM);
00675       for (i = 0; i < n; i++)
00676         if (fread ((char *)&(tm[i]), TMOD_SSIZE, 1, fd) != 1) IO_ERROR;
00677 
00678       n = CIFCENTRY1(cr)->nargs;
00679       CIFCENTRY1(cr)->argids = (long *) _Cif_space[mode](sizeof(long)*n, cifd);
00680       if (CIFCENTRY1(cr)->argids == NULL)
00681         return (CIF_NOMEM);
00682       if (fread ((char *)CIFCENTRY1(cr)->argids, sizeof(long), n, fd) != n)
00683         IO_ERROR;
00684 
00685       n = CIFCENTRY1(cr)->nlen;
00686       CIFCENTRY1(cr)->name = _Cif_space[mode](n+1, cifd);
00687       if (CIFCENTRY1(cr)->name == NULL)
00688         return (CIF_NOMEM);
00689       if (fread ((char *)CIFCENTRY1(cr)->name, sizeof(char), n, fd) != n)
00690         IO_ERROR;
00691       (CIFCENTRY1(cr)->name)[n] = '\0';
00692     }
00693     else {
00694 
00695       n = CIFCENTRY(cr)->nmods;
00696       tm = CIFCENTRY(cr)->mods =
00697         (struct Cif_tmod *) _Cif_space[mode] (sizeof(struct Cif_tmod)*n, cifd);
00698       if (tm == NULL)
00699         return (CIF_NOMEM);
00700       for (i = 0; i < n; i++)
00701         if (fread ((char *)&(tm[i]), TMOD_SSIZE, 1, fd) != 1) IO_ERROR;
00702 
00703       n = CIFCENTRY(cr)->nargs;
00704       CIFCENTRY(cr)->argids = (long *) _Cif_space[mode](sizeof(long)*n, cifd);
00705       if (CIFCENTRY(cr)->argids == NULL)
00706         return (CIF_NOMEM);
00707       if (fread ((char *)CIFCENTRY(cr)->argids, sizeof(long), n, fd) != n)
00708         IO_ERROR;
00709 
00710       n = CIFCENTRY(cr)->nlen;
00711       CIFCENTRY(cr)->name = _Cif_space[mode](n+1, cifd);
00712       if (CIFCENTRY(cr)->name == NULL)
00713         return (CIF_NOMEM);
00714       if (fread ((char *)CIFCENTRY(cr)->name, sizeof(char), n, fd) != n)
00715         IO_ERROR;
00716       (CIFCENTRY(cr)->name)[n] = '\0';
00717     }
00718 
00719     break;
00720   }
00721 
00722   case CIF_C_OBJECT:
00723   {
00724       struct Cif_tmod *tm;
00725 
00726     n = CIFCOBJ(cr)->nmods;
00727     tm = CIFCOBJ(cr)->mods =
00728         (struct Cif_tmod *) _Cif_space[mode] (sizeof(struct Cif_tmod)*n, cifd);
00729     if (tm == NULL)
00730         return (CIF_NOMEM);
00731     for (i = 0; i < n; i++)
00732         if (fread ((char *)&(tm[i]), TMOD_SSIZE, 1, fd) != 1) IO_ERROR;
00733     if ((n = CIFCOBJ(cr)->nlen) > 0) {
00734         CIFCOBJ(cr)->name = _Cif_space[mode](n+1, cifd);
00735       if (CIFCOBJ(cr)->name == NULL)
00736           return (CIF_NOMEM);
00737       if (fread ((char *)CIFCOBJ(cr)->name, sizeof(char), n, fd) != n)
00738             IO_ERROR;
00739       (CIFCOBJ(cr)->name)[n] = '\0';
00740     }
00741 
00742     break;
00743   }
00744 
00745   case CIF_C_LINT_DIRECTIVE:
00746   {
00747     if ((n = CIFCLDIR(cr)->nlen) > 0) {
00748       CIFCLDIR(cr)->name = _Cif_space[mode](n+1, cifd);
00749       if (CIFCLDIR(cr)->name == NULL)
00750         return (CIF_NOMEM);
00751       if (fread ((char *)CIFCLDIR(cr)->name, sizeof(char), n, fd) != n)
00752         IO_ERROR;
00753       (CIFCLDIR(cr)->name)[n] = '\0';
00754     }
00755 
00756     break;
00757   }
00758 
00759   case CIF_C_MACRO_DEF:
00760   {
00761     if ((n = CIFCMDEF(cr)->nlen) > 0) {
00762       CIFCMDEF(cr)->name = _Cif_space[mode](n+1, cifd);
00763       if (CIFCMDEF(cr)->name == NULL)
00764         return (CIF_NOMEM);
00765       if (fread ((char *)CIFCMDEF(cr)->name, sizeof(char), n, fd) != n)
00766         IO_ERROR;
00767       (CIFCMDEF(cr)->name)[n] = '\0';
00768     }
00769 
00770     break;
00771   }
00772 
00773   case CIF_C_ENTRY_END:
00774   {
00775     if ((n = CIFCEEND(cr)->nlen) > 0) {
00776       CIFCEEND(cr)->name = _Cif_space[mode](n+1, cifd);
00777       if (CIFCEEND(cr)->name == NULL)
00778         return (CIF_NOMEM);
00779       if (fread ((char *)CIFCEEND(cr)->name, sizeof(char), n, fd) != n)
00780         IO_ERROR;
00781       (CIFCEEND(cr)->name)[n] = '\0';
00782     }
00783 
00784     break;
00785   }
00786 
00787 #ifndef CRAY2
00788   case CIF_F90_CALLSITE:
00789     if ((n = CIFF90CS(cr)->nargs) > 0) {
00790       lp= CIFF90CS(cr)->argids= (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00791       if (lp == NULL)
00792         return (CIF_NOMEM);
00793       if (fread ((char *)lp, sizeof(long), n, fd) != n) IO_ERROR;
00794 
00795       lp= (long *) (CIFF90CS(cr)->nmembs=
00796               (int *)_Cif_space[mode] (sizeof(int)*n, cifd));
00797       if (lp == NULL)
00798         return (CIF_NOMEM);
00799       if (fread ((char *)lp, sizeof(int), n, fd) != n) IO_ERROR;
00800       lp= (long *) (CIFF90CS(cr)->membs=
00801               (long **)_Cif_space[mode] (sizeof(long *)*n, cifd));
00802       if (lp == NULL)
00803           return (CIF_NOMEM);
00804 
00805       for (i = 0; i < (int) CIFF90CS(cr)->nargs; i++) {
00806           if (CIFF90CS(cr)->nmembs[i] > 0) {
00807         lp= (long *) (CIFF90CS(cr)->membs[i]=
00808                 (long *)_Cif_space[mode] (sizeof(long)*CIFF90CS(cr)->nmembs[i], cifd));
00809         if (lp == NULL)
00810             return (CIF_NOMEM);
00811         if (fread ((char *)lp, sizeof(long), CIFF90CS(cr)->nmembs[i], fd) != CIFF90CS(cr)->nmembs[i]) IO_ERROR;
00812           }
00813       }
00814 
00815       if (CIFF90CS(cr)->rank == 1) {
00816 
00817           lp= (long *) (CIFF90CS(cr)->ranks = (int *)_Cif_space[mode] (sizeof(int)*n, cifd));
00818           if (lp == NULL)
00819         return (CIF_NOMEM);
00820           if (fread ((char *)lp, sizeof(int), n, fd) != n) IO_ERROR;
00821       }
00822 
00823 
00824         }
00825     break;
00826 
00827   case CIF_F90_SCOPE_INFO:
00828     if ((n = CIFF90SI(cr)->numalts) > 0) {
00829       lp= CIFF90SI(cr)->entryids= (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00830       if (lp == NULL)
00831         return (CIF_NOMEM);
00832       if (fread ((char *)lp, sizeof(long), n, fd) != n) IO_ERROR;
00833     }
00834     break;
00835 
00836   case CIF_F90_COMBLK:
00837     n = CIFF90CB(cr)->nlen;
00838     cp = CIFF90CB(cr)->name = _Cif_space[mode] (n+1, cifd);
00839     if (cp == NULL)
00840       return (CIF_NOMEM);
00841     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00842     cp[n] = '\0';
00843     break;
00844 
00845   case CIF_F90_CONST:
00846     n = CIFF90CON(cr)->vlen;
00847     cp = CIFF90CON(cr)->value = _Cif_space[mode] (n+1, cifd);
00848     if (cp == NULL)
00849       return(CIF_NOMEM);
00850     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00851     cp[n] = '\0';
00852     break;
00853 
00854   case CIF_F90_ENTRY:
00855 
00856     if ((n = CIFF90ENTRY(cr)->nargs) > 0) {
00857       lp = CIFF90ENTRY(cr)->argids = (long *) _Cif_space[mode]
00858                   (sizeof(long)*n, cifd);
00859       if (lp == NULL)
00860         return (CIF_NOMEM);
00861       if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00862     }
00863     n = CIFF90ENTRY(cr)->nlen;
00864     cp = CIFF90ENTRY(cr)->name = _Cif_space[mode] (n+1, cifd);
00865     if (cp == NULL)
00866       return (CIF_NOMEM);
00867     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00868     cp[n] = '\0';
00869     break;
00870 
00871   case CIF_F90_DERIVED_TYPE:
00872     if (_Cif_filetbl[cifd].return_version == 2) {
00873 
00874       n = CIFF90DTYPE2(cr)->nlen;
00875       cp = CIFF90DTYPE2(cr)->name = _Cif_space[mode] (n+1, cifd);
00876       if (cp == NULL)
00877           return (CIF_NOMEM);
00878       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00879       cp[n] = '\0';
00880 
00881       if ((n = CIFF90DTYPE2(cr)->nmembs) > 0) {
00882         lp = CIFF90DTYPE2(cr)->memids = (long *) _Cif_space[mode]
00883       (sizeof(long)*n, cifd);
00884         if (lp == NULL)
00885           return (CIF_NOMEM);
00886         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00887       }
00888     }
00889     else {
00890       n = CIFF90DTYPE(cr)->nlen;
00891       cp = CIFF90DTYPE(cr)->name = _Cif_space[mode] (n+1, cifd);
00892       if (cp == NULL)
00893           return (CIF_NOMEM);
00894       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00895       cp[n] = '\0';
00896 
00897       if ((n = CIFF90DTYPE(cr)->nmembs) > 0) {
00898         lp = CIFF90DTYPE(cr)->memids = (long *) _Cif_space[mode]
00899       (sizeof(long)*n, cifd);
00900         if (lp == NULL)
00901           return (CIF_NOMEM);
00902         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00903       }
00904     }
00905     break;
00906 
00907   case CIF_F90_LABEL:
00908     n = CIFF90LABEL(cr)->nlen;
00909     cp = CIFF90LABEL(cr)->name = _Cif_space[mode] (n+1, cifd);
00910     if (cp == NULL)
00911       return (CIF_NOMEM);
00912     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00913     cp[n] = '\0';
00914     break;
00915 
00916   case CIF_F90_NAMELIST:
00917     n = CIFF90NL(cr)->nlen;
00918     cp = CIFF90NL(cr)->name = _Cif_space[mode] (n+1, cifd);
00919     if (cp == NULL)
00920       return (CIF_NOMEM);
00921     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00922     cp[n] = '\0';
00923     n = CIFF90NL(cr)->nids;
00924     lp = CIFF90NL(cr)->ids = (long *)_Cif_space[mode] (sizeof(long)*n, cifd);
00925     if (lp == NULL)
00926       return (CIF_NOMEM);
00927     if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00928     break;
00929 
00930   case CIF_F90_OBJECT:
00931     if ((n = CIFF90OBJ(cr)->nlen) > 0) {
00932       cp = CIFF90OBJ(cr)->name = _Cif_space[mode] (n+1, cifd);
00933       if (cp == NULL)
00934         return (CIF_NOMEM);
00935       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00936       cp[n] = '\0';
00937     }
00938     if ((n = CIFF90OBJ(cr)->ndims) > 0 &&
00939         CIFF90OBJ(cr)->atype != CIF_AT_DEFERRED) { /* deferred arrays have all
00940                 * dimensions assumed to be ':'
00941                 */
00942       CIFF90OBJ(cr)->dim =
00943         (struct Cif_dim *)_Cif_space[mode] (sizeof(struct Cif_dim)*n, cifd);
00944       if (CIFF90OBJ(cr)->dim == NULL)
00945         return (CIF_NOMEM);
00946       if (fread ((char *)CIFF90OBJ(cr)->dim, DIM_SSIZE, n, fd) != n) IO_ERROR;
00947     }
00948     break;
00949 
00950 
00951    case CIF_F90_MISC_OPTS:
00952     n = CIFF90MO(cr)->ciflen;
00953     cp = CIFF90MO(cr)->cifname = _Cif_space[mode] (n+1, cifd);
00954     if (cp == NULL)
00955       return (CIF_NOMEM);
00956     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00957     cp[n] = '\0';
00958 
00959     if (CIFF90MO(cr)->nPdirs > 0) {
00960       if ((i= read_strlist (cifd, (int) CIFF90MO(cr)->nPdirs, &CIFF90MO(cr)->Pdirs, fd)) < 0)
00961         return (i);
00962     }
00963     if (CIFF90MO(cr)->npdirs > 0) {
00964       if ((i= read_strlist (cifd, (int) CIFF90MO(cr)->npdirs, &CIFF90MO(cr)->pdirs, fd)) < 0)
00965         return (i);
00966     }
00967     if ((n = CIFF90MO(cr)->nmsgs) > 0) {
00968       lp= CIFF90MO(cr)->msgno= (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
00969       if (lp == NULL)
00970         return (CIF_NOMEM);
00971       if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
00972     }
00973     if (CIFF90MO(cr)->ncdirs > 0) {
00974       if ((i= read_strlist (cifd, (int) CIFF90MO(cr)->ncdirs, &CIFF90MO(cr)->cdirs, fd)) < 0)
00975         return (i);
00976     }
00977     n = CIFF90MO(cr)->onlen;
00978     cp = CIFF90MO(cr)->objname = _Cif_space[mode] (n+1, cifd);
00979     if (cp == NULL)
00980       return (CIF_NOMEM);
00981     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00982     cp[n] = '\0';
00983     n = CIFF90MO(cr)->cnlen;
00984     cp = CIFF90MO(cr)->calname = _Cif_space[mode] (n+1, cifd);
00985     if (cp == NULL)
00986       return (CIF_NOMEM);
00987     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00988     cp[n] = '\0';
00989     n = CIFF90MO(cr)->inlen;
00990     cp = CIFF90MO(cr)->inname = _Cif_space[mode] (n+1, cifd);
00991     if (cp == NULL)
00992       return (CIF_NOMEM);
00993     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
00994     cp[n] = '\0';
00995     break;
00996 
00997   case CIF_F90_OPT_OPTS:
00998 
00999     if ((n = CIFF90OPTOPT(cr)->noptlevels) > 0) {
01000       CIFF90OPTOPT(cr)->lopts =
01001         (struct Cif_f90_level_opts *)_Cif_space[mode] (sizeof(struct Cif_f90_level_opts)*n, cifd);
01002       if (CIFF90OPTOPT(cr)->lopts == NULL)
01003         return (CIF_NOMEM);
01004       if (CIFF90OPTOPT(cr)->newdef == 1) {
01005           if (fread ((char *)CIFF90OPTOPT(cr)->lopts, OPTS_SSIZE, n, fd) != n) IO_ERROR;
01006       }
01007       else {
01008           if (fread ((char *)CIFF90OPTOPT(cr)->lopts, 4, n, fd) != n) IO_ERROR;
01009       }
01010     }
01011     break;
01012 
01013       case CIF_F90_INT_BLOCK:
01014     if (_Cif_filetbl[cifd].return_version == 2) {
01015 
01016       n = CIFF90IB2(cr)->nlen;
01017       cp = CIFF90IB2(cr)->name = _Cif_space[mode] (n+1, cifd);
01018       if (cp == NULL)
01019           return (CIF_NOMEM);
01020       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
01021       cp[n] = '\0';
01022 
01023       if ((n = CIFF90IB2(cr)->numints) > 0) {
01024         lp= CIFF90IB2(cr)->procids= (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
01025         if (lp == NULL)
01026       return (CIF_NOMEM);
01027         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
01028       }
01029     }
01030     else { /* Version 3 or beyond */
01031 
01032       n = CIFF90IB(cr)->nlen;
01033       cp = CIFF90IB(cr)->name = _Cif_space[mode] (n+1, cifd);
01034       if (cp == NULL)
01035           return (CIF_NOMEM);
01036       if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
01037       cp[n] = '\0';
01038 
01039       if ((n = CIFF90IB(cr)->numints) > 0) {
01040         lp= CIFF90IB(cr)->procids= (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
01041         if (lp == NULL)
01042       return (CIF_NOMEM);
01043         if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
01044       }
01045     }
01046     break;
01047 
01048       case CIF_F90_RENAME:
01049 
01050     n = CIFF90RN(cr)->nlen;
01051     cp = CIFF90RN(cr)->name = _Cif_space[mode] (n+1, cifd);
01052     if (cp == NULL)
01053       return (CIF_NOMEM);
01054     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
01055     cp[n] = '\0';
01056 
01057     n = CIFF90RN(cr)->orignlen;
01058     cp = CIFF90RN(cr)->origname = _Cif_space[mode] (n+1, cifd);
01059     if (cp == NULL)
01060       return (CIF_NOMEM);
01061     if (fread (cp, sizeof(char), n, fd) != n) IO_ERROR;
01062     cp[n] = '\0';
01063 
01064     if ((n = CIFF90RN(cr)->nlocalids) > 0) {
01065       lp= CIFF90RN(cr)->localid = (long *) _Cif_space[mode] (sizeof(long)*n, cifd);
01066       if (lp == NULL)
01067         return (CIF_NOMEM);
01068       if (fread (lp, sizeof(long), n, fd) != n) IO_ERROR;
01069     }
01070     break;
01071 
01072   case CIF_CC_TYPE:
01073     n = CIFCCTYPE(cr)->nlen;
01074     cp = CIFCCTYPE(cr)->name = _Cif_space[mode] (n+1, cifd);
01075     if (cp == NULL)
01076       return (CIF_NOMEM);
01077     if (fread (cp, sizeof(char), n, fd) != n)
01078         IO_ERROR;
01079     cp[n] = '\0';
01080 
01081     if ( (n = CIFCCTYPE(cr)->nmem) > 0 ) {
01082         cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01083         if ( cp == NULL )
01084       return( CIF_NOMEM );
01085         CIFCCTYPE(cr)->mem = (int *) cp;
01086         if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01087       IO_ERROR;
01088     }
01089     break;
01090 
01091   case CIF_CC_ENTRY:
01092     n = CIFCCENT(cr)->nlen;
01093     cp = CIFCCENT(cr)->name = _Cif_space[mode] (n+1, cifd);
01094     if (cp == NULL)
01095       return (CIF_NOMEM);
01096     if (fread (cp, sizeof(char), n, fd) != n)
01097         IO_ERROR;
01098     cp[n] = '\0';
01099 
01100     n = CIFCCENT(cr)->elen;
01101     cp = CIFCCENT(cr)->ename = _Cif_space[mode] (n+1, cifd);
01102     if (cp == NULL)
01103       return (CIF_NOMEM);
01104     if (fread (cp, sizeof(char), n, fd) != n)
01105         IO_ERROR;
01106     cp[n] = '\0';
01107 
01108     if ( (n = CIFCCENT(cr)->nparam) > 0 ) {
01109         cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01110         if ( cp == NULL )
01111       return( CIF_NOMEM );
01112         CIFCCENT(cr)->param = (int *) cp;
01113         if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01114       IO_ERROR;
01115     }
01116     break;
01117 
01118   case CIF_CC_OBJ:
01119     n = CIFCCOBJ(cr)->nlen;
01120     cp = CIFCCOBJ(cr)->name = _Cif_space[mode] (n+1, cifd);
01121     if (cp == NULL)
01122       return (CIF_NOMEM);
01123     if (fread (cp, sizeof(char), n, fd) != n)
01124         IO_ERROR;
01125     cp[n] = '\0';
01126     break;
01127 
01128   case CIF_CC_ENUM:
01129     n = CIFCCENUM(cr)->nlen;
01130     cp = CIFCCENUM(cr)->name = _Cif_space[mode] (n+1, cifd);
01131     if (cp == NULL)
01132       return (CIF_NOMEM);
01133     if (fread (cp, sizeof(char), n, fd) != n)
01134         IO_ERROR;
01135     cp[n] = '\0';
01136     n = CIFCCENUM(cr)->vlen;
01137     cp = CIFCCENUM(cr)->value = _Cif_space[mode] (n+1, cifd);
01138     if (cp == NULL)
01139       return (CIF_NOMEM);
01140     if (fread (cp, sizeof(char), n, fd) != n)
01141         IO_ERROR;
01142     cp[n] = '\0';
01143     break;
01144 
01145   case CIF_CC_EXPR:
01146     if ( (n = CIFCCEXPR(cr)->noper) > 0 ) {
01147         cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01148         if ( cp == NULL )
01149       return( CIF_NOMEM );
01150         CIFCCEXPR(cr)->oper = (int *) cp;
01151         if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01152       IO_ERROR;
01153     }
01154     break;
01155 
01156   case CIF_BE_NODE:
01157     if ( _Cif_filetbl[cifd].return_version == 2 ) {
01158         if ( (n = CIFBENODE2(cr)->nsuccs) > 0 ) {
01159       cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01160       if ( cp == NULL )
01161           return( CIF_NOMEM );
01162       CIFBENODE2(cr)->succs = (int *) cp;
01163       if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01164           IO_ERROR;
01165         }
01166         if ( (n = CIFBENODE2(cr)->nlines) > 0 ) {
01167       if ( _Cif_filetbl[cifd].version == 3 ) {
01168           /* Read and discard file ids 
01169            * which exist in a V3 CIF but not in V2 */
01170           cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01171           if ( cp == NULL )
01172         return( CIF_NOMEM );
01173           if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01174         IO_ERROR;
01175           free( cp );
01176       }
01177       cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01178       if ( cp == NULL )
01179           return( CIF_NOMEM );
01180       CIFBENODE2(cr)->lines = (int *) cp;
01181       if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01182           IO_ERROR;
01183         }
01184         if ( (int) fread( &c, 1, 1, fd ) < 1 )
01185       IO_ERROR;
01186         n = c;
01187         cp = _Cif_space[ mode ]( n+1, cifd );
01188       if ( cp == NULL )
01189           return( CIF_NOMEM );
01190         CIFBENODE2(cr)->label = cp;
01191         if ( (int) fread( cp, 1, n, fd ) < n )
01192       IO_ERROR;
01193         cp[ n ] = 0;
01194     }
01195     else { /* Version 3 or beyond */
01196         if ( (n = CIFBENODE(cr)->nsuccs) > 0 ) {
01197       cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01198       if ( cp == NULL )
01199           return( CIF_NOMEM );
01200       CIFBENODE(cr)->succs = (int *) cp;
01201       if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01202           IO_ERROR;
01203         }
01204         if ( (n = CIFBENODE(cr)->nlines) > 0 ) {
01205       cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01206       if ( cp == NULL )
01207           return( CIF_NOMEM );
01208       CIFBENODE(cr)->fid = (int *) cp;
01209       if ( _Cif_filetbl[cifd].version == 2 ) {
01210           for ( i = 0; i < n; i++ )
01211         CIFBENODE(cr)->fid[ i ] = 0;
01212       } else {
01213           if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01214         IO_ERROR;
01215       }
01216       cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01217       if ( cp == NULL )
01218           return( CIF_NOMEM );
01219       CIFBENODE(cr)->lines = (int *) cp;
01220       if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01221           IO_ERROR;
01222         }
01223         if ( (int) fread( &c, 1, 1, fd ) < 1 )
01224       IO_ERROR;
01225         n = c;
01226         assert( n >= 0 && n < 255 );
01227         cp = _Cif_space[ mode ]( n+1, cifd );
01228       if ( cp == NULL )
01229           return( CIF_NOMEM );
01230         CIFBENODE(cr)->label = cp;
01231         if ( (int) fread( cp, 1, n, fd ) < n )
01232       IO_ERROR;
01233         cp[ n ] = 0;
01234     }
01235     break;
01236 
01237   case CIF_BE_FID:
01238     if ( (n = CIFBEFID(cr)->nfid) > 0 ) {
01239         cp = _Cif_space[ mode ]( n * sizeof( int ), cifd );
01240         if ( cp == NULL )
01241       return( CIF_NOMEM );
01242         CIFBEFID(cr)->fid = (int *) cp;
01243         if ( (int) fread( cp, sizeof( int ), n, fd ) < n )
01244       IO_ERROR;
01245     }
01246     break;
01247 
01248 #endif
01249 
01250 
01251   case CIF_MACH_CHAR:
01252     if (_Cif_filetbl[cifd].lang == CIF_LG_F77) {
01253       if (_Cif_filetbl[cifd].return_version == 1) {
01254 
01255         /*
01256          * We have the correct bits, but some of them could
01257          * not be set in v1, so mask those out
01258          */
01259 #ifdef CRAY2
01260         /*
01261          * On a Cray2, TAILGT was 0x01 in v1, it is now 0x02
01262          * It is the only valid cray2 value for a v1 cif
01263          */
01264         if (CIFMC1(cr)->valmask | CIF_MC_TAILGT_1)  {
01265           CIFMC1(cr)->valmask = CIF_MC_TAILGT;
01266         }
01267         else {
01268           CIFMC1(cr)->valmask = 0;
01269         }
01270 #else  /* Non-Cray2 have more bits to mask out */
01271         CIFMC1(cr)->valmask = CIFMC1(cr)->valmask & CIF_MC_MASK;
01272 #endif /* CRAY2 */
01273 
01274       } /* else, v2, no change required to value mask */
01275           } /* else, f90 or C, no change required to the value mask */
01276 
01277     break;
01278 
01279   default:
01280     break;
01281 
01282   }
01283 
01284   return (0);
01285 
01286 }