Return to tables.c CVS log

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

Power 6/32 Unix version 1.21

/* $Header: /var/lib/cvsd/repos/cci/cci/usr/src/usr.bin/cdb/transBsd/tables.c,v 1.1.1.1 2019/07/28 12:25:33 root Exp $ */
/* (C) Copyright 1985 Third Eye Software, Inc. - All Rights Reserved */

#include "tes42.h"

#include <stab.h>


/* E N D   P R O C */

export void EndProc(adr)
ADRT	adr;
{
    pSYMR	sym;

    sym = SymFInsert();
    sym->st = stEnd;
    sym->sc = scText;
    sym->index = IsymFSym(vsymProc);
    sym->value = adr;
    ChangeAux(vsymProc->index, visym+1);
    vsymProc = symNil;

    sym = SymFIsym(visym-1);	/* check previous guy, too */
    if (sym->st == stEnd)
	sym->value = adr;
} /* EndProc */


/* D O   P R O C  */

export void DoProc(nlist)
pNLISTR	nlist;
{
    if (vsymProc != symNil)
	EndProc(nlist->n_value);

    vsymProc = SymFInsert();
    vsymProc->st = stProc;
    vsymProc->index = AddAux(-1);
    ProcInsert(IsymFSym(vsymProc), nlist->n_value, vilineMac);
    vcLinesInProc = 0;
} /* DoProc */


/* P S B H   F   H A S H   S B */

local pSBHR PsbhFHashSb(sb)
register char	*sb;
{
    register int	sum = 0;

    while (sb && *sb)
	sum += *sb++;

    return(&vpsbhBucket [sum % hashMod]);
} /* PsbhFHashSb */


/* I S S   F   S B   I N S E R T */

export long IssFSbInsert(sb)
register char	*sb;
{
    register pSBHR	psbh;
    register pSBHR	psbhPrev;
    register char	*sbT;
    register int	sum;

    sum = 0;
    if (sb != 0) {
	sbT = sb;
	while (*sbT)
	    sum += *sbT++;
    } /* if */
    psbh = vpsbhBucket + (sum % hashMod);

    while (psbh) {
	if ( (psbh->sb != 0)
	   && (!strcmp(sb, psbh->sb)) ) {
	    return(psbh->iss);
	} /* if */
	psbhPrev = psbh;
	psbh = psbh->psbh;
    } /* while */

    psbh = psbhPrev;
    psbh->psbh = (pSBHR) malloc (cbSBHR);
    psbh = psbh->psbh;
    sbT = psbh->sb = vsbMax;
    psbh->iss = vissMac;
    while (*(sbT++) = *(sb++))
	;

    vsbMax = sbT;
    vissMac = vsbMax - vsbNewStr;
    if (vissMac > vissMax)
	panic("Ran out of string space - use scaling factor");

    vissMac++;
    *(vsbMax++) = '\0';
    psbh->psbh = (pSBHR) 0;

    return (psbh->iss);
} /* IssFSbInsert */


/* D O   L I N E */

export void DoLine(nlist)
pNLISTR	nlist;
{
    pLINER	line;
    static ADRT	adrSecondLine;

    if (vcLinesInProc == 1) {
	/* If there is more than one line in a proc, we ignore the first.
	 * This is correct for all cases except:
	 *	foo() {int x = 1;
	 *	   .... etc.
	 *
	 * Which is brain damaged and life is tough, so there.
	 */
	vilineMac--;
	adrSecondLine = nlist->n_value;
    } else if ((vcLinesInProc >= 2) && (nlist->n_value == adrSecondLine)) {
	/* throw away previous line */
	vilineMac--;
    } /* if */

    if (vilineMac >= vilineMax)
	panic ("line table overflow");
    viline = vilineMac++;

    line= vrgLine + viline;
    line->iln= nlist->n_desc;
    line->dadr= nlist->n_value - vrgPd[vipd].adr;
    vdot = nlist->n_value;
    vcLinesInProc++;
} /* DoLine */


/* E N D   F I L E */

export void EndFile(adr)
ADRT	adr;
{
    register pSYMR	sym;

    if (vsymProc != symNil)
	EndProc(adr);

    vrgFd[vifd].ilnMac = vrgLine[viline].iln; /* kludge? */
    sym = SymFInsert();
    sym->st = stEnd;
    sym->sc = scText;
    sym->index = IsymFSym (vsymFile);
    vsymFile->index = IsymFSym(sym) + 1;	/* forward link */
    sym->value = (vdot == vsymFile->value) ? adr : vdot;
} /* EndFile */


/* D O   F I L E */

export void DoFile (nlist, sbName)
pNLISTR	nlist;
char		*sbName;
{
    register pFDR	fd;
    register pSYMR	sym;
    ADRT	adr;
    int		cb;

    if (vsymFile != symNil)
	EndFile(nlist->n_value);

    adr = (nlist == nlistNil) ? -1L : nlist->n_value;

   /* The weird chack for ending character of the filename
    * is to see if a file of pure data came before us.
    */
    if ((vifd > 0)
       && (sbName[strlen(sbName)-1] != 'o')
       && (vrgFd[vifd].adr == adr)) {
	/* this is the TRUE source file after Loader freebie symbol */
	fd= vrgFd  + vifd;
	visymMac = IsymFSym(vsymFile);	/* one more time! */
    } else {
	if (vifdMac >= vifdMax)
	    panic ("file table overflow");
	vifd = vifdMac++;
	fd= vrgFd + vifd;
    } /* if */

    cb = strlen(sbName);
    fd->iss = IssFSbInsert(sbName);
    fd->adr = adr;
    fd->isym = visymMac;
    fd->iline = vilineMac;

    vsymFile = sym = SymFInsert();
    sym->iss = fd->iss;
    sym->st = stFile;
    sym->sc = scText;
    vdot = sym->value = adr;

    /* reinit mapping array */
    ZeroBlock(&vrgTesF42 [tesF42Low],
	((vites42Max + 1) - tesF42Low) * sizeof(int) );
    vites42Max = tesF42Low;
} /* DoFile */


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

export void ProcInsert(isym, adr, iline)
register int	isym;
register long	adr;
register int	iline;
{
    register pPDR	pd, pd2;

    if (vipdMac >= vipdMax)
	panic("proc table overflow");

    vipd = vipdMac++;

    if ((vipd > 0) && (adr < vrgPd [vipd - 1].adr)) {
	/* we need to INSERT - not Append */

	/* find the proc we come AFTER */
	for (pd = vrgPd + vipd - 1; (pd >= vrgPd) && (pd->adr > adr); pd--)
		;
	/* move everything below it DOWN one */
	for (pd2 = vrgPd + vipd - 1; pd2 > pd; pd2--)
	    pd2[1] = *pd2;
	pd++;	/* point at new empty slot */
    } else {
	pd = vrgPd + vipd;
    } /* if */

    pd->isym = isym;
    pd->adr = adr;
    pd->iline = iline;
} /* ProcInsert */

strcmp(sb1, sb2)
char *sb1, *sb2;
{
    if (sb1 == 0 || sb2 == 0)
	return(1);
    while (*sb1 == *sb2) {
	if (*sb1 == '\0')
	    return(0);
	sb1++;
	sb2++;
    } /* while */
    return(1);
} /* strcmp */

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