|
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/cifdup.c 30.5 07/26/96 07:19:13"; 00038 00039 00040 /* 00041 * Cif_Duplicate copies the input Cif structure to newly malloc'd space. 00042 */ 00043 00044 #define CIF_VERSION 3 00045 00046 #ifdef _ABSOFT 00047 #include "cif.h" 00048 #else 00049 #include <cif.h> 00050 #endif 00051 00052 #include <stdlib.h> 00053 #include <stdio.h> 00054 #include <string.h> 00055 00056 #include "cif_int.h" 00057 00058 extern char *strdup(const char *s); 00059 00060 struct Cif_generic *Cif_Duplicate 00061 #ifdef __STDC__ 00062 (struct Cif_generic *cr) 00063 #else 00064 (cr) 00065 struct Cif_generic *cr; 00066 #endif 00067 { 00068 00069 register int i, rectype, size; 00070 struct Cif_generic *ncr; 00071 char *cp, *ncp; 00072 00073 /* Copy the basic structure */ 00074 00075 rectype = cr->rectype; 00076 if (rectype < 0 || rectype > CIF_MAXRECORD) 00077 return (NULL); 00078 if ((size = _Cif_structsize[rectype][_cif_version]) == 0) 00079 return (NULL); 00080 if ((ncr = (struct Cif_generic *)malloc(size)) == NULL) 00081 return (NULL); 00082 (void) memcpy ((char *)ncr, (char *)cr, size); 00083 00084 /* Copy other items associated with each particular structure */ 00085 00086 switch (rectype) { 00087 00088 case CIF_CALLSITE: 00089 if ((size = CIFCS(cr)->nargs) > 0) { 00090 if ((CIFCS(ncr)->argids = (long *) malloc (sizeof(long *)*size)) 00091 == NULL) return (NULL); 00092 for (i=0; i < size; i++) 00093 (CIFCS(ncr)->argids)[i] = (CIFCS(cr)->argids)[i]; 00094 } 00095 break; 00096 00097 case CIF_COMBLK: 00098 if (_cif_version == 1) { /* must use v1 cif records */ 00099 if ((CIFCB1(ncr)->name = strdup (CIFCB1(cr)->name)) == NULL) 00100 return (NULL); 00101 } 00102 else { /* use v2 cif record2 */ 00103 if ((CIFCB(ncr)->name = strdup (CIFCB(cr)->name)) == NULL) 00104 return (NULL); 00105 } 00106 break; 00107 00108 case CIF_CONST: 00109 if ((CIFCON(ncr)->name = strdup (CIFCON(cr)->name)) == NULL) 00110 return (NULL); 00111 if ((CIFCON(ncr)->value = strdup (CIFCON(cr)->value)) == NULL) 00112 return (NULL); 00113 if (CIFCON(cr)->origform) 00114 if ((CIFCON(ncr)->oform = strdup (CIFCON(cr)->oform)) == NULL) 00115 return (NULL); 00116 break; 00117 00118 case CIF_ENTRY: 00119 if ((CIFENTRY(ncr)->name = strdup (CIFENTRY(cr)->name)) == NULL) 00120 return (NULL); 00121 if ((size = CIFENTRY(cr)->nargs) > 0) { 00122 if ((CIFENTRY(ncr)->argids = (long *) malloc (sizeof(long *)*size)) 00123 == NULL) return (NULL); 00124 for (i=0; i < size; i++) 00125 (CIFENTRY(ncr)->argids)[i] = (CIFENTRY(cr)->argids)[i]; 00126 } 00127 break; 00128 00129 case CIF_CDIR: 00130 if ((size = CIFCDIR(cr)->nids) > 0) { 00131 if ((CIFCDIR(ncr)->ids = (long *) malloc (sizeof(long *)*size)) 00132 == NULL) return (NULL); 00133 for (i=0; i < size; i++) 00134 (CIFCDIR(ncr)->ids)[i] = (CIFCDIR(cr)->ids)[i]; 00135 } 00136 break; 00137 00138 case CIF_CDIR_DOSHARED: 00139 if ((size = CIFCDIRDO(cr)->nids) > 0) { 00140 if ((CIFCDIRDO(ncr)->ids = (long *) malloc (sizeof(long *)*size)) 00141 == NULL) return (NULL); 00142 for (i=0; i < size; i++) 00143 (CIFCDIRDO(ncr)->ids)[i] = (CIFCDIRDO(cr)->ids)[i]; 00144 } 00145 break; 00146 00147 case CIF_GEOMETRY: 00148 if (CIFGEOM(cr)->ndims > 0) { 00149 size = sizeof(struct Cif_geometry_dim) * CIFGEOM(cr)->ndims; 00150 if ((CIFGEOM(ncr)->dim = (struct Cif_geometry_dim *) malloc (size)) == NULL) 00151 return (NULL); 00152 (void) memcpy ((char *)CIFGEOM(ncr)->dim, (char *)CIFGEOM(cr)->dim,size); 00153 00154 } 00155 if (CIFGEOM(cr)->name != (char *) NULL) 00156 CIFGEOM(ncr)->name = strdup (CIFGEOM(cr)->name); 00157 break; 00158 00159 case CIF_FILE: 00160 if (_cif_version == 3) { 00161 00162 if ((CIFFILE(ncr)->name = strdup (CIFFILE(cr)->name)) == NULL) 00163 return(NULL); 00164 00165 if (CIFFILE(cr)->oname == NULL) 00166 CIFFILE(ncr)->oname = NULL; 00167 else 00168 if ((CIFFILE(ncr)->oname = strdup (CIFFILE(cr)->oname)) == NULL) 00169 return(NULL); 00170 } 00171 else { /* must use v1/v2 version of the cif_file record */ 00172 00173 if ((CIFFILE1(ncr)->name = strdup (CIFFILE1(cr)->name)) == NULL) 00174 return(NULL); 00175 00176 } 00177 break; 00178 00179 case CIF_LABEL: 00180 if ((CIFLABEL(ncr)->name = strdup (CIFLABEL(cr)->name)) == NULL) 00181 return(NULL); 00182 break; 00183 00184 case CIF_ORIG_CMD: 00185 if ((CIFOCMD(ncr)->name = strdup (CIFOCMD(cr)->name)) == NULL) 00186 return(NULL); 00187 break; 00188 00189 00190 case CIF_MESSAGE: 00191 if (_cif_version < 3) { /* must use v1/2 cif records */ 00192 00193 if ((size = CIFMSG1(cr)->nargs) > 0) { 00194 if ((CIFMSG1(ncr)->args = (char **) malloc (sizeof(char *)*size)) 00195 == NULL) return (NULL); 00196 for (i = 0; i < size; i++) 00197 if (((CIFMSG1(ncr)->args)[i] = strdup ((CIFMSG1(cr)->args)[i])) 00198 == NULL) return (NULL); 00199 } 00200 } 00201 else { /* V3 CIF */ 00202 00203 if (CIFMSG(cr)->nlen > 0 && 00204 (CIFMSG(ncr)->name = strdup (CIFMSG(cr)->name)) == NULL) 00205 return(NULL); 00206 00207 if ((size = CIFMSG(cr)->nargs) > 0) { 00208 if ((CIFMSG(ncr)->args = (char **) malloc (sizeof(char *)*size)) 00209 == NULL) return (NULL); 00210 for (i = 0; i < size; i++) 00211 if (((CIFMSG(ncr)->args)[i] = strdup ((CIFMSG(cr)->args)[i])) 00212 == NULL) return (NULL); 00213 } 00214 00215 } 00216 break; 00217 00218 case CIF_MISC_OPTS: 00219 00220 if (_cif_version == 1) { /* must use v1 cif records */ 00221 00222 if ((size = CIFMO1(cr)->nmsgs) > 0) { 00223 if ((CIFMO1(ncr)->msgno = (long *) malloc (sizeof(long)*size)) 00224 == NULL) return (NULL); 00225 (void) memcpy ((char *)CIFMO1(ncr)->msgno, (char *)CIFMO1(cr)->msgno, 00226 sizeof(long)*size); 00227 } 00228 if ((size = CIFMO1(cr)->ncdirs) > 0) { 00229 if ((CIFMO1(ncr)->cdirs = (char **) malloc (sizeof(char *)*size)) 00230 == NULL) return (NULL); 00231 for (i = 0; i < size; i++) 00232 if (((CIFMO1(ncr)->cdirs)[i] = strdup ((CIFMO1(cr)->cdirs)[i])) 00233 == NULL) return (NULL); 00234 } 00235 if (CIFMO1(cr)->objname != NULL) 00236 if ((CIFMO1(ncr)->objname = strdup (CIFMO1(cr)->objname)) == NULL) 00237 return(NULL); 00238 if (CIFMO1(cr)->calname != NULL) 00239 if ((CIFMO1(ncr)->calname = strdup (CIFMO1(cr)->calname)) == NULL) 00240 return(NULL); 00241 if (CIFMO1(cr)->inname != NULL) 00242 if ((CIFMO1(ncr)->inname = strdup (CIFMO1(cr)->inname)) == NULL) 00243 return(NULL); 00244 00245 } 00246 else { /* use v2 cif records */ 00247 00248 00249 if ((size = CIFMO(cr)->nmsgs) > 0) { 00250 if ((CIFMO(ncr)->msgno = (long *) malloc (sizeof(long)*size)) 00251 == NULL) return (NULL); 00252 (void) memcpy ((char *)CIFMO(ncr)->msgno, (char *)CIFMO(cr)->msgno, 00253 sizeof(long)*size); 00254 } 00255 if ((size = CIFMO(cr)->ncdirs) > 0) { 00256 if ((CIFMO(ncr)->cdirs = (char **) malloc (sizeof(char *)*size)) 00257 == NULL) return (NULL); 00258 for (i = 0; i < size; i++) 00259 if (((CIFMO(ncr)->cdirs)[i] = strdup ((CIFMO(cr)->cdirs)[i])) 00260 == NULL) return (NULL); 00261 } 00262 if ((size = CIFMO(cr)->numincs) > 0) { 00263 if ((CIFMO(ncr)->incdirs = (char **) malloc (sizeof(char *)*size)) 00264 == NULL) return (NULL); 00265 for (i = 0; i < size; i++) 00266 if (((CIFMO(ncr)->incdirs)[i] = strdup ((CIFMO(cr)->incdirs)[i])) 00267 == NULL) return (NULL); 00268 } 00269 if (CIFMO(cr)->objname != NULL) 00270 if ((CIFMO(ncr)->objname = strdup (CIFMO(cr)->objname)) == NULL) 00271 return(NULL); 00272 if (CIFMO(cr)->lname != NULL) 00273 if ((CIFMO(ncr)->lname = strdup (CIFMO(cr)->lname)) == NULL) 00274 return(NULL); 00275 if (CIFMO(cr)->calname != NULL) 00276 if ((CIFMO(ncr)->calname = strdup (CIFMO(cr)->calname)) == NULL) 00277 return(NULL); 00278 if (CIFMO(cr)->inname != NULL) 00279 if ((CIFMO(ncr)->inname = strdup (CIFMO(cr)->inname)) == NULL) 00280 return(NULL); 00281 00282 00283 } 00284 break; 00285 00286 case CIF_NAMELIST: 00287 if ((CIFNL(ncr)->name = strdup (CIFNL(cr)->name)) == NULL) 00288 return (NULL); 00289 size = sizeof(long) * CIFNL(cr)->nids; 00290 if ((CIFNL(ncr)->ids = (long *) malloc (size)) == NULL) return (NULL); 00291 for (i = 0; i < (int) CIFNL(cr)->nids; i++) 00292 (CIFNL(ncr)->ids)[i] = (CIFNL(cr)->ids)[i]; 00293 break; 00294 00295 case CIF_ND_MSG: 00296 if ((size = CIFNMSG(cr)->nargs) > 0) { 00297 if ((CIFNMSG(ncr)->args = (char **) malloc (sizeof(char *)*size)) 00298 == NULL) return (NULL); 00299 for (i = 0; i < size; i++) 00300 if (((CIFNMSG(ncr)->args)[i] = strdup ((CIFNMSG(cr)->args)[i])) 00301 == NULL) return (NULL); 00302 } 00303 break; 00304 00305 case CIF_OBJECT: 00306 if (_cif_version == 1) { /* must use v1 cif records */ 00307 00308 if (CIFOBJ1(cr)->name != NULL) 00309 if ((CIFOBJ1(ncr)->name = strdup (CIFOBJ1(cr)->name)) == NULL) 00310 return(NULL); 00311 if (CIFOBJ1(cr)->ndims > 0) { 00312 size = sizeof(struct Cif_dim) * CIFOBJ1(cr)->ndims; 00313 if ((CIFOBJ1(ncr)->dim = (struct Cif_dim *) malloc (size)) == NULL) 00314 return (NULL); 00315 (void) memcpy ((char *)CIFOBJ1(ncr)->dim, (char *)CIFOBJ1(cr)->dim,size); 00316 } 00317 } 00318 else { /* use v2 cif records */ 00319 00320 if (CIFOBJ(cr)->name != NULL) 00321 if ((CIFOBJ(ncr)->name = strdup (CIFOBJ(cr)->name)) == NULL) 00322 return(NULL); 00323 if (CIFOBJ(cr)->ndims > 0) { 00324 size = sizeof(struct Cif_dim) * CIFOBJ(cr)->ndims; 00325 if ((CIFOBJ(ncr)->dim = (struct Cif_dim *) malloc (size)) == NULL) 00326 return (NULL); 00327 (void) memcpy ((char *)CIFOBJ(ncr)->dim, (char *)CIFOBJ(cr)->dim,size); 00328 } 00329 00330 } 00331 break; 00332 00333 case CIF_UNIT: 00334 if ((CIFUNIT(ncr)->name = strdup (CIFUNIT(cr)->name)) == NULL) 00335 return (NULL); 00336 break; 00337 00338 case CIF_ENDUNIT: 00339 if ((CIFENDU(ncr)->name = strdup (CIFENDU(cr)->name)) == NULL) 00340 return (NULL); 00341 break; 00342 00343 case CIF_USAGE: 00344 if (_cif_version == 1) { /* must use v1 cif records */ 00345 00346 size = sizeof(struct Cif_use) * CIFUSAGE1(cr)->nuses; 00347 if ((CIFUSAGE1(ncr)->use = (struct Cif_use *) malloc (size)) == NULL) 00348 return (NULL); 00349 (void) memcpy ((char *)CIFUSAGE1(ncr)->use, (char *)CIFUSAGE1(cr)->use, 00350 size); 00351 00352 } 00353 else { /* use v2 cif records */ 00354 00355 size = sizeof(struct Cif_use) * CIFUSAGE(cr)->nuses; 00356 if ((CIFUSAGE(ncr)->use = (struct Cif_use *) malloc (size)) == NULL) 00357 return (NULL); 00358 (void) memcpy ((char *)CIFUSAGE(ncr)->use, (char *)CIFUSAGE(cr)->use, 00359 size); 00360 if (CIFUSAGE(cr)->nmembs > 0) { 00361 size = sizeof(long) * CIFUSAGE(cr)->nmembs; 00362 if ((CIFUSAGE(ncr)->membs = (long *) malloc (size)) == NULL) 00363 return (NULL); 00364 (void) memcpy ((char *)CIFUSAGE(ncr)->membs, (char *)CIFUSAGE(cr)->membs, 00365 size); 00366 } 00367 00368 } 00369 00370 break; 00371 00372 case CIF_FILEDIR: 00373 { 00374 struct Cif_unittbl *nut, *ut; 00375 00376 size = sizeof(struct Cif_unittbl) * CIFFDIR(cr)->nunits; 00377 ut = CIFFDIR(cr)->ut; 00378 if ((nut = CIFFDIR(ncr)->ut = (struct Cif_unittbl *)malloc (size)) 00379 == NULL) return (NULL); 00380 (void) memcpy ((char *)nut, (char *)ut, size); 00381 for (i = 0; i < (int) CIFFDIR(cr)->nunits; i++) 00382 if ((nut[i].name = strdup (ut[i].name)) == NULL) return (NULL); 00383 break; 00384 } 00385 00386 case CIF_UNITDIR: 00387 size = sizeof(struct Cif_urectbl) * CIFUDIR(cr)->nsections; 00388 if ((CIFUDIR(ncr)->ur = (struct Cif_urectbl *) malloc (size)) 00389 == NULL) return (NULL); 00390 (void) memcpy ((char *)CIFUDIR(ncr)->ur, (char *)CIFUDIR(cr)->ur, size); 00391 break; 00392 00393 case CIF_C_TAG: 00394 if (CIFCTAG(cr)->nmods > 0) { 00395 size = sizeof(struct Cif_tmod) * CIFCTAG(cr)->nmods; 00396 if ((CIFCTAG(ncr)->mods = (struct Cif_tmod *) malloc (size)) 00397 == NULL) return (NULL); 00398 (void) memcpy ((char *)CIFCTAG(ncr)->mods, (char *)CIFCTAG(cr)->mods, 00399 size); 00400 } 00401 if (CIFCTAG(cr)->nmems > 0) { 00402 size = sizeof(long) * CIFCTAG(cr)->nmems; 00403 if ((CIFCTAG(ncr)->memids = (long *) malloc (size)) == NULL) 00404 return (NULL); 00405 (void) memcpy ((char *)CIFCTAG(ncr)->memids, 00406 (char *)CIFCTAG(cr)->memids, 00407 size); 00408 } 00409 if ((CIFCTAG(ncr)->name = strdup (CIFCTAG(cr)->name)) == NULL) 00410 return (NULL); 00411 break; 00412 00413 case CIF_C_OPTS: 00414 { 00415 char **ncp, **cp; 00416 00417 if ((CIFCOPTS(ncr)->name = strdup (CIFCOPTS(cr)->name)) == NULL) 00418 return (NULL); 00419 if (CIFCOPTS(cr)->nincs > 0) { 00420 cp = CIFCOPTS(cr)->incs; 00421 size = CIFCOPTS(cr)->nincs; 00422 if ((ncp = (char **)malloc(sizeof(char *)*size)) == NULL) 00423 return (NULL); 00424 CIFCOPTS(ncr)->incs = ncp; 00425 for (i = 0; i < size; i++) 00426 if ((ncp[i] = strdup (cp[i])) == NULL) return (NULL); 00427 } 00428 if (CIFCOPTS(cr)->ndefs > 0) { 00429 cp = CIFCOPTS(cr)->defs; 00430 size = CIFCOPTS(cr)->ndefs; 00431 if ((ncp = (char **)malloc(sizeof(char *)*size)) == NULL) 00432 return (NULL); 00433 CIFCOPTS(ncr)->defs = ncp; 00434 for (i = 0; i < size; i++) 00435 if ((ncp[i] = strdup (cp[i])) == NULL) return (NULL); 00436 } 00437 if (CIFCOPTS(cr)->nudefs > 0) { 00438 cp = CIFCOPTS(cr)->udefs; 00439 size = CIFCOPTS(cr)->nudefs; 00440 if ((ncp = (char **)malloc(sizeof(char *)*size)) == NULL) 00441 return (NULL); 00442 CIFCOPTS(ncr)->udefs = ncp; 00443 for (i = 0; i < size; i++) 00444 if ((ncp[i] = strdup (cp[i])) == NULL) return (NULL); 00445 } 00446 break; 00447 } 00448 00449 case CIF_C_MESSAGE: 00450 00451 if (_cif_version == 1) { /* must use v1 cif records */ 00452 00453 if ((size = CIFCMSG1(cr)->nargs) > 0) { 00454 if ((CIFCMSG1(ncr)->args = (char **) malloc (sizeof(char *)*size)) 00455 == NULL) return (NULL); 00456 for (i = 0; i < size; i++) 00457 if (((CIFCMSG1(cr)->args)[i] = 00458 strdup ((CIFCMSG1(cr)->args)[i])) 00459 == NULL) return (NULL); 00460 } 00461 00462 } 00463 else { /* use v2 cif records */ 00464 00465 if ((size = CIFCMSG(cr)->nargs) > 0) { 00466 if ((CIFCMSG(ncr)->args = (char **) malloc (sizeof(char *)*size)) 00467 == NULL) return (NULL); 00468 for (i = 0; i < size; i++) 00469 if (((CIFCMSG(cr)->args)[i] = strdup ((CIFCMSG(cr)->args)[i])) 00470 == NULL) return (NULL); 00471 } 00472 00473 } 00474 break; 00475 00476 case CIF_C_CONST: 00477 if ((CIFCCON(ncr)->value = strdup (CIFCCON(cr)->value)) == NULL) 00478 return (NULL); 00479 break; 00480 00481 case CIF_C_ENTRY: 00482 00483 if (_cif_version == 1) { /* must use v1 cif records */ 00484 00485 if (CIFCENTRY1(cr)->nmods > 0) { 00486 size = sizeof(struct Cif_tmod) * CIFCENTRY1(cr)->nmods; 00487 if ((CIFCENTRY1(ncr)->mods = (struct Cif_tmod *) malloc (size)) 00488 == NULL) return (NULL); 00489 (void) memcpy ((char *)CIFCENTRY1(ncr)->mods, 00490 (char *)CIFCENTRY1(cr)->mods, 00491 size); 00492 } 00493 00494 if (CIFCENTRY1(cr)->nargs > 0) { 00495 size = sizeof(long) * CIFCENTRY1(cr)->nargs; 00496 if ((CIFCENTRY1(ncr)->argids = (long *) malloc (size)) == NULL) 00497 return (NULL); 00498 (void) memcpy ((char *)CIFCENTRY1(ncr)->argids, 00499 (char *)CIFCENTRY1(cr)->argids, 00500 size); 00501 } 00502 if ((CIFCENTRY1(ncr)->name = strdup (CIFCENTRY1(cr)->name)) == NULL) 00503 return (NULL); 00504 00505 } 00506 else { /* use v2 cif records */ 00507 00508 if (CIFCENTRY(cr)->nmods > 0) { 00509 size = sizeof(struct Cif_tmod) * CIFCENTRY(cr)->nmods; 00510 if ((CIFCENTRY(ncr)->mods = (struct Cif_tmod *) malloc (size)) 00511 == NULL) return (NULL); 00512 (void) memcpy ((char *)CIFCENTRY(ncr)->mods, 00513 (char *)CIFCENTRY(cr)->mods, 00514 size); 00515 } 00516 00517 if (CIFCENTRY(cr)->nargs > 0) { 00518 size = sizeof(long) * CIFCENTRY(cr)->nargs; 00519 if ((CIFCENTRY(ncr)->argids = (long *) malloc (size)) == NULL) 00520 return (NULL); 00521 (void) memcpy ((char *)CIFCENTRY(ncr)->argids, 00522 (char *)CIFCENTRY(cr)->argids, 00523 size); 00524 } 00525 if ((CIFCENTRY(ncr)->name = strdup (CIFCENTRY(cr)->name)) == NULL) 00526 return (NULL); 00527 } 00528 00529 break; 00530 00531 case CIF_C_OBJECT: 00532 if (CIFCOBJ(cr)->nmods > 0) { 00533 size = sizeof(struct Cif_tmod) * CIFCOBJ(cr)->nmods; 00534 if ((CIFCOBJ(ncr)->mods = (struct Cif_tmod *) malloc (size)) 00535 == NULL) return (NULL); 00536 (void) memcpy ((char *)CIFCOBJ(ncr)->mods, (char *)CIFCOBJ(cr)->mods, 00537 size); 00538 } 00539 if ((CIFCOBJ(ncr)->name = strdup (CIFCOBJ(cr)->name)) == NULL) 00540 return (NULL); 00541 break; 00542 00543 case CIF_C_LINT_DIRECTIVE: 00544 if ((CIFCLDIR(ncr)->name = strdup (CIFCLDIR(cr)->name)) == NULL) 00545 return (NULL); 00546 break; 00547 00548 case CIF_C_MACRO_DEF: 00549 if ((CIFCMDEF(ncr)->name = strdup (CIFCMDEF(cr)->name)) == NULL) 00550 return (NULL); 00551 break; 00552 00553 case CIF_C_ENTRY_END: 00554 if ((CIFCEEND(ncr)->name = strdup (CIFCEEND(cr)->name)) == NULL) 00555 return (NULL); 00556 break; 00557 00558 00559 case CIF_F90_CALLSITE: 00560 if ((size = CIFF90CS(cr)->nargs) > 0) { 00561 if ((CIFF90CS(ncr)->argids = (long *) malloc (sizeof(long *)*size)) 00562 == NULL) return (NULL); 00563 if (CIFF90CS(cr)->rank == 1) 00564 if ((CIFF90CS(ncr)->ranks = (int *) malloc (sizeof(int)*size)) 00565 == NULL) return (NULL); 00566 00567 for (i=0; i < size; i++) { 00568 (CIFF90CS(ncr)->argids)[i] = (CIFF90CS(cr)->argids)[i]; 00569 (CIFF90CS(ncr)->nmembs)[i] = (CIFF90CS(cr)->nmembs)[i]; 00570 (CIFF90CS(ncr)->membs)[i] = 00571 (long *) malloc ((CIFF90CS(cr)->nmembs)[i] * sizeof(long)); 00572 (void) memcpy (((char *) (CIFF90CS(ncr)->membs)[i]), 00573 ((char *) (CIFF90CS(cr)->membs)[i]), 00574 (CIFF90CS(cr)->nmembs)[i] * sizeof(long)); 00575 00576 if (CIFF90CS(cr)->rank == 1) 00577 (CIFF90CS(ncr)->ranks)[i] = (CIFF90CS(cr)->ranks)[i]; 00578 00579 } 00580 } 00581 break; 00582 00583 case CIF_F90_SCOPE_INFO: 00584 if ((size = CIFF90SI(cr)->numalts) > 0) { 00585 if ((CIFF90SI(ncr)->entryids = (long *) malloc (sizeof(long *)*size)) 00586 == NULL) return (NULL); 00587 for (i=0; i < size; i++) 00588 (CIFF90SI(ncr)->entryids)[i] = (CIFF90SI(cr)->entryids)[i]; 00589 } 00590 break; 00591 00592 case CIF_F90_COMBLK: 00593 if ((CIFF90CB(ncr)->name = strdup (CIFF90CB(cr)->name)) == NULL) 00594 return (NULL); 00595 break; 00596 00597 case CIF_F90_CONST: 00598 if ((CIFF90CON(ncr)->value = strdup (CIFF90CON(cr)->value)) == NULL) 00599 return (NULL); 00600 break; 00601 00602 case CIF_F90_ENTRY: 00603 if ((CIFF90ENTRY(ncr)->name = strdup (CIFF90ENTRY(cr)->name)) == NULL) 00604 return (NULL); 00605 if ((size = CIFF90ENTRY(cr)->nargs) > 0) { 00606 if ((CIFF90ENTRY(ncr)->argids = (long *) malloc (sizeof(long *)*size)) 00607 == NULL) return (NULL); 00608 for (i=0; i < size; i++) 00609 (CIFF90ENTRY(ncr)->argids)[i] = (CIFF90ENTRY(cr)->argids)[i]; 00610 } 00611 00612 break; 00613 00614 case CIF_F90_DERIVED_TYPE: 00615 if (_cif_version == 2) { /* must use v2 cif records */ 00616 00617 if ((CIFF90DTYPE2(ncr)->name = strdup (CIFF90DTYPE2(cr)->name)) == NULL) 00618 return (NULL); 00619 if ((size = CIFF90DTYPE2(cr)->nmembs) > 0) { 00620 if ((CIFF90DTYPE2(ncr)->memids = (long *) malloc (sizeof(long *)*size)) 00621 == NULL) return (NULL); 00622 for (i=0; i < size; i++) 00623 (CIFF90DTYPE2(ncr)->memids)[i] = (CIFF90DTYPE2(cr)->memids)[i]; 00624 } 00625 } 00626 else { /* Version 3 CIF */ 00627 00628 if ((CIFF90DTYPE(ncr)->name = strdup (CIFF90DTYPE(cr)->name)) == NULL) 00629 return (NULL); 00630 if ((size = CIFF90DTYPE(cr)->nmembs) > 0) { 00631 if ((CIFF90DTYPE(ncr)->memids = (long *) malloc (sizeof(long *)*size)) 00632 == NULL) return (NULL); 00633 for (i=0; i < size; i++) 00634 (CIFF90DTYPE(ncr)->memids)[i] = (CIFF90DTYPE(cr)->memids)[i]; 00635 } 00636 } 00637 break; 00638 00639 case CIF_F90_LABEL: 00640 if ((CIFF90LABEL(ncr)->name = strdup (CIFF90LABEL(cr)->name)) == NULL) 00641 return(NULL); 00642 break; 00643 00644 case CIF_F90_NAMELIST: 00645 if ((CIFF90NL(ncr)->name = strdup (CIFF90NL(cr)->name)) == NULL) 00646 return (NULL); 00647 size = sizeof(long) * CIFF90NL(cr)->nids; 00648 if ((CIFF90NL(ncr)->ids = (long *) malloc (size)) == NULL) return (NULL); 00649 for (i = 0; i < (int) CIFF90NL(cr)->nids; i++) 00650 (CIFF90NL(ncr)->ids)[i] = (CIFF90NL(cr)->ids)[i]; 00651 break; 00652 00653 case CIF_F90_OBJECT: 00654 if (CIFF90OBJ(cr)->name != NULL) 00655 if ((CIFF90OBJ(ncr)->name = strdup (CIFF90OBJ(cr)->name)) == NULL) 00656 return(NULL); 00657 if (CIFF90OBJ(cr)->ndims > 0) { 00658 size = sizeof(struct Cif_dim) * CIFF90OBJ(cr)->ndims; 00659 if ((CIFF90OBJ(ncr)->dim = (struct Cif_dim *) malloc (size)) == NULL) 00660 return (NULL); 00661 (void) memcpy ((char *)CIFF90OBJ(ncr)->dim, (char *)CIFF90OBJ(cr)->dim,size); 00662 } 00663 break; 00664 00665 00666 case CIF_F90_MISC_OPTS: 00667 if ((size = CIFF90MO(cr)->nmsgs) > 0) { 00668 if ((CIFF90MO(ncr)->msgno = (long *) malloc (sizeof(long)*size)) 00669 == NULL) return (NULL); 00670 (void) memcpy ((char *)CIFF90MO(ncr)->msgno, (char *)CIFF90MO(cr)->msgno, 00671 sizeof(long)*size); 00672 } 00673 if ((size = CIFF90MO(cr)->ncdirs) > 0) { 00674 if ((CIFF90MO(ncr)->cdirs = (char **) malloc (sizeof(char *)*size)) 00675 == NULL) return (NULL); 00676 for (i = 0; i < size; i++) 00677 if (((CIFF90MO(ncr)->cdirs)[i] = strdup ((CIFF90MO(cr)->cdirs)[i])) 00678 == NULL) return (NULL); 00679 } 00680 if ((size = CIFF90MO(cr)->nPdirs) > 0) { 00681 if ((CIFF90MO(ncr)->Pdirs = (char **) malloc (sizeof(char *)*size)) 00682 == NULL) return (NULL); 00683 for (i = 0; i < size; i++) 00684 if (((CIFF90MO(ncr)->Pdirs)[i] = strdup ((CIFF90MO(cr)->Pdirs)[i])) 00685 == NULL) return (NULL); 00686 } 00687 if ((size = CIFF90MO(cr)->npdirs) > 0) { 00688 if ((CIFF90MO(ncr)->pdirs = (char **) malloc (sizeof(char *)*size)) 00689 == NULL) return (NULL); 00690 for (i = 0; i < size; i++) 00691 if (((CIFF90MO(ncr)->pdirs)[i] = strdup ((CIFF90MO(cr)->pdirs)[i])) 00692 == NULL) return (NULL); 00693 } 00694 if (CIFF90MO(cr)->objname != NULL) 00695 if ((CIFF90MO(ncr)->objname = strdup (CIFF90MO(cr)->objname)) == NULL) 00696 return(NULL); 00697 if (CIFF90MO(cr)->calname != NULL) 00698 if ((CIFF90MO(ncr)->calname = strdup (CIFF90MO(cr)->calname)) == NULL) 00699 return(NULL); 00700 if (CIFF90MO(cr)->inname != NULL) 00701 if ((CIFF90MO(ncr)->inname = strdup (CIFF90MO(cr)->inname)) == NULL) 00702 return(NULL); 00703 if (CIFF90MO(cr)->cifname != NULL) 00704 if ((CIFF90MO(ncr)->cifname = strdup (CIFF90MO(cr)->cifname)) == NULL) 00705 return(NULL); 00706 break; 00707 00708 case CIF_F90_OPT_OPTS: 00709 if (CIFF90OPTOPT(cr)->noptlevels > 0) { 00710 size = sizeof(struct Cif_f90_level_opts) * CIFF90OPTOPT(cr)->noptlevels; 00711 if ((CIFF90OPTOPT(ncr)->lopts = (struct Cif_f90_level_opts *) malloc (size)) == NULL) 00712 return (NULL); 00713 (void) memcpy ((char *)CIFF90OPTOPT(ncr)->lopts, (char *)CIFF90OPTOPT(cr)->lopts,size); 00714 } 00715 break; 00716 00717 case CIF_F90_INT_BLOCK: 00718 if (_cif_version == 2) { /* must use v2 cif records */ 00719 00720 if (CIFF90IB2(cr)->name != NULL) 00721 if ((CIFF90IB2(ncr)->name = strdup (CIFF90IB2(cr)->name)) == NULL) 00722 return(NULL); 00723 00724 if ((size = CIFF90IB2(cr)->numints) > 0) { 00725 if ((CIFF90IB2(ncr)->procids = (long *) malloc (sizeof(long)*size)) 00726 == NULL) return (NULL); 00727 (void) memcpy ((char *)CIFF90IB2(ncr)->procids, 00728 (char *)CIFF90IB2(cr)->procids, 00729 sizeof(long)*size); 00730 } 00731 } 00732 else { /* Version 3 CIF */ 00733 00734 if (CIFF90IB(cr)->name != NULL) 00735 if ((CIFF90IB(ncr)->name = strdup (CIFF90IB(cr)->name)) == NULL) 00736 return(NULL); 00737 00738 if ((size = CIFF90IB(cr)->numints) > 0) { 00739 if ((CIFF90IB(ncr)->procids = (long *) malloc (sizeof(long)*size)) 00740 == NULL) return (NULL); 00741 (void) memcpy ((char *)CIFF90IB(ncr)->procids, 00742 (char *)CIFF90IB(cr)->procids, 00743 sizeof(long)*size); 00744 } 00745 } 00746 break; 00747 00748 00749 case CIF_BE_NODE: 00750 if (_cif_version == 2) { /* must use v2 cif records */ 00751 size = CIFBENODE2(cr)->nsuccs * sizeof( int ); 00752 if ((ncp = (char *) malloc( size )) == NULL ) 00753 return( NULL ); 00754 CIFBENODE2(ncr)->succs = (int *) ncp; 00755 cp = (char *) CIFBENODE2(cr)->succs; 00756 (void) memcpy (ncp, cp, size); 00757 size = CIFBENODE2(cr)->nlines * sizeof( int ); 00758 if ((ncp = (char *) malloc( size )) == NULL ) 00759 return( NULL ); 00760 CIFBENODE2(ncr)->lines = (int *) ncp; 00761 cp = (char *) CIFBENODE2(cr)->lines; 00762 (void) memcpy (ncp, cp, size); 00763 if ((CIFBENODE2(ncr)->label = strdup (CIFBENODE2(cr)->label)) == NULL) 00764 return (NULL); 00765 } else { 00766 size = CIFBENODE(cr)->nsuccs * sizeof( int ); 00767 if ((ncp = (char *) malloc( size )) == NULL ) 00768 return( NULL ); 00769 CIFBENODE(ncr)->succs = (int *) ncp; 00770 cp = (char *) CIFBENODE(cr)->succs; 00771 (void) memcpy (ncp, cp, size); 00772 size = CIFBENODE(cr)->nlines * sizeof( int ); 00773 if ((ncp = (char *) malloc( size )) == NULL ) 00774 return( NULL ); 00775 CIFBENODE(ncr)->fid = (int *) ncp; 00776 cp = (char *) CIFBENODE(cr)->fid; 00777 (void) memcpy (ncp, cp, size); 00778 if ((ncp = (char *) malloc( size )) == NULL ) 00779 return( NULL ); 00780 CIFBENODE(ncr)->lines = (int *) ncp; 00781 cp = (char *) CIFBENODE(cr)->lines; 00782 (void) memcpy (ncp, cp, size); 00783 if ((CIFBENODE(ncr)->label = strdup (CIFBENODE(cr)->label)) == NULL) 00784 return (NULL); 00785 } 00786 break; 00787 00788 00789 case CIF_BE_FID: 00790 size = CIFBEFID(cr)->nfid * sizeof( int ); 00791 if ((ncp = (char *) malloc( size )) == NULL ) 00792 return( NULL ); 00793 CIFBEFID(ncr)->fid = (int *) ncp; 00794 cp = (char *) CIFBEFID(cr)->fid; 00795 (void) memcpy (ncp, cp, size); 00796 break; 00797 00798 00799 case CIF_CC_TYPE: 00800 if (CIFCCTYPE(cr)->nlen > 0) { 00801 CIFCCTYPE(ncr)->name = strdup (CIFCCTYPE(cr)->name); 00802 if (CIFCCTYPE(ncr)->name == NULL) 00803 return(NULL); 00804 } 00805 if (CIFCCTYPE(cr)->nmem > 0) { 00806 size = CIFCCTYPE(cr)->nmem * sizeof( int ); 00807 if ((ncp = (char *) malloc( size )) == NULL ) 00808 return( NULL ); 00809 CIFCCTYPE(ncr)->mem = (int *) ncp; 00810 cp = (char *) CIFCCTYPE(cr)->mem; 00811 (void) memcpy (ncp, cp, size); 00812 } 00813 break; 00814 00815 case CIF_CC_ENTRY: 00816 if (CIFCCENT(cr)->nlen > 0) { 00817 CIFCCENT(ncr)->name = strdup (CIFCCENT(cr)->name); 00818 if (CIFCCENT(ncr)->name == NULL) 00819 return(NULL); 00820 } 00821 if (CIFCCENT(cr)->nparam > 0) { 00822 size = CIFCCENT(cr)->nparam * sizeof( int ); 00823 if ((ncp = (char *) malloc( size )) == NULL ) 00824 return( NULL ); 00825 CIFCCENT(ncr)->param = (int *) ncp; 00826 cp = (char *) CIFCCENT(cr)->param; 00827 (void) memcpy (ncp, cp, size); 00828 } 00829 break; 00830 00831 case CIF_CC_OBJ: 00832 if (CIFCCOBJ(cr)->nlen > 0) { 00833 CIFCCOBJ(ncr)->name = strdup (CIFCCOBJ(cr)->name); 00834 if (CIFCCOBJ(ncr)->name == NULL) 00835 return(NULL); 00836 } 00837 break; 00838 00839 case CIF_CC_ENUM: 00840 if (CIFCCENUM(cr)->nlen > 0) { 00841 CIFCCENUM(ncr)->name = strdup (CIFCCENUM(cr)->name); 00842 if (CIFCCENUM(ncr)->name == NULL) 00843 return(NULL); 00844 } 00845 if (CIFCCENUM(cr)->vlen > 0) { 00846 CIFCCENUM(ncr)->value = strdup (CIFCCENUM(cr)->value); 00847 if (CIFCCENUM(ncr)->value == NULL) 00848 return(NULL); 00849 } 00850 break; 00851 00852 case CIF_CC_EXPR: 00853 if (CIFCCEXPR(cr)->noper > 0) { 00854 size = CIFCCEXPR(cr)->noper * sizeof( int ); 00855 if ((ncp = (char *) malloc( size )) == NULL ) 00856 return( NULL ); 00857 CIFCCEXPR(ncr)->oper = (int *) ncp; 00858 cp = (char *) CIFCCEXPR(cr)->oper; 00859 (void) memcpy (ncp, cp, size); 00860 } 00861 break; 00862 00863 default: 00864 break; 00865 } 00866 00867 return (ncr); 00868 }
1.7.6.1 
