/***************************************************************************/
/* omf51.c */
/***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include "omf51.h"
#include "omf51const.h"
#include <types.h>
#include <ihexparse.h>

/***************************************************************************/
/* Helper Functions
/***************************************************************************/
void MHDRInit(struct _sMHDR *pObj)
{
	pObj->chkSum = 0;
	pObj->reserved = 0;
	pObj->len = 0;
	pObj->name[0] = 0;
	pObj->nameLen = 0;
	pObj->trnID = 0;
}

void MENDInit(struct _sMEND *pObj)
{
	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->name[0] = 0;
	pObj->nameLen = 0;
	pObj->regMSK = 0;
	pObj->res16 = 0;
	pObj->res8 = 0;
}

void SEGDEFInit(struct _sSEGDEF *pObj)
{
	pObj->relTYP = 0;
	pObj->res8 = 0;
	pObj->segBASE = 0;
	pObj->segID = 0;
	pObj->segINFO = 0;
	pObj->segSIZE = 0;
	pObj->nameLen = 0;
	pObj->name[0] = 0;
}

void SEGInit(struct _sSEG *pObj)
{
	DBYTE i;

	pObj->segDef = (SEGDEF*)malloc(MAX_SEGDEF*sizeof(SEGDEF));
	for(i=0; i < MAX_SEGDEF; i++)
		SEGDEFInit(&pObj->segDef[i]);

	pObj->chkSum = 0;
	pObj->numSegDef = 0;
	pObj->len = 0;
}

void PUBDEFInit(struct _sPUBDEF *pObj)
{
	pObj->name[0] = 0;
	pObj->nameLen = 0;
	pObj->offset = 0;
	pObj->res8 = 0;
	pObj->segID = 0;
	pObj->symINFO = 0;
}

void PUBInit(struct _sPUB *pObj)
{
	DBYTE i;

	pObj->pubDef = (PUBDEF*)malloc(MAX_PUBDEF*sizeof(PUBDEF));
	for(i=0; i < MAX_PUBDEF; i++)
		PUBDEFInit(&pObj->pubDef[i]);

	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->numPubDef = 0;
}

void EXTDEFInit(struct _sEXTDEF *pObj)
{
	pObj->extID = 0;
	pObj->idBlk = 0;
	pObj->name[0] = 0;
	pObj->nameLen = 0;
	pObj->res8 = 0;
	pObj->symINFO = 0;
}

void EXTInit(struct _sEXT *pObj)
{
	DBYTE i;

	pObj->extDef = (EXTDEF*)malloc(MAX_EXTDEF*sizeof(EXTDEF));
	for(i=0; i < MAX_EXTDEF; i++)
		EXTDEFInit(&pObj->extDef[i]);

	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->numExtDef = 0;
}

void SCDInit(struct _sSCD *pObj)
{
	pObj->blkTYP = 0;
	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->name[0] = 0;
	pObj->nameLen = 0;
}

void DBGINFOInit(struct _sDBGINFO *pObj)
{
	pObj->lineNumber = 0;
	pObj->name[0] = 0;
	pObj->nameLen = 0;
	pObj->offset = 0;
	pObj->res8 = 0;
	pObj->segID = 0;
	pObj->segINFO = 0;
	pObj->symINFO = 0;

}

void DBGInit(struct _sDBG *pObj)
{
	DBYTE i;

	pObj->dbgInfo = (DBGINFO*)malloc(MAX_DBGINFO*sizeof(DBGINFO));
	for(i=0; i < MAX_DBGINFO; i++)
		DBGINFOInit(&pObj->dbgInfo[i]);

	pObj->chkSum = 0;
	pObj->defTYP = 0;
	pObj->len = 0;
	pObj->numDbgInfo = 0;

}

void CNTInit(struct _sCNT *pObj)
{
	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->offset = 0;
	pObj->pData = NULL;
	pObj->segID = 0;
	pObj->size = 0;
}

void FIXDEFInit(struct _sFIXDEF *pObj)
{
	pObj->refLoc = 0;
	pObj->refTYP = 0;
	pObj->operand.ID = 0;
	pObj->operand.IDBlk = 0;
	pObj->operand.offset = 0;
}

void FIXInit(struct _sFIX *pObj)
{
	DBYTE i;


	pObj->fixDef = (FIXDEF*)malloc(MAX_FIXDEF*sizeof(FIXDEF));
	for(i=0; i < MAX_FIXDEF; i++)
		FIXDEFInit(&pObj->fixDef[i]);

	pObj->chkSum = 0;
	pObj->len = 0;
	pObj->numFixDef = 0;
}

void ModuleInit(struct _sMODULE *pObj)
{
	DBYTE i;

	pObj->numCnt = 0;
	pObj->numDbg = 0;
	pObj->numFix = 0;
	pObj->pName = NULL;

	for (i=0; i < MAX_DBG; i++)
		pObj->ppDbg[i] = NULL;

	for (i=0; i < MAX_CNT; i++)
		pObj->ppCnt[i] = NULL;

	for (i=0; i < MAX_FIX; i++)
		pObj->ppFix[i] = NULL;
}

/***************************************************************************/
/* Exported Functions
/***************************************************************************/
void OmfInit(struct _sOBJECT *pObj)
{
	DBYTE i;

	pObj->mhdr = (MHDR*)malloc(MAX_MHDR*sizeof(MHDR));
	for (i=0; i < MAX_MHDR; i++)
		MHDRInit(&pObj->mhdr[i]);

	pObj->mend = (MEND*)malloc(MAX_MEND*sizeof(MEND));
	for (i=0; i < MAX_MEND; i++)
		MENDInit(&pObj->mend[i]);

	pObj->seg = (SEG*)malloc(MAX_SEG*sizeof(SEG));
	for (i=0; i < MAX_SEG; i++)
		SEGInit(&pObj->seg[i]);

	pObj->pub = (PUB*)malloc(MAX_PUB*sizeof(PUB));
	for (i=0; i < MAX_PUB; i++)
		PUBInit(&pObj->pub[i]);

	pObj->ext = (EXT*)malloc(MAX_EXT*sizeof(EXT));
	for (i=0; i < MAX_EXT; i++)
		EXTInit(&pObj->ext[i]);

	pObj->scd = (SCD*)malloc(MAX_SCD*sizeof(SCD));
	for (i=0; i < MAX_SCD; i++)
		SCDInit(&pObj->scd[i]);

	pObj->dbg = (DBG*)malloc(MAX_DBG*sizeof(DBG));
	for (i=0; i < MAX_DBG; i++)
		DBGInit(&pObj->dbg[i]);

	pObj->cnt = (CNT*)malloc(MAX_CNT*sizeof(CNT));
	for (i=0; i < MAX_CNT; i++)
		CNTInit(&pObj->cnt[i]);

	pObj->fix = (FIX*)malloc(MAX_FIX*sizeof(FIX));
	for (i=0; i < MAX_FIX; i++)
		FIXInit(&pObj->fix[i]);

	pObj->module = (MODULE*)malloc(MAX_MODULES*sizeof(MODULE));
	for (i=0; i < MAX_MODULES; i++)
		ModuleInit(&pObj->module[i]);

	pObj->numUnknown = 0;
	pObj->numMHDR = 0;
	pObj->numCNT = 0;
	pObj->numDBG = 0;
	pObj->numEXT = 0;
	pObj->numFIX = 0;
	pObj->numLDIC = 0;
	pObj->numLHDR = 0;
	pObj->numLML = 0;
	pObj->numLMN = 0;
	pObj->numMEND = 0;
	pObj->numPUB = 0;
	pObj->numSCD = 0;
	pObj->numSEG = 0;
	pObj->numModules = 0;
	pObj->numUnimplemented = 0;
	pObj->allocType = OBJECT_IS_ABS;
		
}

int OmfOpen(struct _sOBJECT *pObj, char *pName)
{
	strcpy((char*)pObj->fileName, (char*)pName);
	pObj->pFile = fopen(pName, "rb");
	if (pObj->pFile == NULL)
		return -1;
	return 0;
}

void OmfClose(struct _sOBJECT *pObj)
{
	fclose(pObj->pFile);
}

void OmfRead(struct _sOBJECT *pObj)
{
	BYTE recType, recChkSum, modFinished;
	DBYTE recCnt,recLen, i;
	MHDR *pMHDR;
	MEND *pMEND;
	SEG *pSEG;
	SEGDEF *pSEGDEF;
	PUB *pPUB;
	PUBDEF *pPUBDEF;
	EXT *pEXT;
	EXTDEF *pEXTDEF;
	SCD *pSCD, *pCpyScd;
	DBG *pDBG, *pCpyDbg;
	DBGINFO *pDBGINFO;
	CNT *pCNT, *pCpyCnt;
	FIX *pFIX, *pCpyFix;
	FIXDEF *pFIXDEF;
	MODULE *pMod;

	recCnt=0;
	modFinished=0;
	pCpyDbg = pObj->dbg;
	pCpyCnt = pObj->cnt;
	pCpyFix = pObj->fix;
	pCpyScd = pObj->scd;

	while(!feof(pObj->pFile))
	{
		if (fread(&recType, sizeof(BYTE), 1, pObj->pFile)==0)
			break;
		if (fread(&recLen, sizeof(DBYTE), 1, pObj->pFile)==0)
			break;

		pMod = &pObj->module[pObj->numModules];
		switch(recType)
		{
		case REC_TYPE_MHDR:			/* Module Header Record */
			pMHDR = &pObj->mhdr[pObj->numMHDR];
			pMHDR->len = recLen;
			fread(&pMHDR->nameLen, sizeof(BYTE), 1, pObj->pFile);
			fread(pMHDR->name, sizeof(BYTE), (size_t)pMHDR->nameLen, pObj->pFile);
			pMHDR->name[pMHDR->nameLen] = 0;
			fread(&pMHDR->trnID, sizeof(BYTE), 1, pObj->pFile);
			fread(&pMHDR->reserved, sizeof(BYTE), 1, pObj->pFile);
			fread(&pMHDR->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numMHDR++;
			break;

		case REC_TYPE_MEND:			/* Module End Record */
			pMEND = &pObj->mend[pObj->numMEND];
			pMEND->len = recLen;
			fread(&pMEND->nameLen, sizeof(BYTE), 1, pObj->pFile);
			fread(pMEND->name, sizeof(BYTE), (size_t)pMEND->nameLen, pObj->pFile);
			pMEND->name[pMEND->nameLen] = 0;
			fread(&pMEND->res16, sizeof(DBYTE), 1, pObj->pFile);
			fread(&pMEND->regMSK, sizeof(BYTE), 1, pObj->pFile);
			fread(&pMEND->res8, sizeof(BYTE), 1, pObj->pFile);
			fread(&pMEND->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numMEND++;

			/* Update Modules (Sorting) */
			pMod->pName = pCpyScd->name;
			for (i=0; i < pMod->numCnt; i++)
				pMod->ppCnt[i] = pCpyCnt++;

			for (i=0; i < pMod->numDbg; i++)
				pMod->ppDbg[i] = pCpyDbg++;

			for (i=0; i < pMod->numFix; i++)
				pMod->ppFix[i] = pCpyFix++;
			pObj->numModules++;
			modFinished = 0;
			break;

		case REC_TYPE_CNT:			/* Content Record */
			pCNT = &pObj->cnt[pObj->numCNT];
			pCNT->len = recLen;
			fread(&pCNT->segID, sizeof(BYTE), 1, pObj->pFile);
			fread(&pCNT->offset, sizeof(DBYTE), 1, pObj->pFile);
			if (pCNT->segID > 0)
			{
				pSEGDEF = &pObj->seg[0].segDef[pCNT->segID-1];
				pCNT->size = pSEGDEF->segSIZE;
			}
			pCNT->size = pCNT->len-4;

			pCNT->pData = (BYTE*)malloc(pCNT->size*sizeof(BYTE));
			fread(pCNT->pData, sizeof(BYTE), (size_t)pCNT->size, pObj->pFile);
			fread(&pCNT->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numCNT++;
			pMod->numCnt++;
			break;

		case REC_TYPE_FIX:			/* Fixup Record */
			pFIX = &pObj->fix[pObj->numFIX];
			pFIX->len = recLen;

			recLen -= 1;
			while (recLen)
			{
				pFIXDEF = &pFIX->fixDef[pFIX->numFixDef];
				fread(&pFIXDEF->refLoc, sizeof(DBYTE), 1, pObj->pFile);
				fread(&pFIXDEF->refTYP, sizeof(BYTE), 1, pObj->pFile);
				fread(&pFIXDEF->operand.IDBlk, sizeof(BYTE), 1, pObj->pFile);
				fread(&pFIXDEF->operand.ID, sizeof(BYTE), 1, pObj->pFile);
				fread(&pFIXDEF->operand.offset, sizeof(DBYTE), 1, pObj->pFile);
				recLen -= (DBYTE)7;
				pFIX->numFixDef++;
			}
			fread(&pFIX->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numFIX++;
			pMod->numFix++;
			break;

		case REC_TYPE_SEG:			/* Segment Definition Record */
			pSEG = &pObj->seg[pObj->numSEG];
			pSEG->len = recLen;

			recLen -= 1;
			while (recLen)
			{
				pSEGDEF = &pSEG->segDef[pSEG->numSegDef];
				fread(&pSEGDEF->segID, sizeof(BYTE), 1, pObj->pFile);
				fread(&pSEGDEF->segINFO, sizeof(BYTE), 1, pObj->pFile);
				fread(&pSEGDEF->relTYP, sizeof(BYTE), 1, pObj->pFile);
				fread(&pSEGDEF->res8, sizeof(BYTE), 1, pObj->pFile);
				fread(&pSEGDEF->segBASE, sizeof(DBYTE), 1, pObj->pFile);
				fread(&pSEGDEF->segSIZE, sizeof(DBYTE), 1, pObj->pFile);
				fread(&pSEGDEF->nameLen, sizeof(BYTE), 1, pObj->pFile);
				if (pSEGDEF->nameLen > 0)
					fread(&pSEGDEF->name, sizeof(BYTE), (size_t)pSEGDEF->nameLen, pObj->pFile);
				pSEGDEF->name[pSEGDEF->nameLen] = 0;
				recLen -= (DBYTE)(pSEGDEF->nameLen + 9);
				pSEG->numSegDef++;
			}
			fread(&pSEG->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numSEG++;
			pObj->allocType = OBJECT_IS_REL;
			break;

		case REC_TYPE_SCD:			/* Scope Definition Record */
			pSCD = &pObj->scd[pObj->numSCD];
			pSCD->len = recLen;

			fread(&pSCD->blkTYP, sizeof(BYTE), 1, pObj->pFile);
			fread(&pSCD->nameLen, sizeof(BYTE), 1, pObj->pFile);
			if (pSCD->nameLen > 0)
				fread(pSCD->name, sizeof(BYTE), pSCD->nameLen, pObj->pFile);

			pSCD->name[pSCD->nameLen] = 0;
			fread(&pSCD->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numSCD++;
			if (pSCD->blkTYP == SCD_BLKTYP_MOD_BLOCK)
			{
				if (modFinished == 1)
				{
					/* Update Modules (Sorting) */
					pMod->pName = pCpyScd->name;
					for (i=0; i < pMod->numCnt; i++)
						pMod->ppCnt[i] = pCpyCnt++;

					for (i=0; i < pMod->numDbg; i++)
						pMod->ppDbg[i] = pCpyDbg++;

					for (i=0; i < pMod->numFix; i++)
						pMod->ppFix[i] = pCpyFix++;
					pObj->numModules++;
					modFinished = 0;
					pCpyScd++;
					pCpyScd++;
				}
			}
			else
			{
				if(pSCD->blkTYP == SCD_BLKTYP_MOD_END)
				{
					modFinished = 1;
				}
			}
			break;

		case REC_TYPE_DBG:			/* Debug Item Record */
			pDBG = &pObj->dbg[pObj->numDBG];
			pDBG->len = recLen;
			fread(&pDBG->defTYP, sizeof(BYTE), 1, pObj->pFile);

			recLen -= 2;
			switch(pDBG->defTYP)
			{
			case DBG_DEFTYP_LOCAL:
			case DBG_DEFTYP_PUBLIC:
				while (recLen)
				{
					pDBGINFO = &pDBG->dbgInfo[pDBG->numDbgInfo];
					fread(&pDBGINFO->segID, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->symINFO, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->offset, sizeof(DBYTE), 1, pObj->pFile);
					fread(&pDBGINFO->res8, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->nameLen, sizeof(BYTE), 1, pObj->pFile);
					if (pDBGINFO->nameLen > 0)
						fread(&pDBGINFO->name, sizeof(BYTE), (size_t)pDBGINFO->nameLen, pObj->pFile);
					pDBGINFO->name[pDBGINFO->nameLen] = 0;
					recLen -= (DBYTE)(pDBGINFO->nameLen + 6);
					pDBG->numDbgInfo++;
				}
				break;
			case DBG_DEFTYP_SEGMENT:
				while (recLen)
				{
					pDBGINFO = &pDBG->dbgInfo[pDBG->numDbgInfo];
					fread(&pDBGINFO->segID, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->segINFO, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->offset, sizeof(DBYTE), 1, pObj->pFile);
					fread(&pDBGINFO->res8, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->nameLen, sizeof(BYTE), 1, pObj->pFile);
					if (pDBGINFO->nameLen > 0)
						fread(&pDBGINFO->name, sizeof(BYTE), (size_t)pDBGINFO->nameLen, pObj->pFile);
					pDBGINFO->name[pDBGINFO->nameLen] = 0;
					recLen -= (DBYTE)(pDBGINFO->nameLen + 6);
					pDBG->numDbgInfo++;
				}
				break;
			case DBG_DEFTYP_LINE:
				while (recLen)
				{
					pDBGINFO = &pDBG->dbgInfo[pDBG->numDbgInfo];
					fread(&pDBGINFO->segID, sizeof(BYTE), 1, pObj->pFile);
					fread(&pDBGINFO->offset, sizeof(DBYTE), 1, pObj->pFile);
					fread(&pDBGINFO->lineNumber, sizeof(DBYTE), 1, pObj->pFile);
					recLen -= (DBYTE)5;
					pDBG->numDbgInfo++;
				}
				break;
			}
			fread(&pDBG->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numDBG++;
			pMod->numDbg++;
			break;

		case REC_TYPE_PUB:			/* Public Definition Record */
			pPUB = &pObj->pub[pObj->numPUB];
			pPUB->len = recLen;

			recLen -= 1;
			while (recLen)
			{
				pPUBDEF = &pPUB->pubDef[pPUB->numPubDef];
				fread(&pPUBDEF->segID, sizeof(BYTE), 1, pObj->pFile);
				fread(&pPUBDEF->symINFO, sizeof(BYTE), 1, pObj->pFile);
				fread(&pPUBDEF->offset, sizeof(DBYTE), 1, pObj->pFile);
				fread(&pPUBDEF->res8, sizeof(BYTE), 1, pObj->pFile);
				fread(&pPUBDEF->nameLen, sizeof(BYTE), 1, pObj->pFile);
				if (pPUBDEF->nameLen > 0)
					fread(&pPUBDEF->name, sizeof(BYTE), (size_t)pPUBDEF->nameLen, pObj->pFile);
				pPUBDEF->name[pPUBDEF->nameLen] = 0;
				recLen -= (DBYTE)(pPUBDEF->nameLen + 6);
				pPUB->numPubDef++;
			}
			fread(&pPUB->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numPUB++;
			break;

		case REC_TYPE_EXT:			/* External Definition Record */
			pEXT = &pObj->ext[pObj->numEXT];
			pEXT->len = recLen;

			recLen -= 1;
			while (recLen)
			{
				pEXTDEF = &pEXT->extDef[pEXT->numExtDef];
				fread(&pEXTDEF->idBlk, sizeof(BYTE), 1, pObj->pFile);
				fread(&pEXTDEF->extID, sizeof(BYTE), 1, pObj->pFile);
				fread(&pEXTDEF->symINFO, sizeof(BYTE), 1, pObj->pFile);
				fread(&pEXTDEF->res8, sizeof(BYTE), 1, pObj->pFile);
				fread(&pEXTDEF->nameLen, sizeof(BYTE), 1, pObj->pFile);
				if (pEXTDEF->nameLen > 0)
					fread(&pEXTDEF->name, sizeof(BYTE), (size_t)pEXTDEF->nameLen, pObj->pFile);
				pEXTDEF->name[pEXTDEF->nameLen] = 0;
				recLen -= (DBYTE)(pEXTDEF->nameLen + 5);
				pEXT->numExtDef++;
			}
			fread(&pEXT->chkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numEXT++;
			break;

		case REC_TYPE_LML:			/* LIB ModLocs Record */
			fseek(pObj->pFile, (long)recLen-1, SEEK_CUR);
			fread(&recChkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numLML++;
			pObj->numUnimplemented++;
			break;

		case REC_TYPE_LMN:			/* LIB ModName Record */
			fseek(pObj->pFile, (long)recLen-1, SEEK_CUR);
			fread(&recChkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numLMN++;
			pObj->numUnimplemented++;
			break;

		case REC_TYPE_LDIC:			/* LIB DICTNRY Record */
			fseek(pObj->pFile, (long)recLen-1, SEEK_CUR);
			fread(&recChkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numLDIC++;
			pObj->numUnimplemented++;
			break;

		case REC_TYPE_LHDR:			/* LIB Header Record */
			fseek(pObj->pFile, (long)recLen-1, SEEK_CUR);
			fread(&recChkSum, sizeof(BYTE), 1, pObj->pFile);
			pObj->numLHDR++;
			pObj->numUnimplemented++;
			break;

		default:
			fseek(pObj->pFile, (long)recLen, SEEK_CUR);
			pObj->numUnknown++;
			break;
		}
	recCnt++;
	}
}

void Omf2Hex(struct _sOBJECT *pObj)
{
	char name[255];

	DBYTE i, size, len;
	BYTE *pData;
	CNT *pCnt;
	HEXREC hex;
	sprintf(name, "%s.hex",pObj->mhdr[0].name);
	HexCreate(&hex, name);

	for (i=0; i < pObj->numCNT; i++)
	{
		pCnt = &pObj->cnt[i];
		pData = pCnt->pData;
		size = pCnt->size;
		
		hex.dataStart = pCnt->offset;
		while(size)
		{
			len = size;

			if (len > HEXREC_MAXLEN)
				len = HEXREC_MAXLEN;

			memcpy(hex.recData, pData, len);
			hex.length = (BYTE)len;
			hex.type = 0;
			HexWriteRecord(&hex);
			hex.dataStart += len;
			pData += len;
			size -= len;
		}

	}
	HexClose(&hex);
}
/***************************************************************************/
/* Ende
/***************************************************************************/