X
Xif((c_nofaces=getenv("SPD_FACES"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_FACES = %s\n",c_nofaces);
X    defalc->nofaces=atoi(c_nofaces);
X    defalc->nogfaces=atoi(c_nofaces);
X    }
X
Xif((c_nocircs=getenv("SPD_CIRCS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_CIRCS = %s\n",c_nocircs);
X    defalc->nocircs=atoi(c_nocircs);
X    defalc->nogcircs=atoi(c_nocircs);
X    }
X
Xif((c_nosphrs=getenv("SPD_SPHRS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_SPHRS = %s\n",c_nosphrs);
X    defalc->nosphrs=atoi(c_nosphrs);
X    defalc->nogsphrs=atoi(c_nosphrs);
X    }
X
Xif((c_noptchs=getenv("SPD_PTCHS"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_PTCHS = %s\n",c_noptchs);
X    defalc->noptchs=atoi(c_noptchs);
X    defalc->nogptchs=atoi(c_noptchs);
X    }
X
Xif((c_noedges=getenv("SPD_EDGES"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_EDGES = %s\n",c_noedges);
X    defalc->noedges=atoi(c_noedges);
X    }
X
Xif((c_novpl=getenv("SPD_VPLIN"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_VPLIN = %s\n",c_novpl);
X    defalc->nolverts=atoi(c_novpl);
X    defalc->nopverts=atoi(c_novpl);
X    }
X
Xif((c_novpf=getenv("SPD_VPFAC"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_VPFAC = %s\n",c_novpf);
X    defalc->nofverts=atoi(c_novpf);
X    }
X
Xif((c_valence=getenv("SPD_VALEN"))!=NULL) { /* if set, use it */
X    fprintf(stderr,"SPD_VALEN = %s\n",c_valence);
X    defalc->valence=atoi(c_valence);
X    }
X
X/* set object name to a default */
Xstrcpy(defalc->objname,"default object");
X
Xif(verbflg>0) {
X    fprintf(stderr,"def_parms: done\n");
X    }
X
Xreturn(defalc);
X}
X
X
X
X
X
X
X
X/* function: null_parms
X
X   description: Allocates object allocation parameters, but populates with
X                zeroes.
X
X   author: Stewart Dickson
X*/
X
X
X
Xstruct sizes *null_parms(nulalc)
Xstruct sizes *nulalc;
X{
X
Xif(verbflg>0) {
X    fprintf(stderr,"entering null_parms()\n");
X    }
X
Xif(nulalc==NULL) {
X    /* allocate space for object size parameter structure */
X    if((nulalc=(struct sizes *)malloc(sizeof(struct sizes)))==NULL) {
X        fprintf(stderr,
X            "def_parms: cannot allocate 'nulalc' struct size %d\n",
X                sizeof(struct sizes));
X        exit(-1);
X        }
X    }
X
Xnulalc->noverts=0;
Xnulalc->notverts=0;
Xnulalc->valence=0;
Xnulalc->nolines=0;
Xnulalc->nolverts=0;
Xnulalc->nopoints=0;
Xnulalc->nopverts=0;
Xnulalc->nofaces=0;
Xnulalc->nofverts=0;
Xnulalc->noedges=0;
Xnulalc->nocircs=0;
Xnulalc->nosphrs=0;
Xnulalc->noptchs=0;
Xnulalc->noglines=0;
Xnulalc->nogverts=0;
Xnulalc->nogpoints=0;
Xnulalc->nogfaces=0;
Xnulalc->nogcircs=0;
Xnulalc->nogsphrs=0;
Xnulalc->nogptchs=0;
Xnulalc->nomtls=0;
Xnulalc->nomaps=0;
Xnulalc->nocalls=0;
Xnulalc->nolibs=0;
Xnulalc->notraces=0;
Xnulalc->noshados=0;
Xnulalc->nogroups=0;
X
X/* set object name to a null string */
Xstrcpy(nulalc->objname,"");
X
Xif(verbflg>0) {
X    fprintf(stderr,"null_parms: done\n");
X    }
X
Xreturn(nulalc);
X}
X
X
X
X
X
X
X
X/* function: copy_alc
X
X   description: copies allocation parameters from an object structure
X        to an allocation structure.
X
X*/
X
X
Xstruct sizes *copy_alc(cpyobj,cpalloc)
Xstruct topology *cpyobj;
Xstruct sizes *cpalloc;
X{
X
Xif(cpyobj==NULL) { /* NULL source pointer received */
X    fprintf(stderr,"copy_alc: ERROR - NULL object pointer received\n");
X    exit();
X    }
X
Xif(verbflg>2) {
X    fprintf(stderr,"entering copy_alc('%s',%d)\n",cpyobj->size.objname,
X        cpalloc);
X    }
X
Xif(cpalloc==NULL) { /* if memory has not been allocated for this */
X    if(verbflg>2) {
X        fprintf(stderr,
X            "copy_alc: allocating duplicate alloc struct...\n ");
X        }
X    /* allocate structure for internal use */
X    if((cpalloc=(struct sizes *)malloc(sizeof(struct sizes)))==NULL) {
X        fprintf(stderr,"copy_alc: cannot allocate 'cpalloc' size %d\n",
X            sizeof(struct sizes));
X        exit();
X        }
X    if(verbflg>2) {
X        fprintf(stderr,"copy_alc: done\n");
X        }
X    }
X
X/* set object name */
Xstrcpy(cpalloc->objname,cpyobj->size.objname);
X
X/* copy allocations from cpyobj returned from alloc_obj() */
X/* (prevent ourselves from passing along garbage */
Xif((cpalloc->noverts=cpyobj->alloc.noverts)<=0) cpalloc->noverts = 1;
Xif((cpalloc->notverts=cpyobj->alloc.notverts)<=0) cpalloc->notverts = 1;
Xif((cpalloc->nomtls=cpyobj->alloc.nomtls)<=0) cpalloc->nomtls = 1;
Xif((cpalloc->nomaps=cpyobj->alloc.nomaps)<=0) cpalloc->nomaps = 1;
Xif((cpalloc->notraces=cpyobj->alloc.notraces)<=0) cpalloc->notraces = 1;
Xif((cpalloc->noshados=cpyobj->alloc.noshados)<=0) cpalloc->noshados = 1;
Xif((cpalloc->nocalls=cpyobj->alloc.nocalls)<=0) cpalloc->nocalls = 1;
Xif((cpalloc->nolibs=cpyobj->alloc.nolibs)<=0) cpalloc->nolibs = 1;
Xif((cpalloc->nogroups=cpyobj->alloc.nogroups)<=0) cpalloc->nogroups = 1;
Xif((cpalloc->nogverts=cpyobj->alloc.nogverts)<=0) cpalloc->nogverts = 1;
Xif((cpalloc->noglines=cpyobj->alloc.noglines)<=0) cpalloc->noglines = 1;
Xif((cpalloc->nogfaces=cpyobj->alloc.nogfaces)<=0) cpalloc->nogfaces = 1;
Xif((cpalloc->nogsphrs=cpyobj->alloc.nogsphrs)<=0) cpalloc->nogsphrs = 1;
Xif((cpalloc->nogcircs=cpyobj->alloc.nogcircs)<=0) cpalloc->nogcircs = 1;
Xif((cpalloc->nogptchs=cpyobj->alloc.nogptchs)<=0) cpalloc->nogptchs = 1;
Xif((cpalloc->nogpoints=cpyobj->alloc.nogpoints)<=0) cpalloc->nogpoints = 1;
Xif((cpalloc->nolverts=cpyobj->alloc.nolverts)<=0) cpalloc->nolverts = 1;
Xif((cpalloc->nofverts=cpyobj->alloc.nofverts)<=0) cpalloc->nofverts = 1;
Xif((cpalloc->nopverts=cpyobj->alloc.nopverts)<=0) cpalloc->nopverts = 1;
Xif((cpalloc->valence=cpyobj->alloc.valence)<=0) cpalloc->valence = 1;
Xif((cpalloc->nolines=cpyobj->alloc.nolines)<=0) cpalloc->nolines = 1;
Xif((cpalloc->nofaces=cpyobj->alloc.nofaces)<=0) cpalloc->nofaces = 1;
Xif((cpalloc->nopoints=cpyobj->alloc.nopoints)<=0) cpalloc->nopoints = 1;
Xif((cpalloc->nocircs=cpyobj->alloc.nocircs)<=0) cpalloc->nocircs = 1;
Xif((cpalloc->nosphrs=cpyobj->alloc.nosphrs)<=0) cpalloc->nosphrs = 1;
Xif((cpalloc->noptchs=cpyobj->alloc.noptchs)<=0) cpalloc->noptchs = 1;
Xif((cpalloc->noedges=cpyobj->alloc.noedges)<=0) cpalloc->noedges = 1;
X
Xreturn(cpalloc);
X}
X
X
X
X
X
X
X
X
X/* function: copy_siz
X
X   description: copies population size parameters from an object structure
X        to an allocation structure.
X
X*/
X
X
Xstruct sizes *copy_siz(cpyobj,cpalloc)
Xstruct topology *cpyobj;
Xstruct sizes *cpalloc;
X{
Xint gindx;
X
Xif(cpyobj==NULL) { /* NULL source pointer received */
X    fprintf(stderr,"copy_siz: ERROR - NULL object pointer received\n");
X    exit();
X    }
X
Xif(verbflg>2) {
X    fprintf(stderr,"entering copy_siz('%s',%d)\n",cpyobj->size.objname,
X        cpalloc);
X    }
X
Xif(cpalloc==NULL) { /* if memory has not been allocated for this */
X    if(verbflg>2) {
X        fprintf(stderr,
X            "copy_siz: allocating duplicate alloc struct...\n ");
X        }
X    /* allocate structure for internal use */
X    if((cpalloc=(struct sizes *)malloc(sizeof(struct sizes)))==NULL) {
X        fprintf(stderr,"copy_siz: cannot allocate 'cpalloc' size %d\n",
X            sizeof(struct sizes));
X        exit();
X        }
X    if(verbflg>2) {
X        fprintf(stderr,"copy_siz: done\n");
X        }
X    }
X
X/* set object name */
Xstrcpy(cpalloc->objname,cpyobj->size.objname);
X
X/* copy sizes from cpyobj */
Xif((cpalloc->noverts = cpyobj->size.noverts + 1)<=0) cpalloc->noverts = 1;
Xif((cpalloc->notverts = cpyobj->size.notverts + 1)<=0) cpalloc->notverts = 1;
Xif((cpalloc->nomtls = cpyobj->size.nomtls + 1)<=0) cpalloc->nomtls = 1;
Xif((cpalloc->nomaps = cpyobj->size.nomaps + 1)<=0) cpalloc->nomaps = 1;
Xif((cpalloc->notraces = cpyobj->size.notraces + 1)<=0) cpalloc->notraces = 1;
Xif((cpalloc->noshados = cpyobj->size.noshados + 1)<=0) cpalloc->noshados = 1;
Xif((cpalloc->nocalls = cpyobj->size.nocalls + 1)<=0) cpalloc->nocalls = 1;
Xif((cpalloc->nolibs = cpyobj->size.nolibs + 1)<=0) cpalloc->nolibs = 1;
Xif((cpalloc->nogroups = cpyobj->size.nogroups + 1)<=0) cpalloc->nogroups = 1;
Xcpalloc->nogverts = 1;
Xcpalloc->noglines = 1;
Xcpalloc->nogfaces = 1;
Xcpalloc->nogsphrs = 1;
Xcpalloc->nogcircs = 1;
Xcpalloc->nogptchs = 1;
Xcpalloc->nogpoints = 1;
Xfor(gindx=0;gindx<cpyobj->size.nogroups;gindx++) {
X    if(cpyobj->group[gindx]->noverts > cpalloc->nogverts) {
X        cpalloc->nogverts = cpyobj->group[gindx]->noverts + 1;
X        }
X    if(cpyobj->group[gindx]->nolines > cpalloc->noglines) {
X        cpalloc->noglines = cpyobj->group[gindx]->nolines + 1;
X        }
X    if(cpyobj->group[gindx]->nofaces > cpalloc->nogfaces) {
X        cpalloc->nogfaces = cpyobj->group[gindx]->nofaces + 1;
X        }
X    if(cpyobj->group[gindx]->nosphrs > cpalloc->nogsphrs) {
X        cpalloc->nogsphrs = cpyobj->group[gindx]->nosphrs + 1;
X        }
X    if(cpyobj->group[gindx]->nocircs > cpalloc->nogcircs) {
X        cpalloc->nogcircs = cpyobj->group[gindx]->nocircs + 1;
X        }
X    if(cpyobj->group[gindx]->noptchs > cpalloc->nogptchs) {
X        cpalloc->nogptchs = cpyobj->group[gindx]->noptchs + 1;
X        }
X    if(cpyobj->group[gindx]->nopoints > cpalloc->nogpoints) {
X        cpalloc->nogpoints = cpyobj->group[gindx]->nopoints + 1;
X        }
X    }
Xif((cpalloc->nolverts = cpyobj->size.nolverts + 1)<=0) cpalloc->nolverts = 1;
Xif((cpalloc->nofverts = cpyobj->size.nofverts + 1)<=0) cpalloc->nofverts = 1;
Xif((cpalloc->nopverts = cpyobj->size.nopverts + 1)<=0) cpalloc->nopverts = 1;
Xif((cpalloc->valence = cpyobj->size.valence + 1)<=0) cpalloc->valence = 1;
Xif((cpalloc->nolines = cpyobj->size.nolines + 1)<=0) cpalloc->nolines = 1;
Xif((cpalloc->nofaces = cpyobj->size.nofaces + 1)<=0) cpalloc->nofaces = 1;
Xif((cpalloc->nopoints = cpyobj->size.nopoints + 1)<=0) cpalloc->nopoints = 1;
Xif((cpalloc->nocircs = cpyobj->size.nocircs + 1)<=0) cpalloc->nocircs = 1;
Xif((cpalloc->nosphrs = cpyobj->size.nosphrs + 1)<=0) cpalloc->nosphrs = 1;
Xif((cpalloc->noptchs = cpyobj->size.noptchs + 1)<=0) cpalloc->noptchs = 1;
Xif((cpalloc->noedges = cpyobj->size.noedges + 1)<=0) cpalloc->noedges = 1;
X
Xreturn(cpalloc);
X}
X
X
X
X
X
X
X/* function: realc_obj()
X
X   description: increases allocation for selected parts of an object
X        topology structure.
X
X   author: Stewart Dickson
X*/
X
Xstruct topology *realc_obj(rlcobj,rlcalc)
Xstruct topology *rlcobj;
Xstruct sizes *rlcalc;
X{
Xextern int verbflg;
Xint libindx,calindx,mtlindx,mapindx,tracindx,shadindx;
Xint gindx,vindx,tvindx,lindx,findx,eindx,pindx,cindx,sindx,bindx;
Xunsigned objsize;
X
Xif(rlcobj==NULL) {
X    fprintf(stderr,"realc_obj: NULL pointer to structure 'rlcobj',");
X    fprintf(stderr," no can do\n");
X    exit();
X    }
X
X/* struct sizes must have requested size parameters for object */
Xif(rlcalc==NULL) { /* if not, print error and return */
X    fprintf(stderr,
X        "realc_obj: NULL pointer to structure 'alloc', no can do\n");
X    exit();
X    }
X
Xif(verbflg>0) {
X    fprintf(stderr,"entering realc_obj(%s)\n",rlcobj->size.objname);
X    }
X
Xif(rlcalc->notraces>rlcobj->alloc.notraces) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating traced objects\n");
X        }
X    if(rlcobj->trace_obj == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'trace_obj' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate trace object pointers */
X    objsize=rlcalc->notraces*sizeof(struct tracobj *);
X    if((rlcobj->trace_obj =
X            (struct tracobj **)realloc(rlcobj->trace_obj,objsize))
X            == NULL) {
X        fprintf(stderr,
X            "realc_obj: can't reallocate");
X        fprintf(stderr," 'rlcobj->trace_obj' size %u\n",
X            objsize);
X        exit();
X        }
X    /* allocate new trace object structures */
X    objsize=sizeof(struct tracobj *);
X    for(tracindx=rlcobj->alloc.notraces;
X            tracindx<rlcalc->notraces;tracindx++) {
X        if((rlcobj->trace_obj[tracindx] =
X                (struct tracobj *)malloc(objsize))==NULL) {
X            fprintf(stderr, "realc_obj: cannot allocate");
X            fprintf(stderr,
X                " 'rlcobj->trace_obj[%d]' size %u\n",
X                tracindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.notraces=rlcalc->notraces;
X    }
X
Xif(rlcalc->noshados>rlcobj->alloc.noshados) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating shadowed objects\n");
X        }
X    if(rlcobj->shad_obj == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'shad_obj' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'shad_obj' structure pointers */
X    objsize=rlcalc->noshados*sizeof(struct shadobj *);
X    if((rlcobj->shad_obj =
X            (struct shadobj **)realloc(rlcobj->shad_obj,objsize))
X            ==NULL) {
X        fprintf(stderr,
X            "realc_obj: cannot reallocate 'rlcobj->shad_obj'");
X        fprintf(stderr," size %u\n", objsize);
X        exit();
X        }
X    /* allocate space for new 'shad_obj' structures */
X    objsize=sizeof(struct shadobj);
X    for(shadindx=rlcobj->alloc.noshados;
X            shadindx<rlcalc->noshados;shadindx++) {
X        if((rlcobj->shad_obj[shadindx] =
X                (struct shadobj *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate ");
X            fprintf(stderr,"'rlcobj->shad_obj[%d]' size %u\n",
X                shadindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.noshados=rlcalc->noshados;
X    }
X
Xif(rlcalc->nocalls>rlcobj->alloc.nocalls) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating calls\n");
X        }
X    if(rlcobj->call == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'call' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'call' structure pointers */
X    objsize=rlcalc->nocalls*sizeof(struct caldfile *);
X    if((rlcobj->call = (struct caldfile **)
X            realloc(rlcobj->call,objsize))==NULL) {
X        fprintf(stderr,
X            "realc_obj: cannot reallocate 'rlcobj->call' size %u\n",
X            objsize);
X        exit();
X        }
X    /* allocate space for new 'call' structures */
X    objsize=sizeof(struct caldfile);
X    for(calindx=rlcobj->alloc.nocalls;
X            calindx<rlcalc->nocalls;calindx++) {
X        if((rlcobj->call[calindx] =
X                (struct caldfile *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate ");
X            fprintf(stderr,"'rlcobj->call[%d]' size %u\n",
X                calindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nocalls=rlcalc->nocalls;
X    }
X
Xif(rlcalc->nolibs>rlcobj->alloc.nolibs) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating libs\n");
X        }
X    if(rlcobj->lib == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'lib' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'lib' structure pointers */
X    objsize=rlcalc->nolibs*sizeof(struct library *);
X    if((rlcobj->lib = (struct library **)realloc(rlcobj->lib,objsize))==NULL) {
X        fprintf(stderr,
X            "realc_obj: cannot reallocate 'rlcobj->lib' size %u\n",
X            objsize);
X        exit();
X        }
X    /* allocate space for new 'lib' structures */
X    objsize=sizeof(struct library);
X    for(libindx=rlcobj->alloc.nolibs;
X            libindx<rlcalc->nolibs;libindx++) {
X        if((rlcobj->lib[libindx] =
X                (struct library *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate ");
X            fprintf(stderr,"'rlcobj->lib[%d]' size %u\n",
X                libindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nolibs=rlcalc->nolibs;
X    }
X
Xif(rlcalc->nomtls>rlcobj->alloc.nomtls) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating mtls\n");
X        }
X    if(rlcobj->mtl == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'mtl' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'mtl' structure pointers */
X    objsize=rlcalc->nomtls*sizeof(struct material *);
X    if((rlcobj->mtl = (struct material **)realloc(rlcobj->mtl,objsize))==NULL) {
X        fprintf(stderr,
X            "realc_obj: cannot reallocate 'rlcobj->mtl' size %u\n",
X            objsize);
X        exit();
X        }
X    /* allocate space for new 'mtl' structures */
X    objsize=sizeof(struct material);
X    for(mtlindx=rlcobj->alloc.nomtls;
X            mtlindx<rlcalc->nomtls;mtlindx++) {
X        if((rlcobj->mtl[mtlindx] =
X                (struct material *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->mtl[%d]'");
X            fprintf(stderr," size %u\n", objsize);
X            exit();
X            }
X        /* initialize material attributes to defaults */
X        rlcobj->mtl[mtlindx]->Ka.red = 0.1;
X        rlcobj->mtl[mtlindx]->Ka.green = 0.1;
X        rlcobj->mtl[mtlindx]->Ka.blue = 0.1;
X        rlcobj->mtl[mtlindx]->Kd.red = 1.0;
X        rlcobj->mtl[mtlindx]->Kd.green = 1.0;
X        rlcobj->mtl[mtlindx]->Kd.blue = 1.0;
X        rlcobj->mtl[mtlindx]->Ks.red = 0.5;
X        rlcobj->mtl[mtlindx]->Ks.green = 0.5;
X        rlcobj->mtl[mtlindx]->Ks.blue = 0.5;
X        rlcobj->mtl[mtlindx]->Ni.red = 1.25;
X        rlcobj->mtl[mtlindx]->Ni.green = 1.375;
X        rlcobj->mtl[mtlindx]->Ni.blue = 1.5;
X        rlcobj->mtl[mtlindx]->Tf.red = 1.0;
X        rlcobj->mtl[mtlindx]->Tf.green = 1.0;
X        rlcobj->mtl[mtlindx]->Tf.blue = 1.0;
X        rlcobj->mtl[mtlindx]->Ns = 100;
X        rlcobj->mtl[mtlindx]->mass_dens = 1.0;
X        rlcobj->mtl[mtlindx]->surf_elast = 100;
X        rlcobj->mtl[mtlindx]->surf_stiff = 100;
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nomtls=rlcalc->nomtls;
X    }
X
Xif(rlcalc->nomaps>rlcobj->alloc.nomaps) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating maps\n");
X        }
X    if(rlcobj->map == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'map' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'map' structure poointers */
X    objsize=rlcalc->nomaps*sizeof(struct mapping *);
X    if((rlcobj->map = (struct mapping **)realloc(rlcobj->map,objsize))==NULL) {
X        fprintf(stderr,
X            "realc_obj: cannot reallocate 'rlcobj->map' size %u\n",
X            objsize);
X        exit();
X        }
X    /* allocate space for new 'map' structures */
X    objsize=sizeof(struct mapping);
X    for(mapindx=rlcobj->alloc.nomaps;
X            mapindx<rlcalc->nomaps;mapindx++) {
X        if((rlcobj->map[mapindx] =
X                (struct mapping *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate ");
X            fprintf(stderr,"'rlcobj->map[%d]' size %u\n",
X                mapindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nomaps=rlcalc->nomaps;
X    }
X
Xif(rlcalc->nogroups>rlcobj->alloc.nogroups) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating groups\n");
X        }
X    if(rlcobj->group == NULL) {
X        fprintf(stderr,
X            "realc_obj: ERROR - NULL pointer 'group' cannot reallocate\n");
X        exit();
X        }
X    /* reallocate space for 'group' structure pointers */
X    objsize=rlcalc->nogroups*sizeof(struct objgrps *);
X    if((rlcobj->group = (struct objgrps **)
X            realloc(rlcobj->group,objsize))==NULL) {
X        fprintf(stderr,"realc_obj: cannot reallocate 'rlcobj->group'");
X        fprintf(stderr," size %u\n",
X            objsize);
X        exit();
X        }
X    if(verbflg>10) {
X        fprintf(stderr,"realc_obj: rlcobj->group = 0x%x",rlcobj->group);
X        fprintf(stderr," size %u\n",
X            objsize);
X        }
X
X    /* allocate space for new 'group' structures and 'group->*' arrays */
X    for(gindx=rlcobj->alloc.nogroups;gindx<rlcalc->nogroups;gindx++) {
X        /* allocate space for new 'group' structures */
X        objsize=sizeof(struct objgrps);
X        if((rlcobj->group[gindx] =
X                (struct objgrps *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group");
X            fprintf(stderr,"[%d]' size %u\n",
X                gindx,objsize);
X            exit();
X            }
X        /* allocate integer arrays of previous size */
X        objsize=rlcobj->alloc.nogverts*sizeof(int);
X        if((rlcobj->group[gindx]->vertno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->vertno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.nogpoints*sizeof(int);
X        if((rlcobj->group[gindx]->pointno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->pointno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.noglines*sizeof(int);
X        if((rlcobj->group[gindx]->lineno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->lineno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.nogfaces*sizeof(int);
X        if((rlcobj->group[gindx]->faceno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->faceno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.nogcircs*sizeof(int);
X        if((rlcobj->group[gindx]->circno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->circno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.nogsphrs*sizeof(int);
X        if((rlcobj->group[gindx]->sphrno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->sphrno' size %u\n",
X                objsize);
X            exit();
X            }
X        objsize=rlcobj->alloc.nogptchs*sizeof(int);
X        if((rlcobj->group[gindx]->ptchno =
X                (int *)malloc(objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot allocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->ptchno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogroups=rlcalc->nogroups;
X    }
X
Xif(rlcalc->nogverts>rlcobj->alloc.nogverts) {
X    /* reallocate space for 'group->vertno' arrays */
X    objsize=rlcalc->nogverts*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->vertno = (int *)
X                realloc(rlcobj->group[gindx]->vertno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: can't reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->vertno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogverts=rlcalc->nogverts;
X    }
X
Xif(rlcalc->nogpoints>rlcobj->alloc.nogpoints) {
X    /* reallocate space for 'group->pointno' arrays */
X    objsize=rlcalc->nogpoints*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->pointno = (int *)
X                realloc(rlcobj->group[gindx]->pointno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: can't reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->pointno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogpoints=rlcalc->nogpoints;
X    }
X
Xif(rlcalc->noglines>rlcobj->alloc.noglines) {
X    /* reallocate space for 'group->lineno' arrays */
X    objsize=rlcalc->noglines*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->lineno = (int *)
X                realloc(rlcobj->group[gindx]->lineno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->lineno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.noglines=rlcalc->noglines;
X    }
X
Xif(rlcalc->nogfaces>rlcobj->alloc.nogfaces) {
X    /* reallocate space for 'group->faceno' arrays */
X    if(verbflg>0) {
X        fprintf(stderr,
X            "reallocating space for 'group->faceno' arrays");
X        fprintf(stderr,
X            " from %d to %d\n",
X            rlcobj->alloc.nogfaces*sizeof(int),
X            rlcalc->nogfaces*sizeof(int));
X        }
X    objsize=rlcalc->nogfaces*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if(verbflg>0) {
X            fprintf(stderr,
X                "rlcobj->group[%d]->faceno = 0x%x ->",
X                gindx,rlcobj->group[gindx]->faceno);
X            }
X        if((rlcobj->group[gindx]->faceno=
X                (int *)realloc(rlcobj->group[gindx]->faceno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->faceno' size %u\n",
X                objsize);
X            exit();
X            }
X        if(verbflg>0) {
X            fprintf(stderr,
X                " 0x%x\n",
X                rlcobj->group[gindx]->faceno);
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogfaces=rlcalc->nogfaces;
X    if(verbflg>0) {
X        fprintf(stderr,"faces done\n");
X        }
X    }
X
Xif(rlcalc->nogcircs>rlcobj->alloc.nogcircs) {
X    /* reallocate space for 'group->circno' arrays */
X    objsize=rlcalc->nogcircs*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->circno = (int *)
X                realloc(rlcobj->group[gindx]->circno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->circno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogcircs=rlcalc->nogcircs;
X    }
X
Xif(rlcalc->nogsphrs>rlcobj->alloc.nogsphrs) {
X    /* reallocate space for 'group->sphrno' arrays */
X    objsize=rlcalc->nogsphrs*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->sphrno = (int *)
X                realloc(rlcobj->group[gindx]->sphrno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->sphrno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogsphrs=rlcalc->nogsphrs;
X    }
X
Xif(rlcalc->nogptchs>rlcobj->alloc.nogptchs) {
X    /* reallocate space for 'group->ptchno' arrays */
X    objsize=rlcalc->nogptchs*sizeof(int);
X    for(gindx=0;gindx<rlcobj->alloc.nogroups;gindx++) {
X        if((rlcobj->group[gindx]->ptchno = (int *)
X                realloc(rlcobj->group[gindx]->ptchno,
X                objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->group[%d]",
X                gindx);
X            fprintf(stderr,"->ptchno' size %u\n",
X                objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nogptchs=rlcalc->nogptchs;
X    }
X
Xif(rlcalc->noverts>rlcobj->alloc.noverts) {
X    /* reallocate space for 'vertex' structures */
X    objsize=rlcalc->noverts*sizeof(struct vertex *);
X    if(verbflg>0) {
X        fprintf(stderr,
X            "reallocating rlcobj->vertex = 0x%x to size %u\n",
X            rlcobj->vertex,objsize);
X        }
X    if(rlcobj->vertex == NULL) { /* NULL structure - must allocate */
X        rlcobj = alloc_verts(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->vertex =
X                (struct vertex **)realloc(rlcobj->vertex,objsize)) ==
X                NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->vertex' size %u\n",
X                objsize);
X            exit();
X            }
X        if(verbflg>0) {
X            fprintf(stderr,"OK\n");
X            }
X
X        /* allocate space for new 'vertex' structures, 'vertex->faceno'
X            and 'vertex->edgeno' arrays */
X        for(vindx=rlcobj->alloc.noverts;vindx<rlcalc->noverts;vindx++) {
X            /* allocate space for more 'vertex' structures */
X            objsize=sizeof(struct vertex);
X            if((rlcobj->vertex[vindx] =
X                    (struct vertex *)malloc(objsize))==NULL) {
X                fprintf(stderr,
X                        "realc_obj: cannot allocate ");
X                fprintf(stderr,"'rlcobj->vertex[%d]' size %u\n",
X                        vindx,objsize);
X                exit();
X                }
X            objsize=rlcobj->alloc.valence*sizeof(int);
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocated rlcobj->vertex[%d] = 0x%x ",
X                    vindx,rlcobj->vertex[vindx]);
X                fprintf(stderr,"size %u\n",
X                    objsize);
X                }
X            if((rlcobj->vertex[vindx]->faceno =
X                    (int *)malloc(objsize))==NULL) {
X                fprintf(stderr,
X                    "alloc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->vertex[%d]->faceno' size %u\n",
X                    vindx,objsize);
X                exit();
X                }
X            if((rlcobj->vertex[vindx]->edgeno =
X                    (int *)malloc(objsize))==NULL) {
X                fprintf(stderr,
X                    "alloc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->vertex[%d]->edgeno' size %u\n",
X                    vindx,objsize);
X                exit();
X                }
X            /* initialize new vertices to defaults */
X            rlcobj->vertex[vindx]->facec = 0;
X            rlcobj->vertex[vindx]->edgec = 0;
X            rlcobj->vertex[vindx]->group = 0;
X            rlcobj->vertex[vindx]->mtl = 0;
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.noverts = rlcalc->noverts;
X        }
X    }
X
Xif(rlcalc->valence>rlcobj->alloc.valence) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating valences\n");
X        }
X    /* reallocate space for 'vertex->faceno' and 'vertex->edgeno' arrays */
X    for(vindx=0;vindx<rlcalc->noverts;vindx++) {
X        objsize=rlcalc->valence*sizeof(int);
X        if((rlcobj->vertex[vindx]->faceno = (int *)
X            realloc(rlcobj->vertex[vindx]->faceno,objsize))==NULL) {
X            fprintf(stderr,
X                    "realc_obj: cannot reallocate");
X                fprintf(stderr,
X                    " 'rlcobj->vertex[%d]->faceno' size %u\n",
X                    vindx,objsize);
X            exit();
X            }
X        if((rlcobj->vertex[vindx]->edgeno = (int *)
X            realloc(rlcobj->vertex[vindx]->edgeno,objsize))==NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X                fprintf(stderr,
X                    " 'rlcobj->vertex[%d]->edgeno' size %u\n",
X                    vindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.valence=rlcalc->valence;
X    }
X
Xif(rlcalc->nofaces>rlcobj->alloc.nofaces) {
X    /* reallocate space for 'face' structure pointers */
X    objsize=rlcalc->nofaces*sizeof(struct faces *);
X    if(verbflg>0) {
X        fprintf(stderr,
X            "reallocating rlcobj->face = 0x%x to size %u\n",
X            rlcobj->face,objsize);
X        }
X    if(rlcobj->face == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_faces(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->face =
X                (struct faces **)realloc(rlcobj->face,objsize))==NULL) {
X            fprintf(stderr,
X                "realc_obj: cannot reallocate 'rlcobj->face' size %u\n",
X                objsize);
X            exit();
X            }
X        if(verbflg>0) {
X            fprintf(stderr,"OK\n");
X            }
X
X        /* allocate space for new 'face' structures, 'face->vertno',
X           'face->tvertno' and 'face->edgeno' arrays */
X        for(findx=rlcobj->alloc.nofaces;findx<rlcalc->nofaces;findx++) {
X            objsize=sizeof(struct faces);
X            if((rlcobj->face[findx] =
X                    (struct faces *)malloc(objsize))==NULL) {
X                fprintf(stderr,
X                        "realc_obj: cannot allocate ");
X                fprintf(stderr,"'rlcobj->face[%d]' size %u\n",
X                        findx,objsize);
X                exit();
X                }
X            if(verbflg>20) {
X                fprintf(stderr,
X                    "allocated rlcobj->face[%d] = 0x%x size %u\n",
X                    findx,rlcobj->face[findx],objsize);
X                }
X            objsize=rlcobj->alloc.nofverts*sizeof(int);
X            rlcobj->face[findx]->vertno = (int *)malloc(objsize);
X            if(rlcobj->face[findx]->vertno == NULL) {
X                fprintf(stderr,
X                    "realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->face[%d]->vertno' size %u\n",
X                    findx,objsize);
X                exit();
X                }
X            rlcobj->face[findx]->tvertno = (int *)malloc(objsize);
X            if(rlcobj->face[findx]->tvertno == NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->face[%d]->tvertno' size %u\n",
X                    findx,objsize);
X                exit();
X                }
X            rlcobj->face[findx]->edgeno = (int *)malloc(objsize);
X            if(rlcobj->face[findx]->edgeno == NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->face[%d]->edgeno' size %u\n",
X                    findx,objsize);
X                exit();
X                }
X            /* initialize new faces to defaults */
X            rlcobj->face[findx]->bevel = 0;
X            rlcobj->face[findx]->mapflg = NOMAP;
X            rlcobj->face[findx]->map = -1;
X            rlcobj->face[findx]->mtl = 0;
X            rlcobj->face[findx]->smooth = -1;
X            rlcobj->face[findx]->group = 0;
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.nofaces=rlcalc->nofaces;
X        }
X    }
X
Xif(rlcalc->nofverts>rlcobj->alloc.nofverts) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating face vertices\n");
X        }
X    /* reallocate space for 'face->vertno',
X       'face->tvertno' and 'face->edgeno' arrays */
X    for(findx=0;findx<rlcalc->nofaces;findx++) {
X        objsize=rlcalc->nofverts*sizeof(int);
X        if((rlcobj->face[findx]->vertno = (int *)
X            realloc(rlcobj->face[findx]->vertno,objsize))==NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X                fprintf(stderr," 'rlcobj->face[%d]->vertno' size %u\n",
X                    findx,objsize);
X            exit();
X            }
X        if((rlcobj->face[findx]->tvertno = (int *)
X            realloc(rlcobj->face[findx]->tvertno,objsize))==NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X                fprintf(stderr," 'rlcobj->face[%d]->tvertno' size %u\n",
X                findx,objsize);
X            exit();
X            }
X        if((rlcobj->face[findx]->edgeno = (int *)
X            realloc(rlcobj->face[findx]->edgeno,objsize))==NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X                fprintf(stderr," 'rlcobj->face[%d]->edgeno' size %u\n",
X                findx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nofverts=rlcalc->nofverts;
X    }
X
Xif(rlcalc->notverts>rlcobj->alloc.notverts) {
X    /* reallocate space for 'texver' structure pointers */
X    objsize=rlcalc->notverts*sizeof(struct textur *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->texver = 0x%x to size %u\n",
X            rlcobj->texver,objsize);
X        }
X    if(rlcobj->texver == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_tverts(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->texver =
X                (struct textur **)realloc(rlcobj->texver,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->texver' size %u\n",objsize);
X            exit();
X            }
X        if(verbflg>0) {
X            fprintf(stderr,"OK\n");
X            }
X        /* allocate space for new 'texver' structures */
X        objsize=sizeof(struct textur);
X        for(tvindx=rlcobj->alloc.notverts;
X                tvindx<rlcalc->notverts;tvindx++) {
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->texver[%d] = 0x%x size %u",
X                    tvindx,rlcobj->texver[tvindx],objsize);
X                }
X            if((rlcobj->texver[tvindx] =
X                    (struct textur *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->texver[%d]' size %u\n",
X                    tvindx,objsize);
X                exit();
X                }
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.notverts=rlcalc->notverts;
X        }
X    }
X
Xif(rlcalc->nolines>rlcobj->alloc.nolines) {
X    /* reallocate space for 'line' structure pointers */
X    objsize=rlcalc->nolines*sizeof(struct lines *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->line = 0x%x to size %u\n",
X            rlcobj->line,objsize);
X        }
X    if(rlcobj->line == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_lines(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->line =
X                (struct lines **)realloc(rlcobj->line,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->line' size %u\n",objsize);
X            exit();
X            }
X
X        /* allocate space for 'line' structures and 'line->vertno' arrays */
X        for(lindx=rlcobj->alloc.nolines;lindx<rlcalc->nolines;lindx++) {
X            objsize=sizeof(struct lines);
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->line[%d] = 0x%x size %u\n",
X                    lindx,rlcobj->line[lindx],objsize);
X                }
X            if((rlcobj->line[lindx] =
X                    (struct lines *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->line[%d]' size %u\n",
X                    lindx,objsize);
X                exit();
X                }
X            objsize=rlcobj->alloc.nolverts*sizeof(int);
X            if((rlcobj->line[lindx]->vertno =
X                    (int *)malloc(objsize))==NULL) {
X                fprintf(stderr,"alloc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->line[%d]->vertno' size %u\n",
X                    lindx,objsize);
X                exit();
X                }
X            /* initialize new lines to defaults */
X            rlcobj->line[lindx]->group = 0;
X            rlcobj->line[lindx]->mtl = 0;
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.nolines=rlcalc->nolines;
X        }
X    }
X
Xif(rlcalc->nolverts>rlcobj->alloc.nolverts) {
X    objsize=rlcalc->nolverts*sizeof(int);
X    /* reallocate space for 'line->vertno' arrays */
X    for(lindx=0;lindx<rlcalc->nolines;lindx++) {
X        if(verbflg>0) {
X            fprintf(stderr,
X            "reallocating rlcobj->line[%d]->vertno = 0x%x to size %u\n",
X            lindx,rlcobj->line[lindx]->vertno,objsize);
X            }
X        if((rlcobj->line[lindx]->vertno=
X            (int *)realloc(rlcobj->line[lindx]->vertno,objsize)) ==
X            NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->line[%d]->vertno' size %u\n",
X                    lindx,objsize);
X            exit();
X            }
X        if(verbflg>0) {
X            fprintf(stderr,"OK\n");
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nolverts=rlcalc->nolverts;
X    }
X
Xif(rlcalc->noedges>rlcobj->alloc.noedges) {
X    /* reallocate space for 'edge' structure pointers */
X    objsize=rlcalc->noedges*sizeof(struct edges *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->edge = 0x%x to size %u\n",
X            rlcobj->edge,objsize);
X        }
X    if(rlcobj->edge == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_edges(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->edge =
X                (struct edges **)realloc(rlcobj->edge,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->edge' size %u\n",objsize);
X            exit();
X            }
X        /* allocate space for new 'edge' structures */
X        objsize=sizeof(struct edges);
X        for(eindx=rlcobj->alloc.noedges;
X                eindx<rlcalc->noedges;eindx++) {
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->edge[%d] = 0x%x size %u\n",
X                    eindx,rlcobj->edge[eindx],objsize);
X                }
X            if((rlcobj->edge[eindx] =
X                    (struct edges *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->edge[%d]' size %u\n",
X                    eindx,objsize);
X                exit();
X                }
X            }
X        if(verbflg>0) {
X            fprintf(stderr,"OK\n");
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.noedges=rlcalc->noedges;
X        }
X    }
X
Xif(rlcalc->nopoints>rlcobj->alloc.nopoints) {
X    /* reallocate space for 'point' structure pointers */
X    objsize=rlcalc->nopoints*sizeof(struct points *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->point = 0x%x to size %u\n",
X            rlcobj->point,objsize);
X        }
X    if(rlcobj->point == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_points(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->point =
X                (struct points **)realloc(rlcobj->point,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->point' size %u\n",objsize);
X            exit();
X            }
X
X        /* allocate space for 'point' structures and 'point->vertno' arrays */
X        for(pindx=rlcobj->alloc.nopoints;pindx<rlcalc->nopoints;pindx++) {
X            objsize=sizeof(struct points);
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->point[%d] = 0x%x size %u\n",
X                    pindx,rlcobj->point[pindx],objsize);
X                }
X            if((rlcobj->point[pindx] =
X                    (struct points *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->point[%d]' size %u\n",
X                    pindx,objsize);
X                exit();
X                }
X            objsize=rlcobj->alloc.nopverts*sizeof(int);
X            if((rlcobj->point[pindx]->vertno =
X                    (int *)malloc(objsize))==NULL) {
X                fprintf(stderr,"alloc_obj: cannot allocate");
X                fprintf(stderr," 'rlcobj->point[%d]->vertno' size %u\n",
X                    pindx,objsize);
X                exit();
X                }
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.nopoints=rlcalc->nopoints;
X        }
X    }
X
Xif(rlcalc->nopverts>rlcobj->alloc.nopverts) {
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating point vertices\n");
X        }
X    /* reallocate space for 'point->vertno' arrays */
X    objsize=rlcalc->nopverts*sizeof(int);
X    for(pindx=0;pindx<rlcalc->nopoints;pindx++) {
X        if((rlcobj->point[pindx]->vertno=
X            (int *)realloc(rlcobj->point[pindx]->vertno,objsize))
X            ==NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X                fprintf(stderr," 'rlcobj->point[%d]->vertno' size %u\n",
X                    pindx,objsize);
X            exit();
X            }
X        }
X    /* reset allocation size in object struct */
X    rlcobj->alloc.nopverts=rlcalc->nopverts;
X    }
X
Xif(rlcalc->nocircs>rlcobj->alloc.nocircs) {
X    /* reallocate space for 'circl' structure pointers */
X    objsize=rlcalc->nocircs*sizeof(struct circles *);
X    if(verbflg>0) {
X        fprintf(stderr,
X            "reallocating rlcobj->circle = 0x%x to size %u\n",
X            rlcobj->circl,objsize);
X        }
X    if(rlcobj->circl == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_circs(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->circl =
X                (struct circles **)realloc(rlcobj->circl,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->circl' size %u\n",objsize);
X            exit();
X            }
X        /* allocate space for new 'circl' structures */
X        objsize=sizeof(struct circles);
X        for(cindx=rlcobj->alloc.nocircs;
X                cindx<rlcalc->nocircs;cindx++) {
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->circle[%d] = 0x%x size %u\n",
X                    cindx,rlcobj->circl[cindx],objsize);
X                }
X            if((rlcobj->circl[cindx] =
X                    (struct circles *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->circl[%d]' size %u\n",
X                    cindx,objsize);
X                exit();
X                }
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.nocircs=rlcalc->nocircs;
X        }
X    }
X
Xif(rlcalc->nosphrs>rlcobj->alloc.nosphrs) {
X    /* reallocate space for 'spher' structure pointers */
X    objsize=rlcalc->nosphrs*sizeof(struct spheres *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->spher = 0x%x to size %u\n",
X            rlcobj->spher,objsize);
X        }
X    if(rlcobj->spher == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_sphrs(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->spher =
X                (struct spheres **)realloc(rlcobj->spher,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->spher' size %u\n",objsize);
X            exit();
X            }
X        /* allocate space for new 'spher' structures */
X        objsize=sizeof(struct spheres);
X        for(sindx=rlcobj->alloc.nosphrs;
X                sindx<rlcalc->nosphrs;sindx++) {
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->spher[%d] = 0x%x size %u\n",
X                    sindx,rlcobj->spher[sindx],objsize);
X                }
X            if((rlcobj->spher[sindx] =
X                    (struct spheres *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->spher[%d]' size %u\n",
X                    sindx,objsize);
X                exit();
X                }
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.nosphrs=rlcalc->nosphrs;
X        }
X    }
X
Xif(rlcalc->noptchs>rlcobj->alloc.noptchs) {
X    /* reallocate space for 'bicub' structure pointers */
X    objsize=rlcalc->noptchs*sizeof(struct bicubes *);
X    if(verbflg>0) {
X        fprintf(stderr,"reallocating rlcobj->bicub = 0x%x to size %u\n",
X            rlcobj->bicub,objsize);
X        }
X    if(rlcobj->bicub == NULL) { /* NULL pointer - must allocate */
X        rlcobj = alloc_ptchs(rlcobj,rlcalc);
X        }
X    else { /* reallocate */
X        if((rlcobj->bicub =
X                (struct bicubes **)realloc(rlcobj->bicub,objsize)) ==
X                NULL) {
X            fprintf(stderr,"realc_obj: cannot reallocate");
X            fprintf(stderr," 'rlcobj->bicub' size %u\n",objsize);
X            exit();
X            }
X        /* allocate space for new 'bicub' structures */
X        objsize=sizeof(struct bicubes);
X        for(bindx=rlcobj->alloc.noptchs;
X                bindx<rlcalc->noptchs;bindx++) {
X            if(verbflg>10) {
X                fprintf(stderr,
X                    "allocating rlcobj->bicub[%d] = 0x%x size %u\n",
X                    bindx,rlcobj->bicub[bindx],objsize);
X                }
X            if((rlcobj->bicub[bindx] =
X                    (struct bicubes *)malloc(objsize))==NULL) {
X                fprintf(stderr,"realc_obj: cannot allocate");
X                fprintf(stderr,
X                    " 'rlcobj->bicub[%d]' size %u\n",
X                    bindx,objsize);
X                exit();
X                }
X            }
X        /* reset allocation size in object struct */
X        rlcobj->alloc.noptchs=rlcalc->noptchs;
X        }
X    }
X
Xif(verbflg>0) {
X    fprintf(stderr,"realc_obj: rlcobj = 0x%x, done\n",rlcobj);
X    }
X
Xreturn(rlcobj);
X}
X
X
X
X
X
X
X
X
X/* function: free_obj()
X
X   description: frees allocation for an object topology structure.
X
X   author: Stewart Dickson
X*/
X
Xvoid free_obj(freobj)
Xstruct topology *freobj;
X{
Xint tracindx,shadindx,calindx,libindx,mtlindx,mapindx,gindx;
Xint vindx,tvindx,lindx,findx,pindx,eindx,cindx,sindx,bindx;
Xint notraces,noshados,nocalls,nolibs,nomtls,nomaps,nogroups;
Xint noverts,notverts,nolines,nofaces,nopoints,noedges,nocircs,nosphrs,noptchs;
X
Xnotraces=freobj->alloc.notraces;
Xnoshados=freobj->alloc.noshados;
Xnocalls=freobj->alloc.nocalls;
Xnolibs=freobj->alloc.nolibs;
Xnomtls=freobj->alloc.nomtls;
Xnomaps=freobj->alloc.nomaps;
Xnogroups=freobj->alloc.nogroups;
Xnoverts=freobj->alloc.noverts;
Xnotverts=freobj->alloc.notverts;
Xnolines=freobj->alloc.nolines;
Xnofaces=freobj->alloc.nofaces;
Xnopoints=freobj->alloc.nopoints;
Xnoedges=freobj->alloc.noedges;
Xnocircs=freobj->alloc.nocircs;
Xnosphrs=freobj->alloc.nosphrs;
Xnoptchs=freobj->alloc.noptchs;
X
X/* free space for 'trace_obj' structures */
Xfor(tracindx=0;tracindx<notraces;tracindx++) {
X    free(freobj->trace_obj[tracindx]);
X    freobj->trace_obj[tracindx] = NULL;
X    }
X
X/* free space for 'trace_obj' structure pointers */
Xfree(freobj->trace_obj);
Xfreobj->trace_obj = NULL;
X
X/* free space for 'shad_obj' structures */
Xfor(shadindx=0;shadindx<noshados;shadindx++) {
X    free(freobj->shad_obj[shadindx]);
X    freobj->shad_obj[shadindx] = NULL;
X    }
X
X/* free space for 'shad_obj' structure pointers */
Xfree(freobj->shad_obj);
Xfreobj->shad_obj = NULL;
X
X/* free space for 'call' structures */
Xfor(calindx=0;calindx<nocalls;calindx++) {
X    free(freobj->call[calindx]);
X    freobj->call[calindx] = NULL;
X    }
X
X/* free space for 'call' structure pointers */
Xfree(freobj->call);
Xfreobj->call = NULL;
X
X/* free space for 'lib' structures */
Xfor(libindx=0;libindx<nolibs;libindx++) {
X    free(freobj->lib[libindx]);
X    freobj->lib[libindx] = NULL;
X    }
X
X/* free space for 'lib' structure pointers */
Xfree(freobj->lib);
Xfreobj->lib = NULL;
X
X/* free space for 'mtl' structures */
Xfor(mtlindx=0;mtlindx<nomtls;mtlindx++) {
X    free(freobj->mtl[mtlindx]);
X    freobj->mtl[mtlindx] = NULL;
X    }
X
X/* free space for 'mtl' structure pointers */
Xfree(freobj->mtl);
Xfreobj->mtl = NULL;
X
X/* free space for 'map' structures */
Xfor(mapindx=0;mapindx<nomaps;mapindx++) {
X    free(freobj->map[mapindx]);
X    freobj->map[mapindx] = NULL;
X    }
X
X/* free space for 'map' structure pointers */
Xfree(freobj->map);
Xfreobj->map =NULL;
X
X/* free space for 'group' structures */
Xfor(gindx=0;gindx<nogroups;gindx++) {
X    free(freobj->group[gindx]->faceno);
X    freobj->group[gindx]->faceno = NULL;
X    free(freobj->group[gindx]->lineno);
X    freobj->group[gindx]->lineno = NULL;
X    free(freobj->group[gindx]->pointno);
X    freobj->group[gindx]->pointno = NULL;
X    free(freobj->group[gindx]->circno);
X    freobj->group[gindx]->circno = NULL;
X    free(freobj->group[gindx]->sphrno);
X    freobj->group[gindx]->sphrno = NULL;
X    free(freobj->group[gindx]->ptchno);
X    freobj->group[gindx]->ptchno = NULL;
X    free(freobj->group[gindx]);
X    freobj->group[gindx] = NULL;
X    }
X
X/* free space for 'group' structure pointers */
Xfree(freobj->group);
Xfreobj->group = NULL;
X
X/* free space for 'vertex->faceno', 'vertex->edgeno' arrays
X   and 'vertex' structures */
Xfor(vindx=0;vindx<noverts;vindx++) {
X    if(freobj->vertex[vindx]->faceno != NULL) {
X        free(freobj->vertex[vindx]->faceno);
X        freobj->vertex[vindx]->faceno = NULL;
X        }
X    if(freobj->vertex[vindx]->edgeno != NULL) {
X        free(freobj->vertex[vindx]->edgeno);
X        freobj->vertex[vindx]->edgeno = NULL;
X        }
X    if(freobj->vertex[vindx] != NULL) {
X        free(freobj->vertex[vindx]);
X        freobj->vertex[vindx] = NULL;
X        }
X    }
X
X/* free space for 'vertex' structure pointers */
Xfree(freobj->vertex);
Xfreobj->vertex = NULL;
X
X/* free space for 'face->vertno', 'face->tvertno', 'face->edgeno' arrays
X   and 'face' structures */
Xfor(findx=0;findx<nofaces;findx++) {
X    if(freobj->face[findx]->vertno != NULL) {
X        free(freobj->face[findx]->vertno);
X        freobj->face[findx]->vertno = NULL;
X        }
X    if(freobj->face[findx]->tvertno != NULL) {
X        free(freobj->face[findx]->tvertno);
X        freobj->face[findx]->tvertno = NULL;
X        }
X    if(freobj->face[findx]->edgeno != NULL) {
X        free(freobj->face[findx]->edgeno);
X        freobj->face[findx]->edgeno = NULL;
X        }
X    if(freobj->face[findx] != NULL) {
X        free(freobj->face[findx]);
X        freobj->face[findx] = NULL;
X        }
X    }
X
X/* free space for 'face' structure pointers */
Xif(freobj->face != NULL) {
X    free(freobj->face);
X    freobj->face = NULL;
X    }
X
X
X/* free space for 'texver' structures */
Xfor(tvindx=0;tvindx<notverts;tvindx++) {
X    if(freobj->texver[tvindx] != NULL) {
X        free(freobj->texver[tvindx]);
X        freobj->texver[tvindx] = NULL;
X        }
X    }
X
X/* free space for 'texver' structure pointers */
Xif(freobj->texver != NULL) {
X    free(freobj->texver);
X    freobj->texver = NULL;
X    }
X
X/* free space for 'line->vertno' arrays and 'line' structures */
Xfor(lindx=0;lindx<nolines;lindx++) {
X    if(freobj->line[lindx]->vertno != NULL) {
X        free(freobj->line[lindx]->vertno);
X        freobj->line[lindx]->vertno = NULL;
X        free(freobj->line[lindx]);
X        freobj->line[lindx] = NULL;
X        }
X    }
X
X/* free space for 'line' structure pointers */
Xif(freobj->line != NULL) {
X    free(freobj->line);
X    freobj->line = NULL;
X    }
X
X
X/* free space for 'edge' structures */
Xfor(eindx=0;eindx<noedges;eindx++) {
X    if(freobj->edge[eindx] != NULL) {
X        free(freobj->edge[eindx]);
X        freobj->edge[eindx] = NULL;
X        }
X    }
X
X/* free space for 'edge' structure pointers */
Xif(freobj->edge != NULL) {
X    free(freobj->edge);
X    freobj->edge = NULL;
X    }
X
X/* free space for 'point->vertno' arrays and 'point' structures */
Xfor(pindx=0;pindx<nopoints;pindx++) {
X    if(freobj->point[pindx]->vertno != NULL) {
X        free(freobj->point[pindx]->vertno);
X        freobj->point[pindx]->vertno = NULL;
X        }
X    if(freobj->point[pindx] != NULL) {
X        free(freobj->point[pindx]);
X        freobj->point[pindx] = NULL;
X        }
X    }
X
X/* free space for 'point' structure pointers */
Xif(freobj->point != NULL) {
X    free(freobj->point);
X    freobj->point = NULL;
X    }
X
X/* free space for 'circl' structures */
Xfor(cindx=0;cindx<nocircs;cindx++) {
X    if(freobj->circl[cindx] != NULL) {
X        free(freobj->circl[cindx]);
X        freobj->circl[cindx] = NULL;
X        }
X    }
X
X/* free space for 'circl' structure pointers */
Xif(freobj->circl != NULL) {
X    free(freobj->circl);
X    freobj->circl = NULL;
X    }
X
X/* free space for 'spher' structures */
Xfor(sindx=0;sindx<nosphrs;sindx++) {
X    if(freobj->spher[sindx] != NULL) {
X        free(freobj->spher[sindx]);
X        freobj->spher[sindx] = NULL;
X        }
X    }
X
X/* free space for 'spher' structure pointers */
Xif(freobj->spher != NULL) {
X    free(freobj->spher);
X    freobj->spher = NULL;
X    }
X
X/* free space for 'bicub' structures */
Xfor(bindx=0;bindx<noptchs;bindx++) {
X    if(freobj->bicub[bindx] != NULL) {
X        free(freobj->bicub[bindx]);
X        freobj->bicub[bindx] = NULL;
X        }
X    }
X
X/* free space for 'bicub' structure pointers */
Xif(freobj->bicub != NULL) {
X    free(freobj->bicub);
X    freobj->bicub = NULL;
X    }
X
X/* free allocation for object struct */
Xif(freobj != NULL) {
X    free(freobj);
X    freobj = NULL;
X    }
X
X}
!EOR!
echo extracting src/obj_lib/app_obj.c
echo mkdir ./src
mkdir ./src
echo mkdir ./src/obj_lib
mkdir ./src/obj_lib
sed 's/^X//' > src/obj_lib/app_obj.c << '!EOR!' 
X/* file: app_obj.c
X
X   contents:
X                app_obj(),
X                add_group(),
X                add_lib(),
X                add_mtl(),
X                add_map(),
X                copy_obj()
X
X   description: C functions to copy and append object descriptions to data
X                data structures in core.
X
X   author: Stewart Dickson
X*/
X
X#include <topology.h>
X#include <stdio.h>
X
X/*
X
Xfunction: app_obj()
X
Xdescription: appends the object in the source data structure to the destination
X    data structure in core.
X
Xinputs:  srcobj -- pointer to object structure to append to dstobj.
X     dstobj -- pointer to object structure to receive appended object.
X     appgrp -- index of group to receive appended object.
X     metaflg - designation of type of information to copy,
X            recognized types are:
X                'e' - copy simple elements only
X                'm' - copy meta elements and simple elements
X
Xreturns: dstobj
X
X*/
X
X
X
X
Xstruct topology *app_obj(dstobj,srcobj,appgrp,metaflg)
Xstruct topology *dstobj;
Xstruct topology *srcobj;
Xchar appgrp,metaflg;
X{
X/* external data declaration */
Xextern int verbflg;
X/* internal data declaration */
Xstruct sizes *apalloc=NULL,*copy_alc();
Xstruct topology *alloc_obj(),*realc_obj();
Xint lcount,lvcnt;
Xint fcount,fvcnt;
Xint circnt,sphcnt,bicuct;
Xint row,col;
Xint tvcount,vcount,pcount,pvcnt;
Xint sindx;
Xint mtlindx=0,mtlptr[200],add_mtl();
Xint mapindx=0,mapptr[200],add_map();
Xint gindx=0,grpptr[200], add_group();
Xint libindx=0, add_lib();
Xint calindx=0,calcount;
Xint vindx,tvindx;
X
Xint ovoffset;
Xint otvofset;
Xint ovindx;
Xint otvindx;
Xint olindx;
Xint ofindx;
Xint opindx;
Xint ocalindx;
Xint ocindx;
Xint ospndx;
Xint obpndx;
Xint gfindx,gpindx,glindx,gcindx,gsindx,gbindx;
X
Xif(srcobj==NULL) { /* if we have been given a NULL pointer */
X    fprintf(stderr,
X        "app_obj: ERROR - received NULL source struct pointer\n");
X    exit(-1);
X    }
X
Xif(dstobj==NULL) { /* if we have been given a NULL pointer */
X    /* allocate dstobj */
X    dstobj=alloc_obj(NULL);
X    }
X
X/* allocate storage for object size parameter struct */
Xapalloc=copy_alc(dstobj,apalloc);
X
Xif(verbflg>1) {
X    fprintf(stderr,"app_obj: copying object '%s' to '%s'",
X            srcobj->size.objname,dstobj->size.objname);
X    if(appgrp > -1) {
X        fprintf(stderr,
X            " group '%s'(%d)\n",dstobj->group[appgrp]->grpnam,appgrp);    
X            }
X    else {
X        fprintf(stderr," group 'append ...'(%d)\n", appgrp);    
X            }
X    }
X
X/* initialize vertex, element indices to sizes in destination object */
Xovoffset=dstobj->size.noverts-1;
Xotvofset=dstobj->size.notverts-1;
Xovindx=dstobj->size.noverts;
Xotvindx=dstobj->size.notverts;
Xolindx=dstobj->size.nolines;
Xofindx=dstobj->size.nofaces;
Xopindx=dstobj->size.nopoints;
Xocalindx=dstobj->size.nocalls;
Xocindx=dstobj->size.nocircs;
Xospndx=dstobj->size.nosphrs;
Xobpndx=dstobj->size.noptchs;
X
X/* check allocation of destination object and reallocate if necessary */
Xif(ovindx+srcobj->size.noverts > apalloc->noverts) {
X    apalloc->noverts = ovindx+srcobj->size.noverts;
X    }
Xif(otvindx+srcobj->size.notverts > apalloc->notverts) {
X    apalloc->notverts = otvindx+srcobj->size.notverts;
X    }
Xif(olindx+srcobj->size.nolines > apalloc->nolines) {
X    apalloc->nolines = olindx+srcobj->size.nolines;
X    }
Xif(srcobj->alloc.nolverts > apalloc->nolverts) {
X    apalloc->nolverts = srcobj->alloc.nolverts;
X    }
Xif(ofindx+srcobj->size.nofaces > apalloc->nofaces) {
X    apalloc->nofaces = ofindx + srcobj->size.nofaces;
X    }
Xif(opindx+srcobj->size.nopoints > apalloc->nopoints) {
X    apalloc->nopoints = opindx + srcobj->size.nopoints;
X    }
Xif(srcobj->alloc.nopverts > apalloc->nopverts) {
X    apalloc->nopverts = srcobj->alloc.nopverts;
X    }
Xif(ocindx+srcobj->size.nocircs > apalloc->nocircs) {
X    apalloc->nocircs = ocindx + srcobj->size.nocircs;
X    }
Xif(ospndx+srcobj->size.nosphrs > apalloc->nosphrs) {
X    apalloc->nosphrs = ospndx + srcobj->size.nosphrs;
X    }
Xif(obpndx + srcobj->size.noptchs > apalloc->noptchs) {
X    apalloc->noptchs = obpndx + srcobj->size.noptchs;
X    }
X/* reallocate if necessary */
Xdstobj = realc_obj(dstobj,apalloc);
X
X/* copy 'call' directives */
X
Xif(strcmp(srcobj->call[0]->filnam,"# no files called")!=0) {
X
X    if(verbflg>4) {
X        fprintf(stderr,"app_obj: copying %d file calls\n",
X            srcobj->size.nocalls);
X        }
X
X    for(calindx=0;calindx<srcobj->size.nocalls;calindx++) {
X        for(calcount=0;calcount<dstobj->size.nocalls;calcount++) {
X            /* determine if copied call is unique */
X            if(strcmp(srcobj->call[calindx]->filnam,
X                dstobj->call[calcount]->filnam)==0) {
X                break;
X                }
X            }
X        if(strcmp(srcobj->call[calindx]->filnam,
X            dstobj->call[calcount]->filnam)!=0) {
X                    /* if it is unique */
X    
X            if(verbflg>9) {
X                fprintf(stderr,"%s\n",
X                    srcobj->call[calindx]->filnam);
X                }
X    
X            strcpy(dstobj->call[ocalindx]->filnam,
X                srcobj->call[calindx]->filnam);
X            if((++ocalindx)>=dstobj->alloc.nocalls) {
X                fprintf(stderr,
X                    "app_obj: too many file calls %d",
X                    ocalindx);
X                fprintf(stderr,
X                    " in object '%s' -- reallocating\n",
X                    dstobj->size.objname);
X                /* double allocation for library calls */
X                apalloc->nocalls=apalloc->nocalls*2;
X                dstobj=realc_obj(dstobj,apalloc);
X                }
X            }
X        }
X    }
X
X/* copy 'mtllib/maplib' directives */
X
Xif(strcmp(srcobj->lib[0]->libnam,"# no libraries used")!=0) {
X
X    if(verbflg>9) {
X        fprintf(stderr,"app_obj: copying %d library calls\n",
X            srcobj->size.nolibs);
X        }
X
X    for(libindx=0;libindx<srcobj->size.nolibs;libindx++) {
X        add_lib(dstobj,srcobj->lib[libindx]->libnam);
X        }
X    }
X
X/* copy materials */
X
Xif(verbflg > 4) {
X    fprintf(stderr,"app_obj: copying %d materials\n",
X        srcobj->size.nomtls);
X    }
X
Xfor(mtlindx=0;mtlindx<srcobj->size.nomtls;mtlindx++) {
X    mtlptr[mtlindx] = add_mtl(dstobj,srcobj->mtl[mtlindx]->mtlnam);
X
X    if(verbflg>9) {
X        fprintf(stderr,
X            "app_obj: mtl '%s', mtlptr(%d)=%d\n",
X            srcobj->mtl[mtlindx]->mtlnam,mtlindx,mtlptr[mtlindx]);
X        }
X    }
X
X/* copy texture maps */
X
Xif(verbflg > 4) {
X    fprintf(stderr,"app_obj: copying %d mappings\n",
X        srcobj->size.nomaps);
X    }
X
Xfor(mapindx=0;mapindx<srcobj->size.nomaps;mapindx++) {
X    mapptr[mapindx] = add_map(dstobj,srcobj->map[mapindx]->mapnam);
X
X    if(verbflg>9) {
X        fprintf(stderr,
X            "app_obj: map '%s', mapptr(%d)=%d\n",
X            srcobj->map[mapindx]->mapnam,mapindx,mapptr[mapindx]);
X        }
X    }
X
X/* copy groups */
X
Xif(verbflg>4) {
X    fprintf(stderr,"app_obj: copying %d groups\n",
X        srcobj->size.nogroups);
X    }
X
Xfor(gindx = 0; gindx < srcobj->size.nogroups; gindx++) {
X    /* if not, set a pointer to old group */
X    grpptr[gindx] = add_group(dstobj,srcobj->group[gindx]->grpnam);
X
X    if(verbflg>9) {
X        fprintf(stderr,
X            "app_obj: group '%s', grpptr(%d)=%d\n",
X            srcobj->group[gindx]->grpnam,gindx,grpptr[gindx]);
X        }
X    }
X
X/* copy vertices */
X
Xif(verbflg>4) {
X    fprintf(stderr,"app_obj: copy %d vertices\n",srcobj->size.noverts);
X    }
X
Xfor(vcount=1;vcount<srcobj->size.noverts;vcount++) {
X    if(verbflg>9) {
X        fprintf(stderr,"app_obj: vcount=%d, ovindx=%d\n",vcount,ovindx);
X        }
X    mtlindx=srcobj->vertex[vcount]->mtl;
X    if(verbflg>9) {
X        fprintf(stderr,"app_obj: copied mtlptr[%d]=%d\n",
X            mtlindx,(int)mtlptr[mtlindx]);
X        }
X    dstobj->vertex[ovindx]->mtl=mtlptr[mtlindx];
X    dstobj->vertex[ovindx]->x=srcobj->vertex[vcount]->x;
X    dstobj->vertex[ovindx]->y=srcobj->vertex[vcount]->y;
X    dstobj->vertex[ovindx]->z=srcobj->vertex[vcount]->z;
X    if((++ovindx)>=dstobj->alloc.noverts) {
X        fprintf(stderr,
X            "app_obj: too many vertices %d in object '%s'",
X            ovindx,dstobj->size.objname);
X        fprintf(stderr," -- reallocating\n");
X        /* double allocation for vertices */
X        apalloc->noverts=apalloc->noverts*2;
X        dstobj=realc_obj(dstobj,apalloc);
X        }
X    }