Return to files.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb

Power 6/32 Unix version 1.2b

static char sccsid[] = "@(#)files.c	2.7";

#include <stdio.h>
#include "cdb.h"
#include "macdefs.h"


FILE	*vfpSrc;	/* source file of current interest */
export int	vfnDecl;	/* declarations file of current interest */

export FLAGT	vfPascal;	/* if true, vifd is a pascal source file */
export int	vcbTot;	/* used for debugging - # bytes allocated at present */

#define idirMax	16	/* maximum number of alternate directories */
local char	*vrgSbDir[idirMax];	/* a list of directory names */

local short	vidirMac;



/* A D D   D I R */

export void AddDir(sbDir)
char	*sbDir;
{
	if (vidirMac >= idirMax)
		UError("No more room for directories");
	vrgSbDir[vidirMac] = malloc(strlen(sbDir)+1);
	strcpy(vrgSbDir[vidirMac], sbDir);
	vidirMac++;
} /* AddDir */


/* L I S T   D I R */

export void ListDir()
{
	short	i;
	for (i=0; i < vidirMac; i++)
		printf("%s\n", vrgSbDir[i]);
} /* ListDir */


/* F P   F   S B */

local FILE *FpFSb(sbFile, sbFlags)
char	*sbFile, *sbFlags;
{
	short	i;
	char	sbTemp[80];
	FILE	*fp;

	fp = NULL;
	sbTemp[0] = 0;
	if ((sbFile[0] != '/') AND (vidirMac > 0)) {
		for (i=0; i < vidirMac; i++) {
			strcpy(sbTemp, vrgSbDir[i]);
			strcat(sbTemp, "/");
			strcat(sbTemp, sbFile);
			/* try to open it */
			fp = fopen(sbTemp, sbFlags);
			if (fp != NULL)
				break;
		} /* for */
	} /* if */

	if (fp == NULL) {
		/* failed elsewhere, exist locally? */
		strcpy(sbTemp, sbFile);
		fp = fopen(sbTemp, sbFlags);
	}
	if (fp != NULL)
		strcpy(sbFile, sbTemp);
	return(fp);
} /* FpFSb */


/* S E T   R G   L N */

local void SetRgLn(ifdIn, fp)
int	ifdIn;
FILE	*fp;
{
	int		cbNew;
	uint	*rgLn;
	char	buf[200];
	int		ifd, iln, ilnMac;

	iln = 0;
	rewind(fp);
	while (fgets(buf, 200, fp) != NULL)
		iln++;
	iln++;	/* this array is 1 based, not zero */
	cbNew = iln * CBINT;
	rgLn = (uint *) malloc(cbNew);  /* get enough space for line array */
	if (rgLn == 0) {
		for (ifd=0; ifd<vifdMac; ifd++) {
			if (vrgFd[ifd].ilnMac != ilnNil) {
				free(vrgFd[ifd].rgLn);
				vcbTot -= vrgFd[ifd].ilnMac * 2;
				vrgFd[ifd].ilnMac = ilnNil;
				rgLn = (uint *) malloc(cbNew);  /* try again */
				if (rgLn != 0)
					break;
			} /* if */
		} /* for */
		if (ifd >= vifdMac)
			Panic("Memory problems in SetRgLn");
	} /* if */
	vcbTot += cbNew;
	vrgFd[ifdIn].ilnMac = iln;
	vrgFd[ifdIn].rgLn = rgLn;
	rewind(fp);	/* once more, from the top */
	ilnMac = iln;
	for (iln=1; iln < ilnMac; iln++) {
		rgLn[iln] = ftell(fp);
		if (fgets(buf, 200, fp) == NULL)
			break;
	} /* for */
} /* SetRgLn */


/* I P D   F   A D R */

export int IpdFAdr(adr)
ADRT	adr;
{
	int 	ipd;

	if (vrgPd[vipd].adrStart <= adr
	    AND vrgPd[vipd+1].adrStart > adr)
		return(vipd);

	for (ipd=0; ipd < vipdMac; ipd++) {
		if (vrgPd[ipd].adrStart >= adr) {
			if (vrgPd[ipd].adrStart > adr)
				ipd--;
			return(ipd);
		} /* if */
	} /* for */
	return(ipdNil);
} /* IpdFAdr */


/* I P D   F   N A M E */

export int IpdFName(sbProc)
char	*sbProc;
{
	int		ipd;

	if ((vipd != ipdNil)
	    AND (FSbCmp(vrgPd[vipd].sbProc, sbProc)) )
		return(vipd);

	for (ipd=0; ipd < vipdMac; ipd++)	/* try for an EXACT match first */
		if (FSbCmp(vrgPd[ipd].sbProc, sbProc))
			return(ipd);

	for (ipd=0; ipd < vipdMac; ipd++)	/* no good, go for approximate */
		if (FProcCmp(vrgPd[ipd].sbProc, sbProc))
			return(ipd);

	return(ipdNil);
} /* IpdFName */


/* O P E N   I P D */

export void OpenIpd(ipd, fForce)
int	ipd;
FLAGT	fForce;
{
	if (ipd == ipdNil) {
		vipd = ipdNil;
		return;
	} /* if */

	if (!fForce & (ipd == vipd))
		return;

	IfdFOpen(IfdFAdr(vrgPd[ipd].adrStart));	/* open parent file */
	viln = IlnFIsym(vrgPd[ipd].isym+1);	/* find line #, start with next sym */
	if (viln == ilnNil) {
		printf("WARNING: %s does not appear to have line symbols\n",
		vrgFd[vifd].sbFile);
#ifdef BSD41
	} 
	else {
		if (!vfPascal) {
			visym++;	/* we actually want the NEXT one for berkeley C */
			viln = IlnFIsym(visym);
		}
#endif
	} /* if */
	vipd = ipd;
	vslop = 0;
} /* OpenIpd */


/* I F D   F   O P E N */

export int IfdFOpen(ifd)
int	ifd;
{
	char	sbTemp[80], *sbT;
	long	mtimeSrc;
	pFDR	fd;
	FILE	*fp;

	/* we use vifdTemp for `un-related' files */
	if ( (ifd == vifdTemp) AND (vrgFd[vifdTemp].ilnMac != ilnNil) ) {
		/* ie. there was already a file connected with vifdTemp */
		free(vrgFd[vifdTemp].rgLn);
		vcbTot -= vrgFd[vifdTemp].ilnMac * 2;
		vrgFd[vifdTemp].ilnMac = ilnNil;
		vifd = vifdNil;
	} /* if */

	if (ifd < 0 OR ifd >= vifdMac) {
		vifd = vifdNil;
		return(vifdNil);
	} /* if */

	if (ifd == vifd)
		return(ifd);

	/* let's get rid of currently open stuff */
	if (vfpSrc != NULL) {
		fclose(vfpSrc);	/* there is a currently open file */
		vfpSrc = NULL;
	} /* if */
	vifd = vifdNil;
#ifdef SYSIII
	if (vfnDecl != fnNil) {
		close(vfnDecl);
		vfnDecl = fnNil;
		vityMac = 0;
	} /* if */
#endif

	fd = vrgFd + ifd;
	strcpy(sbTemp, (ifd==vifdTemp) ? vsbFileTemp : fd->sbFile);
	fp = FpFSb(sbTemp, "r");
	if (fp == NULL) {
		if (ifd != vifdTemp)
			UError("Cannot open `%s'\n", sbTemp);
		else
			return(vifdNil);
	} /* if */
	vfpSrc = fp;
	vipd = vrgFd[ifd].ipd;
	viln = 1;
	vslop = 0;
	vifd = ifd;

	if (fd->ilnMac == ilnNil) {
		/* we need to see its age and build line array */
		mtimeSrc = AgeFFn(fileno(vfpSrc));
		if (!fd->fWarned AND mtimeSrc > vmtimeSym)
			printf("WARNING: %s is younger than %s\n", sbTemp, vsbSymfile);
		SetRgLn(ifd, vfpSrc);	/* figure out line {nings */
	} /* if */

#ifdef BSD41
	sbT = strrchr(sbTemp, '.') + 1;
	if (*sbT == 'p') {
		/* it would appear to be a pascal source file */
		vfPascal = true;
	} 
	else {
		vfPascal = false;
	}
#endif
#ifdef SYSIII
	if (fd->fHasDecl) {	/* see if we can find a symbols file */
		sbT = strrchr(sbTemp, 'c');
		*sbT = 'd';
		if ((vfnDecl = open(sbTemp, O_RDONLY)) < 0) {
			vfnDecl = fnNil;
			fd->fHasDecl = false;
		} 
		else {
			if (!fd->fWarned AND mtimeSrc > AgeFFn(vfnDecl)) {
				*sbT = chNull;
				printf("WARNING: %sc is younger than %sd\n", sbTemp, sbTemp);
			} /* if */
			vityMac = CblFFn(vfnDecl) / cbTYR;
			InitTyCache();
		} /* if */
	} /* if */
#endif
	fd->fWarned = true;
	return(ifd);
} /* IfdFOpen */


/* I F D   F   A D R */

export int IfdFAdr(adr)
ADRT	adr;
{
	int		ifd;

	if ((vifd != vifdNil)
	    AND (vrgFd[vifd].adrStart <= adr)
	    AND (vrgFd[vifd+1].adrStart > adr))
		return(vifd);

	for (ifd=0; ifd < vifdMac; ifd++) {
		if (vrgFd[ifd].adrStart >= adr) {
			if (vrgFd[ifd].adrStart > adr)
				ifd--;
			return(ifd);
		} /* if */
	} /* for */
	return(vifdNil);
} /* IfdFAdr */


/* I F D   F   N A M E */

export int IfdFName(sbFile)
char	*sbFile;
{
	int 	ifd;

	if ((vifd != vifdNil)
	    AND FSbCmp(vrgFd[vifd].sbFile, sbFile))
		return(vifd);

	for (ifd=0; ifd < vifdMac; ifd++) {
		if (FSbCmp(vrgFd[ifd].sbFile, sbFile)) {
			return(ifd);
		} /* if */
	} /* for */
	return(vifdNil);
} /* IfdFName */


/* I F D   F   I P D */

export int IfdFIpd(ipd)
int	ipd;
{
	int		ifd;
	pFDR	fd;

	for (fd=vrgFd, ifd=0; ifd <= vifdMac; fd++, ifd++)
		if (fd->ipd < ipd)
			return(ifd);
	return(vifdNil);
} /* IfdFIpd */


/* P R I N T   L I N E */

export void PrintLine(iln, count, fPrintLn)
int	iln, count;
FLAGT	fPrintLn;
{
	long	offset;
	char	linebuf[200];

	if (vifd == vifdNil)
		UError("I have no source file for this address");
	if (iln == ilnNil)
		iln = 1;
	iln = Min(iln, vrgFd[vifd].ilnMac);
	count = Min(vrgFd[vifd].ilnMac-iln, count);
	offset = vrgFd[vifd].rgLn[iln];
	if (fseek(vfpSrc, offset, 0)) {
		Panic("Bad seek in PrintLine");
	} /* if */
	while (count--) {
		if (fgets(linebuf, 200, vfpSrc) == NULL)
			Panic("Bad read in PrintLine");
		if (fPrintLn)
			printf("%3d:", iln);
		printf("	%.72s", linebuf);
		iln++;
	} /* while */
	viln = iln - 1;	/* set to last line printed */
} /* PrintLine */


/* I   F   S B   S B */

export int IFSbSb(sbLine, sbTarget)
char	*sbLine, *sbTarget;
{
	int 	cbLine, cbTarget, i;

	i = 0;	/* the index of sbTarget in sbLine */
	cbLine = strlen(sbLine);
	cbTarget = strlen(sbTarget);
	while (cbLine >= cbTarget) {
		if (FHdrCmp(sbTarget, sbLine))
			return(i);
		i++;
		sbLine++;
		cbLine--;
	} /* while */
	return(-1);
} /* IFSbSb */


/* F I N D */

export void Find(target, fBack)
char	*target;
FLAGT	fBack;
{
	int		lineinc, count, iln, ilnStart, ilnMac;
	uint	*rgLn;
	char	linebuf[200];

	iln = viln;
	ilnMac = vrgFd[vifd].ilnMac;
	rgLn = vrgFd[vifd].rgLn;
	if (fBack) {
		lineinc = -1;
		iln--;  /* for backup */
		count = iln;
	} 
	else {
		lineinc = 1;
		iln++;  /* start at next line */
		count = ilnMac - iln;
	} /* if */
	ilnStart = iln;

	if (fseek(vfpSrc, lengthen(rgLn[iln]), 0))
		Panic("Bad seek in Find - offset %d",rgLn[iln]);
	while (count--) {
		if (fBack)
			if (fseek(vfpSrc, lengthen(rgLn[iln]), 0))
				Panic("Bad seek in Find - offset %d",rgLn[iln]);
		if (fgets(linebuf, 200, vfpSrc) == NULL)
			Panic("Bad read in Find");
		if (IFSbSb(linebuf, target) >= 0)
			goto winner;
		iln += lineinc;
	} /* while */

	/* that didn't work, try it from the top of file */
	if (fBack) {
		iln = ilnMac - 1;
		count = ilnMac - ilnStart - 1;
	} 
	else {
		iln = 1;
		count = ilnStart;
	} /* if */
	if (fseek(vfpSrc, lengthen(rgLn[iln]), 0))
		Panic("Bad seek in Find");
	while (count--) {
		if (fBack)
			if (fseek(vfpSrc, lengthen(rgLn[iln]), 0))
				Panic("Bad seek in Find");
		if (fgets(linebuf, 200, vfpSrc) == NULL)
			Panic("Bad read in Find");
		if (IFSbSb(linebuf, target) >= 0)
			goto winner;
		iln += lineinc;
	} /* while */
	UError("No Match - %s", target);

winner:
	PrintLine(iln, 1, true);
} /* Find */


/* P R I N T   P O S */

export void PrintPos(adr, fmt)
ADRT	adr;
int	fmt;
{
	int 	ifd, iln, slop, ifdSave, ipdSave, ilnSave, slopSave;

	if (fmt & fmtSave) {
		ifdSave = vifd;
		ipdSave = vipd;
		ilnSave = viln;
		slopSave = vslop;
	} /* if */

	if (adr != adrNil) {
		IfdLnFAdr(adr, isym0, &ifd, &iln, &slop);
		if (ifd != vifdNil) {
			IfdFOpen(ifd);
			OpenIpd(IpdFAdr(adr), false);
			vslop = slop;
			viln = iln;
		} 
		else {
			vifd = vifdNil;
		} /* if */
		if (fmt == fmtNil)
			return;
	} /* if */

	if (vifd == vifdNil) {
		LabelFAdr(adr);	/* sets vsymCur to nearest label */
		if (fmt & fmtFile)
			printf("file unknown:");
		printf("**%s",SbInCore(vsymCur->sbSym));
		if (vsymCur->value != adr)
			printf("+%s",SbFAdr(lengthen(adr-vsymCur->value), true));
		putchar('\n');	
		goto cleanup;
	} /* if */

	if (fmt & fmtFile) {
		printf("%s:", vrgFd[vifd].sbFile);
	} /* if */

	if (fmt & fmtProc) {
		if (vipd != ipdNil) {
			printf("%s:",vrgPd[vipd].sbProc);
		} 
		else {
			printf("proc??:");
		} /* if */
	} /* if */

	if (fmt & fmtLn) {
		printf("%d", viln);
		if (vslop != 0)
			printf("+%s",SbFAdr(lengthen(vslop), true));
		putchar(':');
	} /* if */

	if (fmt & fmtPrint)
		PrintLine(viln, 1, false);
	else {
		printf(" ");	/* takes out last `:' */
		if (fmt & fmtEol)
			putchar('\n');
	} /* if */

cleanup:
	if (fmt & fmtSave) {
		vifd = vifdNil;
		IfdFOpen(ifdSave);
		vipd = ipdSave;
		viln = ilnSave;
		vslop = slopSave;
	} /* if */
} /* PrintPos */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.