//
//
// 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