ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/hd/holofile.c

Comparing ray/src/hd/holofile.c (file contents):
Revision 3.46 by greg, Thu May 29 16:26:21 2003 UTC vs.
Revision 3.51 by schorsch, Mon Jul 21 22:30:18 2003 UTC

#	Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7		*      9/30/97 GWLarson
8		*/
9
10	+	#include "copyright.h"
11	+
12	+	#include <string.h>
13	+
14		#include "holo.h"
15
16		#ifndef CACHESIZE
#	Line 66 | Line 70 | HDGRID *hproto;
70		register HOLO   *hp;
71		int     n;
72		/* copy grid to temporary header */
73	<	bcopy((void *)hproto, (void *)&hdhead, sizeof(HDGRID));
73	>	memcpy((void *)&hdhead, (void *)hproto, sizeof(HDGRID));
74		/* compute grid vectors and sizes */
75		hdcompgrid(&hdhead);
76		/* allocate header with directory */
#	Line 74 | Line 78 | HDGRID *hproto;
78		if ((hp = (HOLO *)malloc(n)) == NULL)
79		return(NULL);
80		/* copy header information */
81	<	copystruct(hp, &hdhead);
81	>	*hp = hdhead;
82		/* allocate and clear beam list */
83		hp->bl = (BEAM **)malloc((nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
84		if (hp->bl == NULL) {
85		free((void *)hp);
86		return(NULL);
87		}
88	<	bzero((void *)hp->bl, (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
88	>	memset((void *)hp->bl, '\0', (nbeams(hp)+1)*sizeof(BEAM *)+sizeof(BEAM));
89		hp->bl[0] = (BEAM *)(hp->bl+nbeams(hp)+1);      /* set blglob(hp) */
90		hp->fd = -1;
91		hp->dirty = 0;
92		hp->priv = NULL;
93		/* clear beam directory */
94	<	bzero((void *)hp->bi, (nbeams(hp)+1)*sizeof(BEAMI));
94	>	memset((void *)hp->bi, '\0', (nbeams(hp)+1)*sizeof(BEAMI));
95		return(hp);             /* all is well */
96		}
97
#	Line 123 | Line 127 | int    wr;
127		if (fd >= nhdfragls) {
128		hdfragl = (struct fraglist *)hdrealloc((char *)hdfragl,
129		(fd+1)*sizeof(struct fraglist), "hdattach");
130	<	bzero((void *)(hdfragl+nhdfragls),
131	<	(fd+1-nhdfragls)*sizeof(struct fraglist));
130	>	memset((void *)(hdfragl+nhdfragls),
131	>	'\0', (fd+1-nhdfragls)*sizeof(struct fraglist));
132		nhdfragls = fd+1;
133		}
134		hdfragl[fd].nlinks++;
135		hdfragl[fd].writable = wr;              /* set writable flag */
136	<	hdfragl[fd].flen = lseek(fd, (off_t)0L, 2);     /* get file length */
136	>	hdfragl[fd].flen = lseek(fd, (off_t)0, 2);      /* get file length */
137		}
138
139
#	Line 161 | Line 165 | HDGRID *hproto;                /* holodeck section grid */
165		register int    n;
166		/* prepare for system errors */
167		errno = 0;
168	<	if ((fpos = lseek(fd, (off_t)0L, 1)) < 0)
168	>	if ((fpos = lseek(fd, (off_t)0, 1)) < 0)
169		error(SYSTEM, "cannot determine holodeck file position");
170		if (hproto == NULL) {           /* assume we're loading it */
171		HDGRID  hpr;
#	Line 257 | Line 261 | int    i;
261		hp->dirseg[j].n = 1;
262		break;
263		}
264	<	copystruct(hp->dirseg+j, hp->dirseg+(j-1));
264	>	*(hp->dirseg+j) = *(hp->dirseg+(j-1));
265		}
266		do {                            /* check neighbors */
267		mindist = nbeams(hp);           /* find closest */
#	Line 279 | Line 283 | int    i;
283		hp->dirseg[minpos].n - hp->dirseg[j].s;
284		hp->dirty--;
285		while (++j < hp->dirty)         /* close the gap */
286	<	copystruct(hp->dirseg+j, hp->dirseg+(j+1));
286	>	*(hp->dirseg+j) = *(hp->dirseg+(j+1));
287		} while (mindist <= MINDIRSEL);
288		}
289
#	Line 355 | Line 359 | int    fd;
359		if (fd < 0)
360		return(-1);
361		if (fd >= nhdfragls || !hdfragl[fd].nlinks) {
362	<	if ((fpos = lseek(fd, (off_t)0L, 1)) < 0)
362	>	if ((fpos = lseek(fd, (off_t)0, 1)) < 0)
363		return(-1);
364	<	flen = lseek(fd, (off_t)0L, 2);
364	>	flen = lseek(fd, (off_t)0, 2);
365		lseek(fd, fpos, 0);
366		return(flen);
367		}
#	Line 429 | Line 433 | int    nr;                     /* number of new rays desired */
433		hdfreefrag(hp, i);              /* relinquish old fragment */
434		p = hdbray(hp->bl[i]) + hp->bl[i]->nrm;
435		hp->bl[i]->nrm += nr;                   /* update in-core structure */
436	<	bzero((void *)p, nr*sizeof(RAYVAL));
436	>	memset((void *)p, '\0', nr*sizeof(RAYVAL));
437		blglob(hp)->tick = hp->bl[i]->tick = hdclock++; /* update LRU clock */
438		return(p);                              /* point to new rays */
439		}
#	Line 469 | Line 473 | int
473		hdfilord(hb1, hb2)      /* order beams for quick loading */
474		register HDBEAMI        *hb1, *hb2;
475		{
476	<	register long   c;
476	>	register off_t  c;
477		/* residents go first */
478		if (hb2->h->bl[hb2->b] != NULL)
479		return(hb1->h->bl[hb1->b] == NULL);
480		if (hb1->h->bl[hb1->b] != NULL)
481		return(-1);
482		/* otherwise sort by file descriptor */
483	<	if ((c = hb1->h->fd - hb2->h->fd))
484	<	return(c);
483	>	if (hb1->h->fd != hb2->h->fd)
484	>	return(hb1->h->fd - hb2->h->fd);
485		/* then by position in file */
486		c = hb1->h->bi[hb1->b].fo - hb2->h->bi[hb2->b].fo;
487		return(c > 0 ? 1 : c < 0 ? -1 : 0);
#	Line 487 | Line 491 | register HDBEAMI       *hb1, *hb2;
491		hdloadbeams(hb, n, bf)  /* load a list of beams in optimal order */
492		register HDBEAMI        *hb;    /* list gets sorted by hdfilord() */
493		int     n;                      /* list length */
494	<	int     (*bf)();                /* callback function (optional) */
494	>	void    (*bf)();                /* callback function (optional) */
495		{
496		unsigned        origcachesize, memuse;
497		int     bytesloaded, needbytes, bytes2free;
#	Line 551 | Line 555 | int    i;
555		if (++k >= f->nfrags)
556		goto endloop;
557		if (k > j)
558	<	copystruct(f->fi+j, f->fi+k);
558	>	*(f->fi+j) = *(f->fi+k);
559		}
560		endloop:
561		f->nfrags = j;
#	Line 583 | Line 587 | int    i;
587		f->fi[j].nrd = bi->nrd;
588		break;
589		}
590	<	copystruct(f->fi+j, f->fi+(j-1));
590	>	*(f->fi+j) = *(f->fi+(j-1));
591		}
592		/* coalesce adjacent fragments */
593		/* successors never empty */
#	Line 602 | Line 606 | int    i;
606		}
607		biglob(hp)->nrd -= bi->nrd;             /* tell fragment it's free */
608		bi->nrd = 0;
609	<	bi->fo = 0L;
609	>	bi->fo = 0;
610		hdmarkdirty(hp, i);                     /* assume we'll reallocate */
611		return(1);
612		}
#	Line 612 | Line 616 | int
616		hdfragOK(fd, listlen, listsiz)  /* get fragment list status for file */
617		int     fd;
618		int     *listlen;
619	<	register int4   *listsiz;
619	>	register int32  *listsiz;
620		{
621		register struct fraglist        *f;
622		register int    i;
#	Line 635 | Line 639 | register int4  *listsiz;
639		off_t
640		hdallocfrag(fd, nrays)          /* allocate a file fragment */
641		int     fd;
642	<	unsigned int4   nrays;
642	>	uint32  nrays;
643		{
644		register struct fraglist        *f;
645		register int    j;
#	Line 667 | Line 671 | register HOLO  *hp;
671		register int    i;
672		{
673		int     fragfreed;
674	<	unsigned int4   nrays;
674	>	uint32  nrays;
675		unsigned int    n;
676		off_t   nfo;
677		/* check file status */
#	Line 693 | Line 697 | register int   i;
697		}
698		hp->bi[i].fo = nfo;
699		} else
700	<	hp->bi[i].fo = 0L;
700	>	hp->bi[i].fo = 0;
701		biglob(hp)->nrd += nrays - hp->bi[i].nrd;
702		hp->bi[i].nrd = nrays;
703		if (!fragfreed)
#	Line 781 | Line 785 | register int   i;
785		if (hp->bi[i].nrd && !(hdfragflags&FF_KILL && hdfreefrag(hp,i))) {
786		biglob(hp)->nrd -= hp->bi[i].nrd;       /* free failed */
787		hp->bi[i].nrd = 0;
788	<	hp->bi[i].fo = 0L;
788	>	hp->bi[i].fo = 0;
789		hdmarkdirty(hp, i);
790		}
791		return(nchanged);
#	Line 813 | Line 817 | register HOLO  *hp;                    /* section we're adding from */
817		hb[j].b = i;
818		break;
819		}
820	<	copystruct(hb+j, hb+(j-1));
820	>	*(hb+j) = *(hb+(j-1));
821		}
822		}
823		return(nents);                  /* return new list length */

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)