You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
782 lines
17 KiB
782 lines
17 KiB
//
|
|
//
|
|
// mbRWBSC.C - Write .BSC Source Data Base file from various lists.
|
|
//
|
|
//
|
|
|
|
#define LINT_ARGS
|
|
|
|
#include <stdlib.h>
|
|
#include <search.h>
|
|
#include <ctype.h>
|
|
|
|
#include "sbrfdef.h"
|
|
#include "mbrmake.h"
|
|
#include "sbrbsc.h"
|
|
#include "mbrcache.h"
|
|
|
|
// prototypes
|
|
//
|
|
|
|
static void pascal WriteBSCHeader (void);
|
|
static void pascal WriteAtoms (void);
|
|
static void pascal WriteMods (void);
|
|
static void pascal WriteModSyms (void);
|
|
static void pascal WriteSyms (void);
|
|
static void pascal WriteProps (void);
|
|
static void pascal WriteRefs (void);
|
|
static void pascal WriteDefs (void);
|
|
static void pascal WriteCals (void);
|
|
static void pascal WriteCbys (void);
|
|
static void pascal WriteSbrInfo (void);
|
|
static void pascal IndexTree (void);
|
|
static void pascal BSCWrite (LPV lpv, WORD cch);
|
|
static void pascal BSCWriteLsz (LSZ lsz);
|
|
|
|
//
|
|
|
|
#define BSCOut(v) BSCWrite(&(v), sizeof(v))
|
|
|
|
static WORD CntAtomPage; // count of Atom pages
|
|
static WORD AtomCnt = 0;
|
|
|
|
static WORD unknownModName; // UNKNOWN module idx
|
|
|
|
static WORD ModSymCnt = 0; // count of modsyms
|
|
static WORD SymCnt = 0; // count of symbols
|
|
static WORD PropCnt = 0; // count of props
|
|
static DWORD RefCnt = 0; // count of refs
|
|
static WORD DefCnt = 0; // count of defs
|
|
static WORD CbyCnt = 0; // count of use half of above
|
|
static WORD CalCnt = 0; // count of used by half of above
|
|
|
|
static DWORD lbModList; // offset to Module list
|
|
static DWORD lbModSymList; // offset to ModSym list
|
|
static DWORD lbSymList; // offset to Symbol list
|
|
static DWORD lbPropList; // offset to Property list
|
|
static DWORD lbRefList; // offset to Reference list
|
|
static DWORD lbDefList; // offset to Definition list
|
|
static DWORD lbCalList; // offset to Call/used list
|
|
static DWORD lbCbyList; // offset to Call/used list
|
|
static DWORD lbAtomCache; // offset to Sym Atom cache
|
|
static DWORD lbSbrList; // offset to Sbr file names
|
|
|
|
extern char far *GetAtomCache (WORD);
|
|
|
|
void
|
|
WriteBSC (char *OutputFileName)
|
|
// Write .BSC Source Data Base
|
|
//
|
|
{
|
|
OutFile = fopen(OutputFileName, "wb");
|
|
if (OutFile == NULL) {
|
|
Error(ERR_OPEN_FAILED, OutputFileName);
|
|
}
|
|
|
|
//
|
|
// no backing out from here -- if we fail we must delete the database
|
|
//
|
|
|
|
fOutputBroken = TRUE;
|
|
|
|
WriteBSCHeader(); // save space for header
|
|
|
|
WriteAtoms(); // sort and write atom cache
|
|
|
|
IndexTree(); // xlate pointers to indices
|
|
|
|
BldModSymList(); // Build module symbol list
|
|
|
|
SetVMClient(VM_EMIT_TREE);
|
|
|
|
unknownModName = gSYM(vaUnknownSym).isym; // record UNKNOWN index
|
|
|
|
WriteMods(); // output modules
|
|
WriteModSyms(); // output module symbol lists
|
|
WriteSyms(); // output all symbols
|
|
WriteProps(); // output all prop headers
|
|
WriteRefs(); // output all refs
|
|
WriteDefs(); // output all defs
|
|
WriteCals(); // output all uses/calls
|
|
WriteCbys(); // output all UBY/CBY
|
|
WriteSbrInfo(); // output the SBR file names
|
|
|
|
if (fseek(OutFile, 0L, SEEK_SET)) // Beginning of file
|
|
SeekError (OutputFileName);
|
|
|
|
WriteBSCHeader (); // output .BSC header
|
|
|
|
fclose(OutFile);
|
|
|
|
//
|
|
// we're all done --- it's a keeper!
|
|
//
|
|
|
|
fOutputBroken = FALSE;
|
|
|
|
SetVMClient(VM_MISC);
|
|
|
|
if (OptV) {
|
|
printf ("%u\tModules\n", ModCnt);
|
|
printf ("%u\tSymbols\n", SymCnt);
|
|
printf ("%u\tDefinitions\n", DefCnt);
|
|
printf ("%u\tReferences\n", RefCnt);
|
|
printf ("%u\tCalls/Uses\n", CalCnt);
|
|
printf ("%u\tCalled by/Used by\n", CbyCnt);
|
|
#ifdef DEBUG
|
|
printf ("\n");
|
|
printf ("%u\tTotal ModSyms\n", ModSymCnt);
|
|
printf ("%u\tTotal Properties\n", PropCnt);
|
|
printf ("%u\tLast Atom page \n", AtomCnt);
|
|
printf ("\n");
|
|
printf ("%lu\tBase of AtomCache\n", lbAtomCache);
|
|
printf ("%lu\tBase of ModList\n", lbModList);
|
|
printf ("%lu\tBase of ModSymList\n", lbModSymList);
|
|
printf ("%lu\tBase of SymList\n", lbSymList);
|
|
printf ("%lu\tBase of PropList\n", lbPropList);
|
|
printf ("%lu\tBase of RefList\n", lbRefList);
|
|
printf ("%lu\tBase of DefList\n", lbDefList);
|
|
printf ("%lu\tBase of CalList\n", lbCalList);
|
|
printf ("%lu\tBase of CbyList\n", lbCbyList);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteBSCHeader ()
|
|
// Write .BSC header, counts, and table offsets.
|
|
//
|
|
{
|
|
BYTE ver; // version num
|
|
|
|
// output BSC version (major and minor)
|
|
|
|
ver = BSC_MAJ;
|
|
BSCOut(ver); // major ver
|
|
|
|
ver = BSC_MIN;
|
|
BSCOut(ver); // minor ver
|
|
|
|
ver = BSC_UPD;
|
|
BSCOut(ver); // update ver
|
|
|
|
BSCOut(fCase); // case sensitive
|
|
BSCOut(MaxSymLen); // biggest symbol allowed
|
|
|
|
BSCOut(unknownModName); // UNKNOWN idx
|
|
|
|
// output counts (sizes) of each data area
|
|
|
|
BSCOut(ModCnt);
|
|
BSCOut(ModSymCnt);
|
|
BSCOut(SymCnt);
|
|
BSCOut(PropCnt);
|
|
BSCOut(RefCnt);
|
|
BSCOut(DefCnt);
|
|
BSCOut(CalCnt);
|
|
BSCOut(CbyCnt);
|
|
|
|
// last page #
|
|
|
|
BSCOut(CntAtomPage);
|
|
|
|
// last page size
|
|
|
|
BSCOut(AtomCnt);
|
|
|
|
// output BSC data area offsets
|
|
|
|
BSCOut(lbModList);
|
|
BSCOut(lbModSymList);
|
|
BSCOut(lbSymList);
|
|
BSCOut(lbPropList);
|
|
BSCOut(lbRefList);
|
|
BSCOut(lbDefList);
|
|
BSCOut(lbCalList);
|
|
BSCOut(lbCbyList);
|
|
BSCOut(lbAtomCache);
|
|
BSCOut(lbSbrList);
|
|
}
|
|
|
|
static void pascal
|
|
WriteAtoms ()
|
|
// Write a sorted version of the symbol Atom Cache to the .BSC file by walking
|
|
// the sorted symbol subscript array
|
|
//
|
|
{
|
|
WORD i;
|
|
int Atomlen;
|
|
LPCH lpchAtoms;
|
|
LSZ lszAtom;
|
|
|
|
VA vaSym;
|
|
|
|
SetVMClient(VM_EMIT_ATOMS);
|
|
|
|
lpchAtoms = LpvAllocCb(ATOMALLOC);
|
|
|
|
lbAtomCache = ftell(OutFile); // offset to text of symbols
|
|
|
|
for (i=0; i < cAtomsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
gSYM(vaSym);
|
|
lszAtom = gTEXT(cSYM.vaNameText);
|
|
|
|
Atomlen = strlen(lszAtom);
|
|
|
|
// write Atom page if not enough room
|
|
//
|
|
if (Atomlen + AtomCnt + 1 > ATOMALLOC) {
|
|
if (AtomCnt < ATOMALLOC)
|
|
memset(lpchAtoms + AtomCnt, 0, ATOMALLOC - AtomCnt);
|
|
|
|
if ((fwrite (lpchAtoms, ATOMALLOC, 1, OutFile)) != 1)
|
|
WriteError (OutputFileName);
|
|
|
|
CntAtomPage++;
|
|
AtomCnt = 0;
|
|
}
|
|
|
|
strcpy(lpchAtoms + AtomCnt, lszAtom); // copy Atom
|
|
|
|
cSYM.vaNameText = (PVOID)(((long)CntAtomPage << 16) | (AtomCnt));
|
|
|
|
pSYM(vaSym);
|
|
|
|
AtomCnt += Atomlen + 1;
|
|
|
|
// force to even value
|
|
if (AtomCnt & 1) lpchAtoms[AtomCnt++] = 0;
|
|
}
|
|
|
|
// write last Atom page
|
|
//
|
|
if (AtomCnt)
|
|
if ((fwrite (lpchAtoms, AtomCnt, 1, OutFile)) != 1)
|
|
WriteError (OutputFileName);
|
|
|
|
// free all the memory for the atom cache, we no longer need it
|
|
|
|
fflush (OutFile);
|
|
|
|
FreeLpv(lpchAtoms);
|
|
|
|
SetVMClient(VM_MISC);
|
|
}
|
|
|
|
static void pascal
|
|
WriteMods()
|
|
// write out the list of modules
|
|
//
|
|
// compute the MODSYM indices as we do this
|
|
//
|
|
{
|
|
MODLIST bmod;
|
|
VA vaMod;
|
|
WORD i;
|
|
|
|
ModSymCnt = 0;
|
|
lbModList = ftell(OutFile); // offset to Module list
|
|
|
|
for (i = cSymbolsMac; i < cAtomsMac; i++) {
|
|
gSYM(rgvaSymSorted[i]);
|
|
vaMod = cSYM.vaFirstProp; // points back to module, honest!
|
|
gMOD(vaMod);
|
|
|
|
bmod.ModName = gSYM(cMOD.vaNameSym).isym; // module name idx
|
|
ModSymCnt += cMOD.csyms;
|
|
bmod.mSymEnd = ModSymCnt; // last ModSym idx +1
|
|
BSCOut(bmod);
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteModSyms()
|
|
// write out the list of modsyms
|
|
//
|
|
{
|
|
MODSYMLIST bmodsym;
|
|
VA vaMod, vaModSym;
|
|
WORD i;
|
|
|
|
lbModSymList = ftell(OutFile); // offset to ModSym list
|
|
|
|
for (i = cSymbolsMac; i < cAtomsMac; i++) {
|
|
gSYM(rgvaSymSorted[i]);
|
|
vaMod = cSYM.vaFirstProp; // points back to module, honest!
|
|
gMOD(vaMod);
|
|
|
|
vaModSym = cMOD.vaFirstModSym;
|
|
while (vaModSym) {
|
|
gMODSYM(vaModSym);
|
|
|
|
// Symbol Property idx
|
|
bmodsym.ModSymProp = gPROP(cMODSYM.vaFirstProp).iprp;
|
|
|
|
BSCOut(bmodsym);
|
|
|
|
vaModSym = cMODSYM.vaNextModSym;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteSyms()
|
|
// write out the list of SYMs
|
|
//
|
|
{
|
|
SYMLIST bsym;
|
|
VA vaSym;
|
|
WORD i;
|
|
|
|
lbSymList = ftell(OutFile); // offset to Symbol list
|
|
|
|
PropCnt = 0;
|
|
for (i=0; i < cAtomsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
gSYM(vaSym);
|
|
|
|
PropCnt += cSYM.cprop;
|
|
|
|
bsym.PropEnd = PropCnt; // last Prop idx +1
|
|
bsym.Atom = (WORD)((long)cSYM.vaNameText & 0xffff); // Atom cache offset
|
|
bsym.Page = (WORD)((long)cSYM.vaNameText >> 16); // Atom cache page
|
|
|
|
BSCOut(bsym);
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteProps ()
|
|
// write out the list of PROPS to the database
|
|
//
|
|
// the number of definitions (DefCnt), references (RefCnt),
|
|
// calls (CalCnt) and called-by (CbyCnt) items are computed at this time
|
|
//
|
|
// Each PROP is assigned numbers for its associated objects
|
|
//
|
|
{
|
|
PROPLIST bprop;
|
|
VA vaSym, vaProp;
|
|
WORD i;
|
|
|
|
lbPropList = ftell(OutFile); // offset to Property list
|
|
|
|
DefCnt = 0;
|
|
RefCnt = 0L;
|
|
CalCnt = 0;
|
|
CbyCnt = 0;
|
|
|
|
for (i=0; i < cSymbolsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
vaProp = gSYM(vaSym).vaFirstProp;
|
|
|
|
while (vaProp) {
|
|
gPROP(vaProp);
|
|
gSYM(cPROP.vaNameSym);
|
|
|
|
bprop.PropName = cSYM.isym; // Symbol idx
|
|
bprop.PropAttr = cPROP.sattr; // Property Attribute
|
|
|
|
DefCnt += CItemsList(cPROP.vaDefList);
|
|
|
|
bprop.DefEnd = DefCnt; // last Definition idx +1
|
|
|
|
RefCnt += cPROP.cref;
|
|
|
|
bprop.RefEnd = RefCnt; // last Reference idx +1
|
|
|
|
CalCnt += CItemsList(cPROP.vaCalList);
|
|
|
|
bprop.CalEnd = CalCnt; // last Calls/uses idx +1
|
|
|
|
CbyCnt += CItemsList(cPROP.vaCbyList);
|
|
|
|
bprop.CbyEnd = CbyCnt; // last Called by/used by idx +1
|
|
|
|
BSCOut(bprop);
|
|
|
|
vaProp = cPROP.vaNextProp;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteRefs()
|
|
// write out the list of references
|
|
//
|
|
{
|
|
REFLIST bref;
|
|
VA vaSym, vaProp, vaRef;
|
|
WORD i;
|
|
|
|
lbRefList = ftell(OutFile); // offset to Reference list
|
|
|
|
for (i=0; i < cSymbolsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
vaProp = gSYM(vaSym).vaFirstProp;
|
|
|
|
while (vaProp) {
|
|
gPROP(vaProp);
|
|
|
|
vaRef = VaFrVp(cPROP.vpFirstRef);
|
|
while (vaRef) {
|
|
gREF(vaRef);
|
|
|
|
gSYM(VaFrVp(cREF.vpFileSym));
|
|
|
|
bref.RefNam = cSYM.isym; // Symbol idx
|
|
bref.RefLin = cREF.reflin; // Symbol lin
|
|
bref.isbr = cREF.isbr; // owner
|
|
|
|
BSCOut(bref);
|
|
|
|
vaRef = VaFrVp(cREF.vpNextRef);
|
|
}
|
|
|
|
vaProp = cPROP.vaNextProp;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteDefs()
|
|
// write out the list of defintions
|
|
//
|
|
{
|
|
REFLIST bdef;
|
|
WORD i;
|
|
VA vaProp, vaSym;
|
|
|
|
lbDefList = ftell(OutFile); // offset to Definition list
|
|
|
|
for (i=0; i < cSymbolsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
vaProp = gSYM(vaSym).vaFirstProp;
|
|
|
|
while (vaProp) {
|
|
gPROP(vaProp);
|
|
|
|
ENM_LIST (cPROP.vaDefList, DEF)
|
|
|
|
gSYM(cDEF.vaFileSym);
|
|
|
|
bdef.RefNam = cSYM.isym; // Symbol idx
|
|
bdef.RefLin = cDEF.deflin; // Symbol lin
|
|
bdef.isbr = cDEF.isbr; // owner
|
|
|
|
BSCOut(bdef);
|
|
|
|
ENM_END
|
|
|
|
vaProp = cPROP.vaNextProp;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void pascal
|
|
WriteCals()
|
|
// write out the list of uses (CALs) items
|
|
//
|
|
{
|
|
USELIST buse;
|
|
PROP prop;
|
|
VA vaSym, vaProp;
|
|
WORD i;
|
|
|
|
lbCalList = ftell(OutFile); // offset to CAL list
|
|
|
|
for (i=0; i < cSymbolsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
vaProp = gSYM(vaSym).vaFirstProp;
|
|
|
|
while (vaProp) {
|
|
prop = gPROP(vaProp);
|
|
|
|
ENM_LIST(prop.vaCalList, CAL)
|
|
|
|
gPROP(cCAL.vaCalProp);
|
|
|
|
buse.UseProp = cPROP.iprp; // property idx
|
|
buse.UseCnt = (BYTE) cCAL.calcnt; // use count
|
|
buse.isbr = cCAL.isbr; // owner
|
|
|
|
BSCOut(buse);
|
|
|
|
ENM_END
|
|
|
|
vaProp = prop.vaNextProp;
|
|
}
|
|
}
|
|
BSCOut(buse); // Pad
|
|
}
|
|
|
|
static void pascal
|
|
WriteCbys()
|
|
// write out the list of used-by (CBY) items
|
|
//
|
|
{
|
|
USELIST buse;
|
|
PROP prop;
|
|
VA vaSym, vaProp;
|
|
WORD i;
|
|
|
|
lbCbyList = ftell(OutFile); // offset to CBY list
|
|
|
|
for (i=0; i < cSymbolsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
vaProp = gSYM(vaSym).vaFirstProp;
|
|
|
|
while (vaProp) {
|
|
prop = gPROP(vaProp);
|
|
|
|
ENM_LIST(prop.vaCbyList, CBY)
|
|
|
|
gPROP(cCBY.vaCbyProp);
|
|
|
|
buse.UseProp = cPROP.iprp; // property idx
|
|
buse.UseCnt = (BYTE) cCBY.cbycnt; // use count
|
|
buse.isbr = cCBY.isbr; // owner
|
|
|
|
BSCOut(buse);
|
|
|
|
ENM_END
|
|
|
|
vaProp = prop.vaNextProp;
|
|
}
|
|
}
|
|
BSCOut(buse); // Pad
|
|
}
|
|
|
|
static void pascal
|
|
WriteSbrInfo()
|
|
// write out the names of the .sbr files in the correct order
|
|
//
|
|
{
|
|
VA vaSbr;
|
|
WORD isbr;
|
|
VA *rgVaSbr;
|
|
|
|
lbSbrList = ftell(OutFile);
|
|
|
|
rgVaSbr = (VA *)LpvAllocCb(SbrCnt * (WORD)sizeof(VA));
|
|
|
|
for (isbr = 0; isbr < SbrCnt; isbr++)
|
|
rgVaSbr[isbr] = vaNil;
|
|
|
|
vaSbr = vaRootSbr;
|
|
while (vaSbr) {
|
|
gSBR(vaSbr);
|
|
if (cSBR.isbr != -1)
|
|
rgVaSbr[cSBR.isbr] = vaSbr;
|
|
|
|
vaSbr = cSBR.vaNextSbr;
|
|
}
|
|
|
|
for (isbr = 0; isbr < SbrCnt; isbr++) {
|
|
if (rgVaSbr[isbr] != vaNil) {
|
|
gSBR(rgVaSbr[isbr]);
|
|
BSCWriteLsz(cSBR.szName);
|
|
}
|
|
}
|
|
BSCWriteLsz("");
|
|
}
|
|
|
|
static void pascal
|
|
IndexTree ()
|
|
// Walk all the list of all symbols and index each prop as we find it
|
|
// at this point we also count the total number of defs + refs to
|
|
// make sure that we can actually create this database
|
|
//
|
|
{
|
|
VA vaSym, vaProp;
|
|
DWORD cdefs = 0;
|
|
DWORD crefs = 0;
|
|
DWORD ccals = 0;
|
|
DWORD ccbys = 0;
|
|
WORD i;
|
|
|
|
SetVMClient(VM_INDEX_TREE);
|
|
|
|
SymCnt = 0;
|
|
PropCnt = 0;
|
|
|
|
for (i=0; i < cAtomsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
gSYM(vaSym);
|
|
cSYM.isym = SymCnt++; // Symbol index
|
|
pSYM(vaSym);
|
|
|
|
// the vaFirstProp field is used for something else in module symbols
|
|
if (cSYM.cprop)
|
|
vaProp = cSYM.vaFirstProp;
|
|
else
|
|
vaProp = vaNil;
|
|
|
|
while (vaProp) {
|
|
gPROP(vaProp);
|
|
|
|
cPROP.iprp = PropCnt++; // Property index
|
|
|
|
cdefs += CItemsList(cPROP.vaDefList);
|
|
crefs += cPROP.cref;
|
|
ccals += CItemsList(cPROP.vaCalList);
|
|
ccbys += CItemsList(cPROP.vaCbyList);
|
|
|
|
pPROP(vaProp);
|
|
|
|
vaProp = cPROP.vaNextProp;
|
|
}
|
|
}
|
|
SymCnt -= ModCnt; // Subtract module names
|
|
|
|
if (cdefs > 0xffffL ||
|
|
crefs > 0xffffffL ||
|
|
ccals > 0xffffL ||
|
|
ccbys > 0xffffL) {
|
|
if (OptV) {
|
|
printf ("%u\tModules\n", ModCnt);
|
|
printf ("%u\tSymbols\n", SymCnt);
|
|
printf ("%lu\tDefinitions\n", cdefs);
|
|
printf ("%lu\tReferences\n", crefs);
|
|
printf ("%lu\tCalls/Uses\n", ccals);
|
|
printf ("%lu\tCalled by/Used by\n", ccbys);
|
|
}
|
|
Error(ERR_CAPACITY_EXCEEDED, "");
|
|
}
|
|
|
|
SetVMClient(VM_MISC);
|
|
}
|
|
|
|
static void pascal
|
|
BSCWrite(LPV lpv, WORD cch)
|
|
// write block to the .bsc file
|
|
//
|
|
{
|
|
if (fwrite(lpv, cch, 1, OutFile) != 1)
|
|
WriteError (OutputFileName);
|
|
}
|
|
|
|
static void pascal
|
|
BSCWriteLsz(LSZ lsz)
|
|
// write a null terminated string to the BSC file
|
|
//
|
|
{
|
|
BSCWrite(lsz, (WORD)(strlen(lsz)+1));
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
void
|
|
DebugDump()
|
|
{
|
|
VA vaMod, vaProp, vaSym;
|
|
WORD i;
|
|
|
|
vaMod = vaRootMod;
|
|
printf("Modules:\n");
|
|
while (vaMod) {
|
|
gMOD(vaMod);
|
|
printf ("\t%s\n", GetAtomStr (cMOD.vaNameSym));
|
|
vaMod = cMOD.vaNextMod;
|
|
}
|
|
printf ("\nAll Symbols:\n");
|
|
|
|
for (i=0; i < cAtomsMac; i++) {
|
|
vaSym = rgvaSymSorted[i];
|
|
if (vaSym == vaNil) continue;
|
|
|
|
gSYM(vaSym);
|
|
|
|
// the vaFirstProp field is used for something else in module symbols
|
|
if (cSYM.cprop)
|
|
vaProp = cSYM.vaFirstProp;
|
|
else
|
|
vaProp = vaNil;
|
|
|
|
while (vaProp) {
|
|
gPROP(vaProp);
|
|
|
|
DebugDumpProp(vaProp);
|
|
|
|
vaProp = gPROP(vaProp).vaNextProp;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
DebugDumpProp(VA vaProp)
|
|
{
|
|
PROP prop;
|
|
VA vaRef;
|
|
|
|
gPROP(vaProp);
|
|
prop = cPROP;
|
|
|
|
printf ("%s ", GetAtomStr (prop.vaNameSym));
|
|
printf ("\t\t[%d %d %d %d]\n",
|
|
CItemsList(prop.vaDefList),
|
|
prop.cref,
|
|
CItemsList(prop.vaCalList),
|
|
CItemsList(prop.vaCbyList)
|
|
);
|
|
|
|
ENM_LIST(prop.vaDefList, DEF)
|
|
|
|
printf ("\tdefined in %s(%d) <%d>\n",
|
|
GetAtomStr (cDEF.vaFileSym),
|
|
cDEF.deflin,
|
|
cDEF.isbr
|
|
);
|
|
ENM_END
|
|
|
|
vaRef = VaFrVp(prop.vpFirstRef);
|
|
while (vaRef) {
|
|
gREF(vaRef);
|
|
|
|
printf ("\trefer'd in %s(%d) <%d>\n",
|
|
GetAtomStr ( VaFrVp(cREF.vpFileSym) ),
|
|
cREF.reflin,
|
|
cREF.isbr
|
|
);
|
|
|
|
vaRef = VaFrVp(cREF.vpNextRef);
|
|
}
|
|
|
|
ENM_LIST(prop.vaCalList, CAL)
|
|
|
|
printf ("\tcalls/uses %s[%d] <%d>\n",
|
|
GetAtomStr (gPROP(cCAL.vaCalProp).vaNameSym),
|
|
cCAL.calcnt,
|
|
cCAL.isbr
|
|
);
|
|
ENM_END
|
|
|
|
ENM_LIST(prop.vaCbyList, CBY)
|
|
|
|
printf ("\tc-by/u-by %s[%d] <%d>\n",
|
|
GetAtomStr (gPROP(cCBY.vaCbyProp).vaNameSym),
|
|
cCBY.cbycnt,
|
|
cCBY.isbr
|
|
);
|
|
ENM_END
|
|
|
|
}
|
|
#endif
|