|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
|
Open64 (mfef90, whirl2f, and IR tools)
TAG: version-openad; SVN changeset: 916
|
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 }
1.7.6.1 
