/***************************************************************************/
/* omf51print.c */
/***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include "omf51.h"
#include "omf51const.h"
#include "omf51print.h"

/***************************************************************************/
/* Constants
/***************************************************************************/

/***************************************************************************/
/* Helper Functions
/***************************************************************************/
BYTE SegmentGetSegType(BYTE segInfo)
{
	return (segInfo & 0x07);
}

BYTE SegmentGetSegReg(BYTE segInfo)
{
	return (segInfo & 0x18) >> 3; 
}

BYTE SegmentIsEmpty(BYTE segInfo)
{
	return (segInfo & 0x80) >> 7;
}

BYTE SegmentIsOVL(BYTE segInfo)
{
	return (segInfo & 0x20) >> 5;
}

BYTE SymbolIsIND(BYTE symInfo)
{
	return (symInfo & 0x80) >> 7;
}

BYTE SymbolIsVAR(BYTE symInfo)
{
	return (symInfo & 0x40) >> 6;
}

BYTE SymbolIsRBF(BYTE symInfo)
{
	return (symInfo & 0x20) >> 5;
}

BYTE SymbolGetSymReg(BYTE symInfo)
{
	return (symInfo & 0x18) >> 3; 
}

BYTE SegmentGetSymType(BYTE symInfo)
{
	return (symInfo & 0x07);
}

/***************************************************************************/
/* Exported Functions
/***************************************************************************/
void MHDRPrint(struct _sMHDR *pObj, FILE *pFile)
{
	fprintf(pFile, "Module name   : %s\n",pObj->name);
	fprintf(pFile, "Software used : ");
	
	switch(pObj->trnID)
	{
	case 0xFD:
		fprintf(pFile, "ASM51 ");
		break;

	case 0xFE:
		fprintf(pFile, "PL/M-51 ");
		break;

	case 0xFF:
		fprintf(pFile, "RL51 ");
		break;
	
	default:
		fprintf(pFile, "Unknown ");
		break;
	}
	fprintf(pFile, "(0x%2.2X)\n",pObj->trnID);
	fprintf(pFile, "\n");
}


void SEGDEFPrint(struct _sSEGDEF *pObj, FILE *pFile)
{
	fprintf(pFile, "Segment name    : %s\n", pObj->name);
	fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
	if (pObj->segID == 0)
		fprintf(pFile, " (Absolut)\n");
	else
		fprintf(pFile, "\n");

	fprintf(pFile, "Relocation Type : %s (0x%2.2X)\n", relTypeName[pObj->relTYP], pObj->relTYP);

	fprintf(pFile, "Empty           : ");
	if (SegmentIsEmpty(pObj->segINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Overlayable     : ");
	if (SegmentIsOVL(pObj->segINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Register bank   : %x\n",SegmentGetSegReg(pObj->segINFO));
	fprintf(pFile, "Segment Type    : %s\n",segTypeName[SegmentGetSegType(pObj->segINFO)]);
	
	fprintf(pFile, "Segment base    : 0x%4.4X\n", pObj->segBASE);
	fprintf(pFile, "Segment size    : 0x%4.4X\n", pObj->segSIZE);
	fprintf(pFile, "\n");
}

void SEGPrint(struct _sSEG *pObj, FILE *pFile)
{
	DBYTE i;

	for (i=0; i < pObj->numSegDef; i++)
		SEGDEFPrint(&pObj->segDef[i], pFile);
}

void PUBDEFPrint(struct _sPUBDEF *pObj, FILE *pFile)
{
	fprintf(pFile, "Public name     : %s\n", pObj->name);
	fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
	if (pObj->segID == 0)
		fprintf(pFile, " (Absolut)\n");
	else
		fprintf(pFile, "\n");

	fprintf(pFile, "Indirect Call   : ");
	if (SymbolIsIND(pObj->symINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Variable        : ");
	if (SymbolIsVAR(pObj->symINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Reg. Banks used : ");
	if (SymbolIsRBF(pObj->symINFO) == 1)
		fprintf(pFile, "at least one bank\n");
	else
		fprintf(pFile, "all\n");

	fprintf(pFile, "Register bank   : %x\n",SymbolGetSymReg(pObj->symINFO));
	fprintf(pFile, "Usage Type      : %s\n",symTypeName[SegmentGetSymType(pObj->symINFO)]);
	
	fprintf(pFile, "Symbol Offset   : 0x%4.4X\n", pObj->offset);
	fprintf(pFile, "\n");

}

void PUBPrint(struct _sPUB *pObj, FILE *pFile)
{
	DBYTE i;

	for (i=0; i < pObj->numPubDef; i++)
		PUBDEFPrint(&pObj->pubDef[i], pFile);
}

void EXTDEFPrint(struct _sEXTDEF *pObj, FILE *pFile)
{
	fprintf(pFile, "External name   : %s\n", pObj->name);
	fprintf(pFile, "ID BLK          : 0x%2.2X\n", pObj->idBlk);
	fprintf(pFile, "EXT ID          : 0x%2.2X\n", pObj->extID);
	
	fprintf(pFile, "Indirect Call   : ");
	if (SymbolIsIND(pObj->symINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Variable        : ");
	if (SymbolIsVAR(pObj->symINFO) == 1)
		fprintf(pFile, "Yes\n");
	else
		fprintf(pFile, "No\n");

	fprintf(pFile, "Reg. Banks used : ");
	if (SymbolIsRBF(pObj->symINFO) == 1)
		fprintf(pFile, "at least one bank\n");
	else
		fprintf(pFile, "all\n");

	fprintf(pFile, "Register bank   : %x\n",SymbolGetSymReg(pObj->symINFO));
	fprintf(pFile, "Usage Type      : %s\n",symTypeName[SegmentGetSymType(pObj->symINFO)]);
	
	fprintf(pFile, "\n");

}

void EXTPrint(struct _sEXT *pObj, FILE *pFile)
{
	DBYTE i;

	for (i=0; i < pObj->numExtDef; i++)
		EXTDEFPrint(&pObj->extDef[i], pFile);
}

void SCDPrint(struct _sSCD *pObj, FILE *pFile)
{
	fprintf(pFile, "Block name      : %s\n",pObj->name);
	fprintf(pFile, "BLK TYP         : %s (0x%2.2X)\n",blkTypeName[pObj->blkTYP], pObj->blkTYP);
	fprintf(pFile, "\n");
}
	
void DBGINFOPrint(struct _sDBGINFO *pObj, FILE *pFile, BYTE defType)
{
	
	switch(defType)
	{
		case DBG_DEFTYP_LOCAL:
		case DBG_DEFTYP_PUBLIC:
			fprintf(pFile, "Symbol name     : %s\n", pObj->name);
			fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
			if (pObj->segID == 0)
				fprintf(pFile, " (Absolut)\n");
			else
				fprintf(pFile, "\n");

			fprintf(pFile, "Indirect Call   : ");
			if (SymbolIsIND(pObj->symINFO) == 1)
				fprintf(pFile, "Yes\n");
			else
				fprintf(pFile, "No\n");

			fprintf(pFile, "Variable        : ");
			if (SymbolIsVAR(pObj->symINFO) == 1)
				fprintf(pFile, "Yes\n");
			else
				fprintf(pFile, "No\n");

			fprintf(pFile, "Reg. Banks used : ");
			if (SymbolIsRBF(pObj->symINFO) == 1)
				fprintf(pFile, "at least one bank\n");
			else
				fprintf(pFile, "all\n");

			fprintf(pFile, "Register bank   : %x\n",SymbolGetSymReg(pObj->symINFO));
			fprintf(pFile, "Usage Type      : %s\n",symTypeName[SegmentGetSymType(pObj->symINFO)]);
	
			fprintf(pFile, "Symbol Offset   : 0x%4.4X\n", pObj->offset);

			break;

		case DBG_DEFTYP_SEGMENT:
			fprintf(pFile, "Symbol name     : %s\n", pObj->name);
			fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
			if (pObj->segID == 0)
				fprintf(pFile, " (Absolut)\n");
			else
				fprintf(pFile, "\n");

			fprintf(pFile, "Empty           : ");
			if (SegmentIsEmpty(pObj->segINFO) == 1)
				fprintf(pFile, "Yes\n");
			else
				fprintf(pFile, "No\n");

			fprintf(pFile, "Overlayable     : ");
			if (SegmentIsOVL(pObj->segINFO) == 1)
				fprintf(pFile, "Yes\n");
			else
				fprintf(pFile, "No\n");

			fprintf(pFile, "Register bank   : %x\n",SegmentGetSegReg(pObj->segINFO));
			fprintf(pFile, "Segment Type    : %s\n",segTypeName[SegmentGetSegType(pObj->segINFO)]);
				break;

		case DBG_DEFTYP_LINE:
			fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
			if (pObj->segID == 0)
				fprintf(pFile, " (Absolut)\n");
			else
				fprintf(pFile, "\n");
			fprintf(pFile, "Symbol Offset   : 0x%4.4X\n", pObj->offset);
			fprintf(pFile, "Line number     : 0x%4.4X\n", pObj->lineNumber);
				break;
	}
	fprintf(pFile, "\n");
}

void DBGPrint(struct _sDBG *pObj, FILE *pFile)
{
	DBYTE i;

	fprintf(pFile, "* DEF TYP       : %s (0x%2.2X)\n",dbgDefTypeName[pObj->defTYP], pObj->defTYP);
	
	for (i=0; i < pObj->numDbgInfo; i++)
		DBGINFOPrint(&pObj->dbgInfo[i], pFile, pObj->defTYP);
}

void CNTPrint(struct _sCNT *pObj, FILE *pFile)
{
	fprintf(pFile, "Segment ID      : 0x%2.2X", pObj->segID);
	if (pObj->segID == 0)
		fprintf(pFile, " (Absolut)\n");
	else
		fprintf(pFile, "\n");

	fprintf(pFile, "Symbol Offset   : 0x%4.4X\n", pObj->offset);
	fprintf(pFile, "Data Size       : 0x%4.4X\n", pObj->size);
}

void ModulePrint(struct _sMODULE *pObj, FILE *pFile)
{
	DBYTE i;

	fprintf(pFile, "Module name   : %s\n", pObj->pName);

	i = 0;
	while (pObj->ppCnt[i])
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Content [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		CNTPrint(pObj->ppCnt[i++], pFile);
	}
	
}

void OmfPrint(struct _sOBJECT *pObj)
{
	char name[255];
	BYTE segID;
	DBYTE i;
	FILE *pFile;
	SEGDEF *pSegDef;

	if (pObj->allocType == OBJECT_IS_ABS)
		sprintf(name, "%s_abs.omf",pObj->mhdr[0].name);
	else
		sprintf(name, "%s_rel.omf",pObj->mhdr[0].name);

	pFile = fopen(name,"wa");
	
	if (pObj->allocType == OBJECT_IS_ABS)
		fprintf(pFile,"%s (Absolut OMF)\n",pObj->fileName);
	else
		fprintf(pFile,"%s (Relocatible OMF)\n",pObj->fileName);

	for (i=0; i < pObj->numMHDR; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Module Header [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		MHDRPrint(&pObj->mhdr[i], pFile);
	}

	for (i=0; i < pObj->numSEG; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Segment Definition [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		SEGPrint(&pObj->seg[i], pFile);
	}
	
	for (i=0; i < pObj->numPUB; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Public Definition [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		PUBPrint(&pObj->pub[i], pFile);
	}

	for (i=0; i < pObj->numEXT; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* External Definition [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		EXTPrint(&pObj->ext[i], pFile);
	}

	for (i=0; i < pObj->numSCD; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Scope Definition [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		SCDPrint(&pObj->scd[i], pFile);
	}
	
	for (i=0; i < pObj->numDBG; i++)
	{
		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Debug Item [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		DBGPrint(&pObj->dbg[i], pFile);
	}

	for (i=0; i < pObj->numCNT; i++)
	{
		segID = pObj->cnt[i].segID;
		if (segID == 0)
			pSegDef = NULL;
		else
			pSegDef = &pObj->seg[0].segDef[segID-1];

		fprintf(pFile, "******************************************************************\n");
		fprintf(pFile, "* Content [%2.2X]\n",i);
		fprintf(pFile, "******************************************************************\n");
		CNTPrint(&pObj->cnt[i], pFile);
		if (pSegDef==NULL)
		{
			fprintf(pFile, "\n");
		}
		else
		{
			fprintf(pFile, "------------------------------------------------------------------\n");
			fprintf(pFile, " Segment Definition:\n");
			fprintf(pFile, "------------------------------------------------------------------\n");
			SEGDEFPrint(pSegDef, pFile);
		}
	}
	fprintf(pFile, "******************************************************************\n");
	fprintf(pFile, "* Module Information\n");
	fprintf(pFile, "******************************************************************\n\n");
	for (i=0; i < pObj->numModules; i++)
	{
		ModulePrint(&pObj->module[i], pFile);
		fprintf(pFile, "\n");
	}
	fprintf(pFile, "\n");
	fclose(pFile);
}

/***************************************************************************/
/* Ende
/***************************************************************************/