00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 static char USMID[] = "@(#) libcif/cifdup.c 30.5 07/26/96 07:19:13";
00038
00039
00040
00041
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
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
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) {
00099 if ((CIFCB1(ncr)->name = strdup (CIFCB1(cr)->name)) == NULL)
00100 return (NULL);
00101 }
00102 else {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 {
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) {
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 }
