commit 3297d1bb7e084fb16156a396cb0df4dd4bdc861d
Author: Jens Ahrensfeld <jens@jayfield.org>
Date:   Sat Jul 19 07:44:42 2014 +0000

    Initial import
    
    git-svn-id: http://moon:8086/svn/software/trunk/libsrc/omf51@1 b431acfa-c32f-4a4a-93f1-934dc6c82436

diff --git a/Debug/omf51.lib b/Debug/omf51.lib
new file mode 100755
index 0000000..a6b5cb3
Binary files /dev/null and b/Debug/omf51.lib differ
diff --git a/Debug/omf51.obj b/Debug/omf51.obj
new file mode 100755
index 0000000..27801ed
Binary files /dev/null and b/Debug/omf51.obj differ
diff --git a/Debug/omf51.pch b/Debug/omf51.pch
new file mode 100755
index 0000000..037e7d0
Binary files /dev/null and b/Debug/omf51.pch differ
diff --git a/Debug/omf51const.obj b/Debug/omf51const.obj
new file mode 100755
index 0000000..45efbc9
Binary files /dev/null and b/Debug/omf51const.obj differ
diff --git a/Debug/omf51print.obj b/Debug/omf51print.obj
new file mode 100755
index 0000000..f0d48e8
Binary files /dev/null and b/Debug/omf51print.obj differ
diff --git a/Debug/vc60.idb b/Debug/vc60.idb
new file mode 100755
index 0000000..57a28b0
Binary files /dev/null and b/Debug/vc60.idb differ
diff --git a/Debug/vc60.pdb b/Debug/vc60.pdb
new file mode 100755
index 0000000..a29ca2b
Binary files /dev/null and b/Debug/vc60.pdb differ
diff --git a/Release/omf51.obj b/Release/omf51.obj
new file mode 100755
index 0000000..b03085c
Binary files /dev/null and b/Release/omf51.obj differ
diff --git a/Release/omf51.pch b/Release/omf51.pch
new file mode 100755
index 0000000..d97d239
Binary files /dev/null and b/Release/omf51.pch differ
diff --git a/Release/omf51const.obj b/Release/omf51const.obj
new file mode 100755
index 0000000..85f5af1
Binary files /dev/null and b/Release/omf51const.obj differ
diff --git a/Release/omf51print.obj b/Release/omf51print.obj
new file mode 100755
index 0000000..4ab5b46
Binary files /dev/null and b/Release/omf51print.obj differ
diff --git a/Release/vc60.idb b/Release/vc60.idb
new file mode 100755
index 0000000..e7e2be4
Binary files /dev/null and b/Release/vc60.idb differ
diff --git a/omf51.c b/omf51.c
new file mode 100755
index 0000000..a95a1a0
--- /dev/null
+++ b/omf51.c
@@ -0,0 +1,640 @@
+/***************************************************************************/
+/* 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
+/***************************************************************************/
diff --git a/omf51.dsp b/omf51.dsp
new file mode 100755
index 0000000..c54f11e
--- /dev/null
+++ b/omf51.dsp
@@ -0,0 +1,112 @@
+# Microsoft Developer Studio Project File - Name="omf51" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** NICHT BEARBEITEN **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=omf51 - Win32 Debug
+!MESSAGE Dies ist kein gültiges Makefile. Zum Erstellen dieses Projekts mit NMAKE
+!MESSAGE verwenden Sie den Befehl "Makefile exportieren" und führen Sie den Befehl
+!MESSAGE 
+!MESSAGE NMAKE /f "omf51.mak".
+!MESSAGE 
+!MESSAGE Sie können beim Ausführen von NMAKE eine Konfiguration angeben
+!MESSAGE durch Definieren des Makros CFG in der Befehlszeile. Zum Beispiel:
+!MESSAGE 
+!MESSAGE NMAKE /f "omf51.mak" CFG="omf51 - Win32 Debug"
+!MESSAGE 
+!MESSAGE Für die Konfiguration stehen zur Auswahl:
+!MESSAGE 
+!MESSAGE "omf51 - Win32 Release" (basierend auf  "Win32 (x86) Static Library")
+!MESSAGE "omf51 - Win32 Debug" (basierend auf  "Win32 (x86) Static Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "omf51 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x407 /d "NDEBUG"
+# ADD RSC /l 0x407 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"../../lib/Release\omf51.lib"
+
+!ELSEIF  "$(CFG)" == "omf51 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ  /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ  /c
+# ADD BASE RSC /l 0x407 /d "_DEBUG"
+# ADD RSC /l 0x407 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"../../lib/Debug\omf51.lib"
+
+!ENDIF 
+
+# Begin Target
+
+# Name "omf51 - Win32 Release"
+# Name "omf51 - Win32 Debug"
+# Begin Group "Quellcodedateien"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\omf51.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\omf51const.c
+# End Source File
+# Begin Source File
+
+SOURCE=.\omf51print.c
+# End Source File
+# End Group
+# Begin Group "Header-Dateien"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\omf51const.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\omf51print.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/omf51.dsw b/omf51.dsw
new file mode 100755
index 0000000..08277fe
--- /dev/null
+++ b/omf51.dsw
@@ -0,0 +1,29 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNUNG: DIESE ARBEITSBEREICHSDATEI DARF NICHT BEARBEITET ODER GELÖSCHT WERDEN!
+
+###############################################################################
+
+Project: "omf51"=.\omf51.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/omf51.h b/omf51.h
new file mode 100755
index 0000000..db5e109
--- /dev/null
+++ b/omf51.h
@@ -0,0 +1,217 @@
+/***************************************************************************/
+/* omf51.h */
+/***************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+
+/***************************************************************************/
+#ifndef OMF51_H
+#define OMF51_H
+
+#define	BYTE	unsigned char
+#define DBYTE	unsigned short
+
+#define REC_TYPE_MHDR	0x02	/* Module Header Record */
+#define REC_TYPE_MEND	0x04	/* Module End Record */
+#define REC_TYPE_CNT	0x06	/* Content Record */
+#define REC_TYPE_FIX	0x08	/* Fixup Record */
+#define REC_TYPE_SEG	0x0E	/* Segment Definition Record */
+#define REC_TYPE_SCD	0x10	/* Scope Definition Record */
+#define REC_TYPE_DBG	0x12	/* Debug Item Record */
+#define REC_TYPE_PUB	0x16	/* Public Definition Record */
+#define REC_TYPE_EXT	0x18	/* External Definition Record */
+#define REC_TYPE_LML	0x26	/* LIB ModLocs Record */
+#define REC_TYPE_LMN	0x28	/* LIB ModName Record */
+#define REC_TYPE_LDIC	0x2A	/* LIB DICTNRY Record */
+#define REC_TYPE_LHDR	0x2C	/* LIB Header Record */
+
+#define MAX_MHDR			8
+#define MAX_MEND			8
+#define MAX_SEG				255
+#define MAX_SEGDEF			255
+#define MAX_PUB				255
+#define MAX_PUBDEF			255
+#define MAX_EXT				255
+#define MAX_EXTDEF			255
+#define	MAX_SCD				255
+#define MAX_DBG				255
+#define MAX_DBGINFO			255
+#define MAX_CNT				255
+#define MAX_FIX				255
+#define MAX_FIXDEF			255
+
+#define	MAX_MODULES			255
+
+#define DBG_DEFTYP_LOCAL	0x00
+#define DBG_DEFTYP_PUBLIC	0x01
+#define DBG_DEFTYP_SEGMENT	0x02
+#define DBG_DEFTYP_LINE		0x03
+
+#define SCD_BLKTYP_MOD_BLOCK	0x00
+#define SCD_BLKTYP_DO_BLOCK		0x01
+#define SCD_BLKTYP_PROC_BLOCK	0x02
+#define SCD_BLKTYP_MOD_END		0x03
+#define SCD_BLKTYP_DO_END		0x04
+#define SCD_BLKTYP_PROC_END		0x05
+
+#define	OBJECT_IS_REL			0
+#define	OBJECT_IS_ABS			1
+
+/***************************************************************************/
+/* Module Header Record */
+typedef struct _sMHDR
+{
+	char name[41];
+	BYTE trnID, nameLen, reserved, chkSum;
+	DBYTE len;
+
+} MHDR; 
+
+/* Module End Record */
+typedef struct _sMEND
+{
+	char name[41];
+	BYTE regMSK, nameLen, res8, chkSum;
+	DBYTE len, res16;
+} MEND; 
+
+typedef struct _sSEGDEF
+{
+	BYTE name[41], nameLen, segID, segINFO, relTYP, res8;
+	DBYTE segBASE, segSIZE;
+} SEGDEF;
+
+/* Segment Definition Record */
+typedef struct _sSEG
+{
+	BYTE chkSum;
+	DBYTE numSegDef, len;
+//	SEGDEF segDef[MAX_SEGDEF];
+	SEGDEF *segDef;
+} SEG;
+
+typedef struct _sPUBDEF
+{
+	BYTE name[41], nameLen, segID, symINFO, res8;
+	DBYTE offset;
+
+} PUBDEF;
+typedef struct _sPUB
+{
+	BYTE chkSum;
+	DBYTE numPubDef, len;
+//	PUBDEF pubDef[MAX_PUBDEF];
+	PUBDEF *pubDef;
+
+} PUB;
+
+typedef struct _sEXTDEF
+{
+	BYTE name[41], nameLen, idBlk, extID, symINFO, res8;
+
+} EXTDEF;
+
+typedef struct _sEXT
+{
+	BYTE chkSum;
+	DBYTE numExtDef, len;
+//	EXTDEF extDef[MAX_EXTDEF];
+	EXTDEF *extDef;
+
+} EXT;
+
+typedef struct _sSCD
+{
+	char name[41];
+	BYTE blkTYP, chkSum, nameLen;
+	DBYTE len;
+
+} SCD; 
+
+typedef struct _sDBGINFO
+{
+	BYTE name[41], nameLen, segID, segINFO, symINFO, res8;
+	DBYTE offset, lineNumber;
+
+} DBGINFO;
+
+typedef struct _sDBG
+{
+	BYTE chkSum, defTYP;
+	DBYTE numDbgInfo, len;
+//	DBGINFO dbgInfo[MAX_DBGINFO];
+	DBGINFO *dbgInfo;
+
+} DBG;
+
+typedef struct _sCNT
+{
+	BYTE chkSum, segID, *pData;
+	DBYTE len, offset, size;
+
+} CNT;
+
+typedef struct _sOP
+{
+	BYTE IDBlk, ID;
+	DBYTE offset;
+} OP;
+
+typedef struct _sFIXDEF
+{
+	BYTE refTYP;
+	DBYTE refLoc;
+	OP operand;
+
+} FIXDEF;
+
+typedef struct _sFIX
+{
+	BYTE chkSum;
+	DBYTE len, numFixDef;
+//	FIXDEF fixDef[MAX_FIXDEF];
+	FIXDEF *fixDef;
+} FIX;
+
+typedef struct _sMODULE
+{
+	char *pName;
+	DBYTE numDbg, numCnt, numFix;
+	DBG *ppDbg[MAX_DBG];
+	CNT *ppCnt[MAX_CNT];
+	FIX *ppFix[MAX_FIX];
+
+} MODULE;
+
+typedef struct _sOBJECT
+{
+	char *fileName[1024];
+	DBYTE numUnknown, numMHDR, numMEND, numCNT, numFIX, numSEG, numSCD;
+	DBYTE numDBG, numPUB, numEXT, numLML, numLMN, numLDIC, numLHDR;
+	DBYTE numModules;
+	FILE *pFile;
+	MHDR *mhdr;
+	MEND *mend;
+	SEG  *seg;
+	PUB  *pub;
+	EXT  *ext;
+	SCD	 *scd;
+	DBG  *dbg;
+	CNT  *cnt;
+	FIX  *fix;
+	DBYTE numUnimplemented;
+	MODULE *module;
+	BYTE allocType;
+
+} OBJECT;
+
+/***************************************************************************/
+void OmfInit(struct _sOBJECT *pObj);
+int OmfOpen(struct _sOBJECT *pObj, char *pName);
+void OmfClose(struct _sOBJECT *pObj);
+void OmfRead(struct _sOBJECT *pObj);
+void OmfPrint(struct _sOBJECT *pObj);
+void Omf2Hex(struct _sOBJECT *pObj);
+
+/***************************************************************************/
+#endif /* OMF51_H */
\ No newline at end of file
diff --git a/omf51.ncb b/omf51.ncb
new file mode 100755
index 0000000..808ea9b
Binary files /dev/null and b/omf51.ncb differ
diff --git a/omf51.opt b/omf51.opt
new file mode 100755
index 0000000..3b7610d
Binary files /dev/null and b/omf51.opt differ
diff --git a/omf51.plg b/omf51.plg
new file mode 100755
index 0000000..2f0c1b9
--- /dev/null
+++ b/omf51.plg
@@ -0,0 +1,31 @@
+<html>
+<body>
+<pre>
+<h1>Erstellungsprotokoll</h1>
+<h3>
+--------------------Konfiguration: omf51 - Win32 Release--------------------
+</h3>
+<h3>Befehlszeilen</h3>
+Erstellen der temporären Datei  "D:\WIN98\TEMP\RSPE2E0.TMP" mit Inhalten
+[
+/nologo /ML /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /Fp"Release/omf51.pch" /YX /Fo"Release/" /Fd"Release/" /FD /c 
+"E:\home\Develop\80x86\libsrc\omf51\omf51const.c"
+"E:\home\Develop\80x86\libsrc\omf51\omf51.c"
+"E:\home\Develop\80x86\libsrc\omf51\omf51print.c"
+]
+Creating command line "cl.exe @D:\WIN98\TEMP\RSPE2E0.TMP" 
+Erstellen der Befehlzeile "link.exe -lib /nologo /out:"../../lib/Release\omf51.lib"  .\Release\omf51const.obj .\Release\omf51.obj .\Release\omf51print.obj "
+<h3>Ausgabefenster</h3>
+Kompilierung läuft...
+omf51const.c
+omf51.c
+omf51print.c
+Bibliothek wird erstellt...
+
+
+
+<h3>Ergebnisse</h3>
+omf51.lib - 0 Fehler, 0 Warnung(en)
+</pre>
+</body>
+</html>
diff --git a/omf51const.c b/omf51const.c
new file mode 100755
index 0000000..301cf46
--- /dev/null
+++ b/omf51const.c
@@ -0,0 +1,1074 @@
+/***************************************************************************/
+/* omf51const.c */
+/***************************************************************************/
+
+/***************************************************************************/
+/* Constants
+/***************************************************************************/
+const char *recTypeTitle[256] =
+{
+	"RecType_00",
+	"Module Header",
+	"RecType_02",
+	"RecType_03",
+	"Module End",
+	"RecType_05",
+	"Content",
+	"RecType_07",
+	"Fixup",
+	"RecType_09",
+	"RecType_0A",
+	"RecType_0B",
+	"RecType_0C",
+	"RecType_0D",
+	"RecType_0E",
+	"RecType_0F",
+	"Scope Definition",
+	"RecType_11",
+	"Debug Item",
+	"RecType_13",
+	"RecType_14",
+	"RecType_15",
+	"Public Definition",
+	"RecType_17",
+	"External Definition",
+	"RecType_19",
+	"RecType_1A",
+	"RecType_1B",
+	"RecType_1C",
+	"RecType_1D",
+	"RecType_1E",
+	"RecType_1F",
+	"RecType_20",
+	"RecType_21",
+	"RecType_22",
+	"RecType_23",
+	"RecType_24",
+	"RecType_25",
+	"LIB ModLocs",
+	"RecType_27",
+	"LIB ModName",
+	"RecType_29",
+	"LIB DICTNRY",
+	"RecType_2B",
+	"LIB Header",
+	"RecType_2D",
+	"RecType_2E",
+	"RecType_2F",
+	"RecType_30",
+	"RecType_31",
+	"RecType_32",
+	"RecType_33",
+	"RecType_34",
+	"RecType_35",
+	"RecType_36",
+	"RecType_37",
+	"RecType_38",
+	"RecType_39",
+	"RecType_3A",
+	"RecType_3B",
+	"RecType_3C",
+	"RecType_3D",
+	"RecType_3E",
+	"RecType_3F",
+	"RecType_40",
+	"RecType_41",
+	"RecType_42",
+	"RecType_43",
+	"RecType_44",
+	"RecType_45",
+	"RecType_46",
+	"RecType_47",
+	"RecType_48",
+	"RecType_49",
+	"RecType_4A",
+	"RecType_4B",
+	"RecType_4C",
+	"RecType_4D",
+	"RecType_4E",
+	"RecType_4F",
+	"RecType_50",
+	"RecType_51",
+	"RecType_52",
+	"RecType_53",
+	"RecType_54",
+	"RecType_55",
+	"RecType_56",
+	"RecType_57",
+	"RecType_58",
+	"RecType_59",
+	"RecType_5A",
+	"RecType_5B",
+	"RecType_5C",
+	"RecType_5D",
+	"RecType_5E",
+	"RecType_5F",
+	"RecType_60",
+	"RecType_61",
+	"RecType_62",
+	"RecType_63",
+	"RecType_64",
+	"RecType_65",
+	"RecType_66",
+	"RecType_67",
+	"RecType_68",
+	"RecType_69",
+	"RecType_6A",
+	"RecType_6B",
+	"RecType_6C",
+	"RecType_6D",
+	"RecType_6E",
+	"RecType_6F",
+	"RecType_70",
+	"RecType_71",
+	"RecType_72",
+	"RecType_73",
+	"RecType_74",
+	"RecType_75",
+	"RecType_76",
+	"RecType_77",
+	"RecType_78",
+	"RecType_79",
+	"RecType_7A",
+	"RecType_7B",
+	"RecType_7C",
+	"RecType_7D",
+	"RecType_7E",
+	"RecType_7F",
+	"RecType_80",
+	"RecType_81",
+	"RecType_82",
+	"RecType_83",
+	"RecType_84",
+	"RecType_85",
+	"RecType_86",
+	"RecType_87",
+	"RecType_88",
+	"RecType_89",
+	"RecType_8A",
+	"RecType_8B",
+	"RecType_8C",
+	"RecType_8D",
+	"RecType_8E",
+	"RecType_8F",
+	"RecType_90",
+	"RecType_91",
+	"RecType_92",
+	"RecType_93",
+	"RecType_94",
+	"RecType_95",
+	"RecType_96",
+	"RecType_97",
+	"RecType_98",
+	"RecType_99",
+	"RecType_9A",
+	"RecType_9B",
+	"RecType_9C",
+	"RecType_9D",
+	"RecType_9E",
+	"RecType_9F",
+	"RecType_A0",
+	"RecType_A1",
+	"RecType_A2",
+	"RecType_A3",
+	"RecType_A4",
+	"RecType_A5",
+	"RecType_A6",
+	"RecType_A7",
+	"RecType_A8",
+	"RecType_A9",
+	"RecType_AA",
+	"RecType_AB",
+	"RecType_AC",
+	"RecType_AD",
+	"RecType_AE",
+	"RecType_AF",
+	"RecType_B0",
+	"RecType_B1",
+	"RecType_B2",
+	"RecType_B3",
+	"RecType_B4",
+	"RecType_B5",
+	"RecType_B6",
+	"RecType_B7",
+	"RecType_B8",
+	"RecType_B9",
+	"RecType_BA",
+	"RecType_BB",
+	"RecType_BC",
+	"RecType_BD",
+	"RecType_BE",
+	"RecType_BF",
+	"RecType_C0",
+	"RecType_C1",
+	"RecType_C2",
+	"RecType_C3",
+	"RecType_C4",
+	"RecType_C5",
+	"RecType_C6",
+	"RecType_C7",
+	"RecType_C8",
+	"RecType_C9",
+	"RecType_CA",
+	"RecType_CB",
+	"RecType_CC",
+	"RecType_CD",
+	"RecType_CE",
+	"RecType_CF",
+	"RecType_D0",
+	"RecType_D1",
+	"RecType_D2",
+	"RecType_D3",
+	"RecType_D4",
+	"RecType_D5",
+	"RecType_D6",
+	"RecType_D7",
+	"RecType_D8",
+	"RecType_D9",
+	"RecType_DA",
+	"RecType_DB",
+	"RecType_DC",
+	"RecType_DD",
+	"RecType_DE",
+	"RecType_DF",
+	"RecType_E0",
+	"RecType_E1",
+	"RecType_E2",
+	"RecType_E3",
+	"RecType_E4",
+	"RecType_E5",
+	"RecType_E6",
+	"RecType_E7",
+	"RecType_E8",
+	"RecType_E9",
+	"RecType_EA",
+	"RecType_EB",
+	"RecType_EC",
+	"RecType_ED",
+	"RecType_EE",
+	"RecType_EF",
+	"RecType_F0",
+	"RecType_F1",
+	"RecType_F2",
+	"RecType_F3",
+	"RecType_F4",
+	"RecType_F5",
+	"RecType_F6",
+	"RecType_F7",
+	"RecType_F8",
+	"RecType_F9",
+	"RecType_FA",
+	"RecType_FB",
+	"RecType_FC",
+	"RecType_FD",
+	"RecType_FE",
+	"RecType_FF"
+};
+
+const char *segTypeName[8] = 
+{
+	"CODE",
+	"XDATA",
+	"DATA",
+	"IDATA",
+	"BIT",
+	"SEGTYPE_5",
+	"SEGTYPE_6",
+	"SEGTYPE_7"
+};
+
+const char *symTypeName[8] = 
+{
+	"CODE",
+	"XDATA",
+	"DATA",
+	"IDATA",
+	"BIT",
+	"NUMBER",
+	"SYMTYPE_6",
+	"SYMTYPE_7"
+};
+
+const char *relTypeName[256] =
+{
+	"ABS",
+	"UNIT",
+	"BITADDRESSABLE",
+	"INPAGE",
+	"INBLOCK",
+	"PAGE",
+	"RELTYPE_06",
+	"RELTYPE_07",
+	"RELTYPE_08",
+	"RELTYPE_09",
+	"RELTYPE_0A",
+	"RELTYPE_0B",
+	"RELTYPE_0C",
+	"RELTYPE_0D",
+	"RELTYPE_0E",
+	"RELTYPE_0F",
+	"RELTYPE_10",
+	"RELTYPE_11",
+	"RELTYPE_12",
+	"RELTYPE_13",
+	"RELTYPE_14",
+	"RELTYPE_15",
+	"RELTYPE_16",
+	"RELTYPE_17",
+	"RELTYPE_18",
+	"RELTYPE_19",
+	"RELTYPE_1A",
+	"RELTYPE_1B",
+	"RELTYPE_1C",
+	"RELTYPE_1D",
+	"RELTYPE_1E",
+	"RELTYPE_1F",
+	"RELTYPE_20",
+	"RELTYPE_21",
+	"RELTYPE_22",
+	"RELTYPE_23",
+	"RELTYPE_24",
+	"RELTYPE_25",
+	"RELTYPE_26",
+	"RELTYPE_27",
+	"RELTYPE_28",
+	"RELTYPE_29",
+	"RELTYPE_2A",
+	"RELTYPE_2B",
+	"RELTYPE_2C",
+	"RELTYPE_2D",
+	"RELTYPE_2E",
+	"RELTYPE_2F",
+	"RELTYPE_30",
+	"RELTYPE_31",
+	"RELTYPE_32",
+	"RELTYPE_33",
+	"RELTYPE_34",
+	"RELTYPE_35",
+	"RELTYPE_36",
+	"RELTYPE_37",
+	"RELTYPE_38",
+	"RELTYPE_39",
+	"RELTYPE_3A",
+	"RELTYPE_3B",
+	"RELTYPE_3C",
+	"RELTYPE_3D",
+	"RELTYPE_3E",
+	"RELTYPE_3F",
+	"RELTYPE_40",
+	"RELTYPE_41",
+	"RELTYPE_42",
+	"RELTYPE_43",
+	"RELTYPE_44",
+	"RELTYPE_45",
+	"RELTYPE_46",
+	"RELTYPE_47",
+	"RELTYPE_48",
+	"RELTYPE_49",
+	"RELTYPE_4A",
+	"RELTYPE_4B",
+	"RELTYPE_4C",
+	"RELTYPE_4D",
+	"RELTYPE_4E",
+	"RELTYPE_4F",
+	"RELTYPE_50",
+	"RELTYPE_51",
+	"RELTYPE_52",
+	"RELTYPE_53",
+	"RELTYPE_54",
+	"RELTYPE_55",
+	"RELTYPE_56",
+	"RELTYPE_57",
+	"RELTYPE_58",
+	"RELTYPE_59",
+	"RELTYPE_5A",
+	"RELTYPE_5B",
+	"RELTYPE_5C",
+	"RELTYPE_5D",
+	"RELTYPE_5E",
+	"RELTYPE_5F",
+	"RELTYPE_60",
+	"RELTYPE_61",
+	"RELTYPE_62",
+	"RELTYPE_63",
+	"RELTYPE_64",
+	"RELTYPE_65",
+	"RELTYPE_66",
+	"RELTYPE_67",
+	"RELTYPE_68",
+	"RELTYPE_69",
+	"RELTYPE_6A",
+	"RELTYPE_6B",
+	"RELTYPE_6C",
+	"RELTYPE_6D",
+	"RELTYPE_6E",
+	"RELTYPE_6F",
+	"RELTYPE_70",
+	"RELTYPE_71",
+	"RELTYPE_72",
+	"RELTYPE_73",
+	"RELTYPE_74",
+	"RELTYPE_75",
+	"RELTYPE_76",
+	"RELTYPE_77",
+	"RELTYPE_78",
+	"RELTYPE_79",
+	"RELTYPE_7A",
+	"RELTYPE_7B",
+	"RELTYPE_7C",
+	"RELTYPE_7D",
+	"RELTYPE_7E",
+	"RELTYPE_7F",
+	"RELTYPE_80",
+	"RELTYPE_81",
+	"RELTYPE_82",
+	"RELTYPE_83",
+	"RELTYPE_84",
+	"RELTYPE_85",
+	"RELTYPE_86",
+	"RELTYPE_87",
+	"RELTYPE_88",
+	"RELTYPE_89",
+	"RELTYPE_8A",
+	"RELTYPE_8B",
+	"RELTYPE_8C",
+	"RELTYPE_8D",
+	"RELTYPE_8E",
+	"RELTYPE_8F",
+	"RELTYPE_90",
+	"RELTYPE_91",
+	"RELTYPE_92",
+	"RELTYPE_93",
+	"RELTYPE_94",
+	"RELTYPE_95",
+	"RELTYPE_96",
+	"RELTYPE_97",
+	"RELTYPE_98",
+	"RELTYPE_99",
+	"RELTYPE_9A",
+	"RELTYPE_9B",
+	"RELTYPE_9C",
+	"RELTYPE_9D",
+	"RELTYPE_9E",
+	"RELTYPE_9F",
+	"RELTYPE_A0",
+	"RELTYPE_A1",
+	"RELTYPE_A2",
+	"RELTYPE_A3",
+	"RELTYPE_A4",
+	"RELTYPE_A5",
+	"RELTYPE_A6",
+	"RELTYPE_A7",
+	"RELTYPE_A8",
+	"RELTYPE_A9",
+	"RELTYPE_AA",
+	"RELTYPE_AB",
+	"RELTYPE_AC",
+	"RELTYPE_AD",
+	"RELTYPE_AE",
+	"RELTYPE_AF",
+	"RELTYPE_B0",
+	"RELTYPE_B1",
+	"RELTYPE_B2",
+	"RELTYPE_B3",
+	"RELTYPE_B4",
+	"RELTYPE_B5",
+	"RELTYPE_B6",
+	"RELTYPE_B7",
+	"RELTYPE_B8",
+	"RELTYPE_B9",
+	"RELTYPE_BA",
+	"RELTYPE_BB",
+	"RELTYPE_BC",
+	"RELTYPE_BD",
+	"RELTYPE_BE",
+	"RELTYPE_BF",
+	"RELTYPE_C0",
+	"RELTYPE_C1",
+	"RELTYPE_C2",
+	"RELTYPE_C3",
+	"RELTYPE_C4",
+	"RELTYPE_C5",
+	"RELTYPE_C6",
+	"RELTYPE_C7",
+	"RELTYPE_C8",
+	"RELTYPE_C9",
+	"RELTYPE_CA",
+	"RELTYPE_CB",
+	"RELTYPE_CC",
+	"RELTYPE_CD",
+	"RELTYPE_CE",
+	"RELTYPE_CF",
+	"RELTYPE_D0",
+	"RELTYPE_D1",
+	"RELTYPE_D2",
+	"RELTYPE_D3",
+	"RELTYPE_D4",
+	"RELTYPE_D5",
+	"RELTYPE_D6",
+	"RELTYPE_D7",
+	"RELTYPE_D8",
+	"RELTYPE_D9",
+	"RELTYPE_DA",
+	"RELTYPE_DB",
+	"RELTYPE_DC",
+	"RELTYPE_DD",
+	"RELTYPE_DE",
+	"RELTYPE_DF",
+	"RELTYPE_E0",
+	"RELTYPE_E1",
+	"RELTYPE_E2",
+	"RELTYPE_E3",
+	"RELTYPE_E4",
+	"RELTYPE_E5",
+	"RELTYPE_E6",
+	"RELTYPE_E7",
+	"RELTYPE_E8",
+	"RELTYPE_E9",
+	"RELTYPE_EA",
+	"RELTYPE_EB",
+	"RELTYPE_EC",
+	"RELTYPE_ED",
+	"RELTYPE_EE",
+	"RELTYPE_EF",
+	"RELTYPE_F0",
+	"RELTYPE_F1",
+	"RELTYPE_F2",
+	"RELTYPE_F3",
+	"RELTYPE_F4",
+	"RELTYPE_F5",
+	"RELTYPE_F6",
+	"RELTYPE_F7",
+	"RELTYPE_F8",
+	"RELTYPE_F9",
+	"RELTYPE_FA",
+	"RELTYPE_FB",
+	"RELTYPE_FC",
+	"RELTYPE_FD",
+	"RELTYPE_FE",
+	"RELTYPE_FF"
+};
+
+const char *blkTypeName[256] =
+{
+	"Module Block",
+	"DO Block",
+	"PROCEDURE Block",
+	"Module end",
+	"DO end",
+	"PRCEDURE end",
+	"BLKTYPE_06",
+	"BLKTYPE_07",
+	"BLKTYPE_08",
+	"BLKTYPE_09",
+	"BLKTYPE_0A",
+	"BLKTYPE_0B",
+	"BLKTYPE_0C",
+	"BLKTYPE_0D",
+	"BLKTYPE_0E",
+	"BLKTYPE_0F",
+	"BLKTYPE_10",
+	"BLKTYPE_11",
+	"BLKTYPE_12",
+	"BLKTYPE_13",
+	"BLKTYPE_14",
+	"BLKTYPE_15",
+	"BLKTYPE_16",
+	"BLKTYPE_17",
+	"BLKTYPE_18",
+	"BLKTYPE_19",
+	"BLKTYPE_1A",
+	"BLKTYPE_1B",
+	"BLKTYPE_1C",
+	"BLKTYPE_1D",
+	"BLKTYPE_1E",
+	"BLKTYPE_1F",
+	"BLKTYPE_20",
+	"BLKTYPE_21",
+	"BLKTYPE_22",
+	"BLKTYPE_23",
+	"BLKTYPE_24",
+	"BLKTYPE_25",
+	"BLKTYPE_26",
+	"BLKTYPE_27",
+	"BLKTYPE_28",
+	"BLKTYPE_29",
+	"BLKTYPE_2A",
+	"BLKTYPE_2B",
+	"BLKTYPE_2C",
+	"BLKTYPE_2D",
+	"BLKTYPE_2E",
+	"BLKTYPE_2F",
+	"BLKTYPE_30",
+	"BLKTYPE_31",
+	"BLKTYPE_32",
+	"BLKTYPE_33",
+	"BLKTYPE_34",
+	"BLKTYPE_35",
+	"BLKTYPE_36",
+	"BLKTYPE_37",
+	"BLKTYPE_38",
+	"BLKTYPE_39",
+	"BLKTYPE_3A",
+	"BLKTYPE_3B",
+	"BLKTYPE_3C",
+	"BLKTYPE_3D",
+	"BLKTYPE_3E",
+	"BLKTYPE_3F",
+	"BLKTYPE_40",
+	"BLKTYPE_41",
+	"BLKTYPE_42",
+	"BLKTYPE_43",
+	"BLKTYPE_44",
+	"BLKTYPE_45",
+	"BLKTYPE_46",
+	"BLKTYPE_47",
+	"BLKTYPE_48",
+	"BLKTYPE_49",
+	"BLKTYPE_4A",
+	"BLKTYPE_4B",
+	"BLKTYPE_4C",
+	"BLKTYPE_4D",
+	"BLKTYPE_4E",
+	"BLKTYPE_4F",
+	"BLKTYPE_50",
+	"BLKTYPE_51",
+	"BLKTYPE_52",
+	"BLKTYPE_53",
+	"BLKTYPE_54",
+	"BLKTYPE_55",
+	"BLKTYPE_56",
+	"BLKTYPE_57",
+	"BLKTYPE_58",
+	"BLKTYPE_59",
+	"BLKTYPE_5A",
+	"BLKTYPE_5B",
+	"BLKTYPE_5C",
+	"BLKTYPE_5D",
+	"BLKTYPE_5E",
+	"BLKTYPE_5F",
+	"BLKTYPE_60",
+	"BLKTYPE_61",
+	"BLKTYPE_62",
+	"BLKTYPE_63",
+	"BLKTYPE_64",
+	"BLKTYPE_65",
+	"BLKTYPE_66",
+	"BLKTYPE_67",
+	"BLKTYPE_68",
+	"BLKTYPE_69",
+	"BLKTYPE_6A",
+	"BLKTYPE_6B",
+	"BLKTYPE_6C",
+	"BLKTYPE_6D",
+	"BLKTYPE_6E",
+	"BLKTYPE_6F",
+	"BLKTYPE_70",
+	"BLKTYPE_71",
+	"BLKTYPE_72",
+	"BLKTYPE_73",
+	"BLKTYPE_74",
+	"BLKTYPE_75",
+	"BLKTYPE_76",
+	"BLKTYPE_77",
+	"BLKTYPE_78",
+	"BLKTYPE_79",
+	"BLKTYPE_7A",
+	"BLKTYPE_7B",
+	"BLKTYPE_7C",
+	"BLKTYPE_7D",
+	"BLKTYPE_7E",
+	"BLKTYPE_7F",
+	"BLKTYPE_80",
+	"BLKTYPE_81",
+	"BLKTYPE_82",
+	"BLKTYPE_83",
+	"BLKTYPE_84",
+	"BLKTYPE_85",
+	"BLKTYPE_86",
+	"BLKTYPE_87",
+	"BLKTYPE_88",
+	"BLKTYPE_89",
+	"BLKTYPE_8A",
+	"BLKTYPE_8B",
+	"BLKTYPE_8C",
+	"BLKTYPE_8D",
+	"BLKTYPE_8E",
+	"BLKTYPE_8F",
+	"BLKTYPE_90",
+	"BLKTYPE_91",
+	"BLKTYPE_92",
+	"BLKTYPE_93",
+	"BLKTYPE_94",
+	"BLKTYPE_95",
+	"BLKTYPE_96",
+	"BLKTYPE_97",
+	"BLKTYPE_98",
+	"BLKTYPE_99",
+	"BLKTYPE_9A",
+	"BLKTYPE_9B",
+	"BLKTYPE_9C",
+	"BLKTYPE_9D",
+	"BLKTYPE_9E",
+	"BLKTYPE_9F",
+	"BLKTYPE_A0",
+	"BLKTYPE_A1",
+	"BLKTYPE_A2",
+	"BLKTYPE_A3",
+	"BLKTYPE_A4",
+	"BLKTYPE_A5",
+	"BLKTYPE_A6",
+	"BLKTYPE_A7",
+	"BLKTYPE_A8",
+	"BLKTYPE_A9",
+	"BLKTYPE_AA",
+	"BLKTYPE_AB",
+	"BLKTYPE_AC",
+	"BLKTYPE_AD",
+	"BLKTYPE_AE",
+	"BLKTYPE_AF",
+	"BLKTYPE_B0",
+	"BLKTYPE_B1",
+	"BLKTYPE_B2",
+	"BLKTYPE_B3",
+	"BLKTYPE_B4",
+	"BLKTYPE_B5",
+	"BLKTYPE_B6",
+	"BLKTYPE_B7",
+	"BLKTYPE_B8",
+	"BLKTYPE_B9",
+	"BLKTYPE_BA",
+	"BLKTYPE_BB",
+	"BLKTYPE_BC",
+	"BLKTYPE_BD",
+	"BLKTYPE_BE",
+	"BLKTYPE_BF",
+	"BLKTYPE_C0",
+	"BLKTYPE_C1",
+	"BLKTYPE_C2",
+	"BLKTYPE_C3",
+	"BLKTYPE_C4",
+	"BLKTYPE_C5",
+	"BLKTYPE_C6",
+	"BLKTYPE_C7",
+	"BLKTYPE_C8",
+	"BLKTYPE_C9",
+	"BLKTYPE_CA",
+	"BLKTYPE_CB",
+	"BLKTYPE_CC",
+	"BLKTYPE_CD",
+	"BLKTYPE_CE",
+	"BLKTYPE_CF",
+	"BLKTYPE_D0",
+	"BLKTYPE_D1",
+	"BLKTYPE_D2",
+	"BLKTYPE_D3",
+	"BLKTYPE_D4",
+	"BLKTYPE_D5",
+	"BLKTYPE_D6",
+	"BLKTYPE_D7",
+	"BLKTYPE_D8",
+	"BLKTYPE_D9",
+	"BLKTYPE_DA",
+	"BLKTYPE_DB",
+	"BLKTYPE_DC",
+	"BLKTYPE_DD",
+	"BLKTYPE_DE",
+	"BLKTYPE_DF",
+	"BLKTYPE_E0",
+	"BLKTYPE_E1",
+	"BLKTYPE_E2",
+	"BLKTYPE_E3",
+	"BLKTYPE_E4",
+	"BLKTYPE_E5",
+	"BLKTYPE_E6",
+	"BLKTYPE_E7",
+	"BLKTYPE_E8",
+	"BLKTYPE_E9",
+	"BLKTYPE_EA",
+	"BLKTYPE_EB",
+	"BLKTYPE_EC",
+	"BLKTYPE_ED",
+	"BLKTYPE_EE",
+	"BLKTYPE_EF",
+	"BLKTYPE_F0",
+	"BLKTYPE_F1",
+	"BLKTYPE_F2",
+	"BLKTYPE_F3",
+	"BLKTYPE_F4",
+	"BLKTYPE_F5",
+	"BLKTYPE_F6",
+	"BLKTYPE_F7",
+	"BLKTYPE_F8",
+	"BLKTYPE_F9",
+	"BLKTYPE_FA",
+	"BLKTYPE_FB",
+	"BLKTYPE_FC",
+	"BLKTYPE_FD",
+	"BLKTYPE_FE",
+	"BLKTYPE_FF"
+};
+
+const char *dbgDefTypeName[256] =
+{
+	"Local symbols",
+	"Public symbols",
+	"Segment symbols",
+	"Line numbers",
+	"DEFTYPE_04",
+	"DEFTYPE_05",
+	"DEFTYPE_06",
+	"DEFTYPE_07",
+	"DEFTYPE_08",
+	"DEFTYPE_09",
+	"DEFTYPE_0A",
+	"DEFTYPE_0B",
+	"DEFTYPE_0C",
+	"DEFTYPE_0D",
+	"DEFTYPE_0E",
+	"DEFTYPE_0F",
+	"DEFTYPE_10",
+	"DEFTYPE_11",
+	"DEFTYPE_12",
+	"DEFTYPE_13",
+	"DEFTYPE_14",
+	"DEFTYPE_15",
+	"DEFTYPE_16",
+	"DEFTYPE_17",
+	"DEFTYPE_18",
+	"DEFTYPE_19",
+	"DEFTYPE_1A",
+	"DEFTYPE_1B",
+	"DEFTYPE_1C",
+	"DEFTYPE_1D",
+	"DEFTYPE_1E",
+	"DEFTYPE_1F",
+	"DEFTYPE_20",
+	"DEFTYPE_21",
+	"DEFTYPE_22",
+	"DEFTYPE_23",
+	"DEFTYPE_24",
+	"DEFTYPE_25",
+	"DEFTYPE_26",
+	"DEFTYPE_27",
+	"DEFTYPE_28",
+	"DEFTYPE_29",
+	"DEFTYPE_2A",
+	"DEFTYPE_2B",
+	"DEFTYPE_2C",
+	"DEFTYPE_2D",
+	"DEFTYPE_2E",
+	"DEFTYPE_2F",
+	"DEFTYPE_30",
+	"DEFTYPE_31",
+	"DEFTYPE_32",
+	"DEFTYPE_33",
+	"DEFTYPE_34",
+	"DEFTYPE_35",
+	"DEFTYPE_36",
+	"DEFTYPE_37",
+	"DEFTYPE_38",
+	"DEFTYPE_39",
+	"DEFTYPE_3A",
+	"DEFTYPE_3B",
+	"DEFTYPE_3C",
+	"DEFTYPE_3D",
+	"DEFTYPE_3E",
+	"DEFTYPE_3F",
+	"DEFTYPE_40",
+	"DEFTYPE_41",
+	"DEFTYPE_42",
+	"DEFTYPE_43",
+	"DEFTYPE_44",
+	"DEFTYPE_45",
+	"DEFTYPE_46",
+	"DEFTYPE_47",
+	"DEFTYPE_48",
+	"DEFTYPE_49",
+	"DEFTYPE_4A",
+	"DEFTYPE_4B",
+	"DEFTYPE_4C",
+	"DEFTYPE_4D",
+	"DEFTYPE_4E",
+	"DEFTYPE_4F",
+	"DEFTYPE_50",
+	"DEFTYPE_51",
+	"DEFTYPE_52",
+	"DEFTYPE_53",
+	"DEFTYPE_54",
+	"DEFTYPE_55",
+	"DEFTYPE_56",
+	"DEFTYPE_57",
+	"DEFTYPE_58",
+	"DEFTYPE_59",
+	"DEFTYPE_5A",
+	"DEFTYPE_5B",
+	"DEFTYPE_5C",
+	"DEFTYPE_5D",
+	"DEFTYPE_5E",
+	"DEFTYPE_5F",
+	"DEFTYPE_60",
+	"DEFTYPE_61",
+	"DEFTYPE_62",
+	"DEFTYPE_63",
+	"DEFTYPE_64",
+	"DEFTYPE_65",
+	"DEFTYPE_66",
+	"DEFTYPE_67",
+	"DEFTYPE_68",
+	"DEFTYPE_69",
+	"DEFTYPE_6A",
+	"DEFTYPE_6B",
+	"DEFTYPE_6C",
+	"DEFTYPE_6D",
+	"DEFTYPE_6E",
+	"DEFTYPE_6F",
+	"DEFTYPE_70",
+	"DEFTYPE_71",
+	"DEFTYPE_72",
+	"DEFTYPE_73",
+	"DEFTYPE_74",
+	"DEFTYPE_75",
+	"DEFTYPE_76",
+	"DEFTYPE_77",
+	"DEFTYPE_78",
+	"DEFTYPE_79",
+	"DEFTYPE_7A",
+	"DEFTYPE_7B",
+	"DEFTYPE_7C",
+	"DEFTYPE_7D",
+	"DEFTYPE_7E",
+	"DEFTYPE_7F",
+	"DEFTYPE_80",
+	"DEFTYPE_81",
+	"DEFTYPE_82",
+	"DEFTYPE_83",
+	"DEFTYPE_84",
+	"DEFTYPE_85",
+	"DEFTYPE_86",
+	"DEFTYPE_87",
+	"DEFTYPE_88",
+	"DEFTYPE_89",
+	"DEFTYPE_8A",
+	"DEFTYPE_8B",
+	"DEFTYPE_8C",
+	"DEFTYPE_8D",
+	"DEFTYPE_8E",
+	"DEFTYPE_8F",
+	"DEFTYPE_90",
+	"DEFTYPE_91",
+	"DEFTYPE_92",
+	"DEFTYPE_93",
+	"DEFTYPE_94",
+	"DEFTYPE_95",
+	"DEFTYPE_96",
+	"DEFTYPE_97",
+	"DEFTYPE_98",
+	"DEFTYPE_99",
+	"DEFTYPE_9A",
+	"DEFTYPE_9B",
+	"DEFTYPE_9C",
+	"DEFTYPE_9D",
+	"DEFTYPE_9E",
+	"DEFTYPE_9F",
+	"DEFTYPE_A0",
+	"DEFTYPE_A1",
+	"DEFTYPE_A2",
+	"DEFTYPE_A3",
+	"DEFTYPE_A4",
+	"DEFTYPE_A5",
+	"DEFTYPE_A6",
+	"DEFTYPE_A7",
+	"DEFTYPE_A8",
+	"DEFTYPE_A9",
+	"DEFTYPE_AA",
+	"DEFTYPE_AB",
+	"DEFTYPE_AC",
+	"DEFTYPE_AD",
+	"DEFTYPE_AE",
+	"DEFTYPE_AF",
+	"DEFTYPE_B0",
+	"DEFTYPE_B1",
+	"DEFTYPE_B2",
+	"DEFTYPE_B3",
+	"DEFTYPE_B4",
+	"DEFTYPE_B5",
+	"DEFTYPE_B6",
+	"DEFTYPE_B7",
+	"DEFTYPE_B8",
+	"DEFTYPE_B9",
+	"DEFTYPE_BA",
+	"DEFTYPE_BB",
+	"DEFTYPE_BC",
+	"DEFTYPE_BD",
+	"DEFTYPE_BE",
+	"DEFTYPE_BF",
+	"DEFTYPE_C0",
+	"DEFTYPE_C1",
+	"DEFTYPE_C2",
+	"DEFTYPE_C3",
+	"DEFTYPE_C4",
+	"DEFTYPE_C5",
+	"DEFTYPE_C6",
+	"DEFTYPE_C7",
+	"DEFTYPE_C8",
+	"DEFTYPE_C9",
+	"DEFTYPE_CA",
+	"DEFTYPE_CB",
+	"DEFTYPE_CC",
+	"DEFTYPE_CD",
+	"DEFTYPE_CE",
+	"DEFTYPE_CF",
+	"DEFTYPE_D0",
+	"DEFTYPE_D1",
+	"DEFTYPE_D2",
+	"DEFTYPE_D3",
+	"DEFTYPE_D4",
+	"DEFTYPE_D5",
+	"DEFTYPE_D6",
+	"DEFTYPE_D7",
+	"DEFTYPE_D8",
+	"DEFTYPE_D9",
+	"DEFTYPE_DA",
+	"DEFTYPE_DB",
+	"DEFTYPE_DC",
+	"DEFTYPE_DD",
+	"DEFTYPE_DE",
+	"DEFTYPE_DF",
+	"DEFTYPE_E0",
+	"DEFTYPE_E1",
+	"DEFTYPE_E2",
+	"DEFTYPE_E3",
+	"DEFTYPE_E4",
+	"DEFTYPE_E5",
+	"DEFTYPE_E6",
+	"DEFTYPE_E7",
+	"DEFTYPE_E8",
+	"DEFTYPE_E9",
+	"DEFTYPE_EA",
+	"DEFTYPE_EB",
+	"DEFTYPE_EC",
+	"DEFTYPE_ED",
+	"DEFTYPE_EE",
+	"DEFTYPE_EF",
+	"DEFTYPE_F0",
+	"DEFTYPE_F1",
+	"DEFTYPE_F2",
+	"DEFTYPE_F3",
+	"DEFTYPE_F4",
+	"DEFTYPE_F5",
+	"DEFTYPE_F6",
+	"DEFTYPE_F7",
+	"DEFTYPE_F8",
+	"DEFTYPE_F9",
+	"DEFTYPE_FA",
+	"DEFTYPE_FB",
+	"DEFTYPE_FC",
+	"DEFTYPE_FD",
+	"DEFTYPE_FE",
+	"DEFTYPE_FF"
+};
+
+/***************************************************************************/
+/* Ende
+/***************************************************************************/
diff --git a/omf51const.h b/omf51const.h
new file mode 100755
index 0000000..06eeff3
--- /dev/null
+++ b/omf51const.h
@@ -0,0 +1,20 @@
+/***************************************************************************/
+/* omf51const.h */
+/***************************************************************************/
+#ifndef OMF51CONST_H
+#define OMF51CONST_H
+
+/***************************************************************************/
+/* Constants
+/***************************************************************************/
+extern const char *recTypeTitle[256];
+extern const char *segTypeName[8];
+extern const char *symTypeName[8];
+extern const char *relTypeName[256];
+extern const char *blkTypeName[256];
+extern const char *dbgDefTypeName[256];
+
+/***************************************************************************/
+/* Ende
+/***************************************************************************/
+#endif /* OMF51CONST_H */
\ No newline at end of file
diff --git a/omf51print.c b/omf51print.c
new file mode 100755
index 0000000..d77b761
--- /dev/null
+++ b/omf51print.c
@@ -0,0 +1,443 @@
+/***************************************************************************/
+/* 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
+/***************************************************************************/
diff --git a/omf51print.h b/omf51print.h
new file mode 100755
index 0000000..4c6db47
--- /dev/null
+++ b/omf51print.h
@@ -0,0 +1,44 @@
+/***************************************************************************/
+/* omf51print.h */
+/***************************************************************************/
+
+#ifndef OMF51PRINT_H
+#define OMF51PRINT_H
+
+/***************************************************************************/
+/* Constants
+/***************************************************************************/
+
+/***************************************************************************/
+/* Helper Functions
+/***************************************************************************/
+BYTE SegmentGetSegType(BYTE segInfo);
+BYTE SegmentGetSegReg(BYTE segInfo);
+BYTE SegmentIsEmpty(BYTE segInfo);
+BYTE SegmentIsOVL(BYTE segInfo);
+BYTE SymbolIsIND(BYTE symInfo);
+BYTE SymbolIsVAR(BYTE symInfo);
+BYTE SymbolIsRBF(BYTE symInfo);
+BYTE SymbolGetSymReg(BYTE symInfo);
+BYTE SegmentGetSymType(BYTE symInfo);
+
+/***************************************************************************/
+/* Exported Functions
+/***************************************************************************/
+void MHDRPrint(struct _sMHDR *pObj, FILE *pFile);
+void SEGDEFPrint(struct _sSEGDEF *pObj, FILE *pFile);
+void SEGPrint(struct _sSEG *pObj, FILE *pFile);
+void PUBDEFPrint(struct _sPUBDEF *pObj, FILE *pFile);
+void PUBPrint(struct _sPUB *pObj, FILE *pFile);
+void EXTDEFPrint(struct _sEXTDEF *pObj, FILE *pFile);
+void EXTPrint(struct _sEXT *pObj, FILE *pFile);
+void SCDPrint(struct _sSCD *pObj, FILE *pFile);
+void DBGINFOPrint(struct _sDBGINFO *pObj, FILE *pFile, BYTE defType);
+void DBGPrint(struct _sDBG *pObj, FILE *pFile);
+void CNTPrint(struct _sCNT *pObj, FILE *pFile);
+void OmfPrint(struct _sOBJECT *pObj);
+
+/***************************************************************************/
+/* Ende
+/***************************************************************************/
+#endif /* OMF51PRINT_H */