/*** htest - help engine test harness
*
*   Copyright <C> 1987, Microsoft Corporation
*
* Revision History:
*
*	15-Dec-1988 ln	Added dump command
*   []	21-Oct-1988 LN	New Version
*
*************************************************************************/

#include <io.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined (OS2)
#define INCL_SUB
#define INCL_DOSMODULEMGR
#define INCL_DOSFILEMGR
#define INCL_DOSMISC
#include <ctype.h>
#include <os2.h>
#else
#include <windows.h>
#endif

#include "cons.h"

#include "help.h"
#include "helpfile.h"			/* help file format definition	*/
#include "helpsys.h"			/* internal (help sys only) decl*/

#if defined (OS2)
#define HELPDLL_NAME    "mshelp1.dll"
#define HELPDLL_BASE    "mshelp1"
#else
#define HELPDLL_NAME    "mshelp.dll"
#define HELPDLL_BASE    "mshelp"
#endif
/*
 * text color values
 */
#define BLACK		0
#define BLUE		1
#define GREEN		2
#define CYAN		3
#define RED		4
#define MAGENTA 	5
#define BROWN		6
#define WHITE		7
#define GREY		8
#define LIGHTBLUE	9
#define LIGHTGREEN	10
#define LIGHTCYAN	11
#define LIGHTRED	12
#define LIGHTMAGENTA	13
#define YELLOW		14
#define BRIGHTWHITE	15

#define BUFSIZE 	128		/* text buffer size		*/

#define ISERROR(x)      (((x).mh == 0L) && ((x).cn <= HELPERR_MAX))
#define SETERROR(x,y)   { (x).mh = 0L; (x).cn = y;}

typedef void    pascal (*void_F)    (void);
typedef int     pascal (*int_F)     (void);
typedef ushort  pascal (*ushort_F)  (void);
typedef f       pascal (*f_F)       (void);
typedef char *  pascal (*pchar_F)   (void);
typedef nc      pascal (*nc_F)      (void);
typedef mh      pascal (*mh_F)      (void);

#if !defined (HELP_HACK)

#define HelpcLines      ((int_F)    (pEntry[P_HelpcLines     ]))
#define HelpClose       ((void_F)   (pEntry[P_HelpClose      ]))
#define HelpCtl         ((void_F)   (pEntry[P_HelpCtl        ]))
#define HelpDecomp      ((f_F)      (pEntry[P_HelpDecomp     ]))
#define HelpGetCells    ((int_F)    (pEntry[P_HelpGetCells   ]))
#define HelpGetInfo     ((inf_F)    (pEntry[P_HelpGetInfo    ]))
#define HelpGetLine     ((ushort_F) (pEntry[P_HelpGetLine    ]))
#define HelpGetLineAttr ((ushort_F) (pEntry[P_HelpGetLineAttr]))
#define HelpHlNext      ((f_F)      (pEntry[P_HelpHlNext     ]))
#define HelpLook        ((ushort_F) (pEntry[P_HelpLook       ]))
#define HelpNc          ((nc_F)     (pEntry[P_HelpNc         ]))
#define HelpNcBack      ((nc_F)     (pEntry[P_HelpNcBack     ]))
#define HelpNcCb        ((ushort_F) (pEntry[P_HelpNcCb       ]))
#define HelpNcCmp       ((nc_F)     (pEntry[P_HelpNcCmp      ]))
#define HelpNcNext      ((nc_F)     (pEntry[P_HelpNcNext     ]))
#define HelpNcPrev      ((nc_F)     (pEntry[P_HelpNcPrev     ]))
#define HelpNcRecord    ((void_F)   (pEntry[P_HelpNcRecord   ]))
#define HelpNcUniq      ((nc_F)     (pEntry[P_HelpNcUniq     ]))
#define HelpOpen        ((nc_F)     (pEntry[P_HelpOpen       ]))
#define HelpShrink      ((void_F)   (pEntry[P_HelpShrink     ]))
#define HelpSzContext   ((f_F)      (pEntry[P_HelpSzContext  ]))
#define HelpXRef        ((pchar_F)  (pEntry[P_HelpXRef       ]))
#define LoadFdb         ((f_F)      (pEntry[P_LoadFdb        ]))
#define LoadPortion     ((mh_F)     (pEntry[P_LoadPortion    ]))

#endif

enum {
    P_HelpcLines,
    P_HelpClose,
    P_HelpCtl,
    P_HelpDecomp,
    P_HelpGetCells,
    P_HelpGetInfo,
    P_HelpGetLine,
    P_HelpGetLineAttr,
    P_HelpHlNext,
    P_HelpLook,
    P_HelpNc,
    P_HelpNcBack,
    P_HelpNcCb,
    P_HelpNcCmp,
    P_HelpNcNext,
    P_HelpNcPrev,
    P_HelpNcRecord,
    P_HelpNcUniq,
    P_HelpOpen,
    P_HelpShrink,
    P_HelpSzContext,
    P_HelpXRef,
    P_LoadFdb,
    P_LoadPortion,
    LASTENTRYPOINT
    } ENTRYPOINTS;

#define NUM_ENTRYPOINTS (LASTENTRYPOINT - P_HelpcLines)


typedef nc pascal (*PHF) (void);


/*
 * Global Data
 */
char            buf[BUFSIZ];            /* text buffer                  */
char            cell[2] = {' ',0x1f};   /* background clearing cell     */
#define ColorByte cell[1]
int             curline;                /* current line output          */
char            *errTbl[] = {
                    "",
                    "help file not found",
                    "ReadHelpFile failed on header",
                    "to many open helpfiles",
                    "bad appeneded file",
                    "Not a help file",
                    "newer or incompatible help file",
                    "memory allocation failed"
                    };
f		fBoth	= FALSE; /* both stdout & screen	*/
f		fEnable = FALSE;	/* enable control lines in disp */
int             iNcCur;                 /* current index in ncTbl       */
int             lastline;
int             lLast;                  /* last starting line number disp*/
mh		mhTopicCur;		/* mem handle for most recent	*/
uchar		mpAttr[] = {		/* on-screen color map		*/
		   0x1f,		/* 0: normal text		*/
		   0x1c,		/* 1: bold			*/
		   0x1a,		/* 2: italics			*/
		   0x1e,		/* 3: bold italics		*/
		   0x7f,		/* 4: underline 		*/
		   0x7c,		/* 5: bold ul			*/
		   0x7a,		/* 6: italics ul		*/
		   0x7e 		/* 7: bold italics ul		*/
		    };
nc		ncCur;			/* most recently read in topic	*/
nc		ncTbl[MAXFILES];	/* table of open nc's           */
char far *	pTopicCur;		/* ptr to most recent topic	*/
char            *spaces  = "                                                                  \r\n";

#if defined (OS2)
HMODULE         hModule;
#else
HANDLE          hModule;
#endif

PHF             pEntry[NUM_ENTRYPOINTS] = {0};
#if defined (OS2)
char *          szEntryName[NUM_ENTRYPOINTS] = {
                    "_HelpcLines",
                    "_HelpClose",
                    "_HelpCtl",
                    "_HelpDecomp",
                    "_HelpGetCells",
                    "_HelpGetInfo",
                    "_HelpGetLine",
                    "_HelpGetLineAttr",
                    "_HelpHlNext",
                    "_HelpLook",
                    "_HelpNc",
                    "_HelpNcBack",
                    "_HelpNcCb",
                    "_HelpNcCmp",
                    "_HelpNcNext",
                    "_HelpNcPrev",
                    "_HelpNcRecord",
                    "_HelpNcUniq",
                    "_HelpOpen",
                    "_HelpShrink",
                    "_HelpSzContext",
                    "_HelpXRef",
                    "_LoadFdb",
                    "_LoadPortion",
                    };

#else
char *          szEntryName[NUM_ENTRYPOINTS] = {
                    "HelpcLines",
                    "HelpClose",
                    "HelpCtl",
                    "HelpDecomp",
                    "HelpGetCells",
                    "HelpGetInfo",
                    "HelpGetLine",
                    "HelpGetLineAttr",
                    "HelpHlNext",
                    "HelpLook",
                    "HelpNc",
                    "HelpNcBack",
                    "HelpNcCb",
                    "HelpNcCmp",
                    "HelpNcNext",
                    "HelpNcPrev",
                    "HelpNcRecord",
                    "HelpNcUniq",
                    "HelpOpen",
                    "HelpShrink",
                    "HelpSzContext",
                    "HelpXRef",
                    "LoadFdb",
                    "LoadPortion",
                    };

#endif

// rjsa VIOMODEINFO     screen;

/*
 * Forward declarations
 */
#define ASSERTDOS(x)   assertDos(x, __FILE__, __LINE__)
void        pascal near assertDos   (USHORT, CHAR *, USHORT);
void	    pascal near cls	    (void);
void        pascal near dispCmd     (int, int);
void		pascal near dumpCmd 	();
void		pascal near dumpfileCmd ( char *);
void	    pascal near fileCmd     (char *);
void	    pascal near helpCmd     (void);
void        pascal near lookupCmd   (char *, int);
void        pascal near outtext     (char *, BYTE);
void        pascal near outtextat   (char *, int, int, BYTE);
uchar far * pascal near phrasecopy  (uchar *, uchar far *);
void	    pascal near xrefCmd     (char *);

#undef HelpDealloc
#undef HelpLock
#undef HelpUnlock

void        pascal  far HelpDealloc (mh);
void far *  pascal  far HelpLock    (mh);
void	    pascal  far HelpUnlock  (mh);

f		 pascal near LoadFdb (mh, fdb far *);
mh		 pascal near LoadPortion (USHORT, mh);
//char far *  pascal near hfstrcpy(char far *, char far *);
//ushort      pascal near hfstrlen(char far *);


void   LoadTheDll(void);
USHORT WrtCellStr (PBYTE buf, int cb, int row, int col);
USHORT WrtLineAttr( PBYTE buf, lineattr* rgAttr, int cb, int row, int col );
USHORT WrtCharStrAtt (PBYTE pText, int cb, int row, int col, PBYTE pcolor);


PSCREEN     Scr;

/*** main - main program
*
* Input:
*  Standard C main, all ignored
*
* Output:
*  Returns via exit()
*
*************************************************************************/
void main(
USHORT     argc,
char	**argv
) {
char    c;
nc		ncNull = {0,0};
SCREEN_INFORMATION ScrInfo;
/*
 * parse any options
 */
if (argc > 1)
    while ((** ++argv) == '-') {
	c = *(++(*argv));
	switch (toupper(c)) {
	    case 'B':			    /* -b: both screen and stdout   */
		fBoth = TRUE;
		break;
	    default:
		fputs ("Unknown switch ignored", stderr);
		break;
	    }
        }

// InitializeGlobalState();
Scr = consoleGetCurrentScreen();

//  Load help engine DLL and initialize pointers to entry
//  points.
//
LoadTheDll();

#if defined(CLEAR)
HelpInit();
#endif

/*
 * Start by getting the current config & clearing screen.
 */
// rjsa screen.cb = sizeof(screen);
// rjsa assertDos (VioGetMode (&screen, 0));
// rjsa lastline = screen.row-1;
consoleGetScreenInformation( Scr, &ScrInfo );
lastline = ScrInfo.NumberOfRows-2;
// lastline = 22;
cls();
helpCmd();
/*
 * main loop. Position at bottom of screen, and accept one command at at time
 * from there. Interpret commands until done.
 */
do {
    outtextat ("\r\n", lastline, 0, BRIGHTWHITE);
    outtextat (spaces, lastline, 0, BRIGHTWHITE);
	outtextat ("HTEST Command> ", lastline, 0, BRIGHTWHITE);
    // rjsa VioSetCurPos (lastline, 15, 0);
    consoleSetCursor(Scr, lastline, 16);
    gets (buf);
    cls ();
    outtextat ("\r\n", lastline, 0, BRIGHTWHITE);
    outtextat ("Processing: ", lastline, 0, LIGHTRED);
    outtextat (buf, lastline, 12, BRIGHTWHITE);
    outtextat ("\r\n", lastline, 0, BRIGHTWHITE);
/*
 * ctrl on/off
 */
    if (!strcmp (buf,"ctrl on")) {
	fEnable = TRUE;
	cls ();
	outtextat ("Control Lines Displayed", 0, 0, BRIGHTWHITE);
	}
    else if (!strcmp (buf,"ctrl off")) {
	fEnable = FALSE;
	cls ();
	outtextat ("Control Lines NOT Displayed", 0, 0, BRIGHTWHITE);
	}
/*
 * disp
 */
    else if (!strcmp (buf,"disp"))
	dispCmd (1,lastline);
/*
 * down
 */
    else if (!strcmp (buf,"down"))
	dispCmd (lLast+1,lLast + lastline);
/*
 * dump
 */
	else if (!strncmp (buf, "dump ", 5))
	dumpfileCmd(buf+5);
	else if (!strcmp (buf,"dump"))
	dumpCmd ();
/*
 * file newhelpfilename
 */
    else if (!strncmp (buf,"file ", 5))
	fileCmd (buf+5);
/*
 * help
 */
    else if (!strcmp (buf,"help"))
	helpCmd ();
/*
 * look helpstring
 */
    else if (!strncmp (buf,"look ", 5))
	lookupCmd (buf+5,0);
/*
 * look
 */
    else if (!strcmp (buf,"look"))
	lookupCmd (NULL,0);
/*
 * next
 */
    else if (!strcmp (buf,"next"))
	lookupCmd (NULL,1);
/*
 * prev
 */
    else if (!strcmp (buf,"prev"))
	lookupCmd (NULL,-1);
/*
 * up
 */
    else if (!strcmp (buf,"up")) {
	lLast = max (1, lLast-1);
	dispCmd (lLast,lLast + lastline);
	}
/*
 * xref xrefnumber
 */
    else if (!strncmp (buf,"xref", 4))
	xrefCmd (buf+4);
/*
 * + page down
 */
    else if (!strcmp (buf,"+")) {
	lLast += lastline;
	dispCmd (lLast,lLast + lastline);
	}
/*
 * - page up
 */
    else if (!strcmp (buf,"-")) {
	lLast = max (1, lLast - (lastline));
	dispCmd (lLast,lLast + lastline);
	}
    }
/*
 * exit
 */
while (strncmp(buf,"exit",4));
outtextat (spaces, lastline, 0, BRIGHTWHITE);
HelpClose (ncNull);

/* end main */}






/*** dispCmd - display topic text
*
*  displays the topic text on the screen.
*
* Input:
*  lStart	- starting line
*   lEnd	- ending line
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near dispCmd (
int     lStart,
int     lEnd
) {
char	buf[BUFSIZ*2];
lineattr	rgAttr[BUFSIZ];
int     cb;
int     lineCur = 0;

	HelpCtl (pTopicCur, fEnable);
	cls ();
	lLast = lStart;
	while (lStart<lEnd) {
		if (!isatty(_fileno(stdout)) || fBoth) {
			cb = (int)HelpGetLine (lStart, BUFSIZ*2, (char far *)buf, pTopicCur);
			if (cb == 0)
				lStart = lEnd;
			buf[cb-1] = '\r';
			buf[cb] = '\n';
			buf[cb+1] = 0;
			outtext (buf, BLACK);
			buf[cb-1] = 0;
		}
		if (isatty(_fileno(stdout)) || fBoth) {
			cb = HelpGetLine(lStart, BUFSIZ*2, (char far*)buf, pTopicCur );
			HelpGetLineAttr( lStart, BUFSIZ*sizeof(lineattr), rgAttr, pTopicCur );
			WrtLineAttr(buf, rgAttr, cb, lineCur++, 0 );
		}

		//if (isatty(fileno(stdout)) || fBoth) {
		//	 cb = HelpGetCells (lStart, BUFSIZ*2, buf, pTopicCur, mpAttr);
		//	if (cb == -1)
		//		lStart = lEnd;
		//	else
		//		 ASSERTDOS (WrtCellStr (buf, cb, lineCur++, 0));
		//	}

		lStart++;
	}

/* end dispCmd */}

static char *szHS[] = { "HS_INDEX",
			"HS_CONTEXTSTRINGS",
			"HS_CONTEXTMAP",
			"HS_KEYPHRASE",
			"HS_HUFFTREE",
			"HS_TOPICS",
			"unused (6)",
			"unused (7)",
			"HS_NEXT" };

/*** dumpCmd - process dump command
*
*  Dumps the contents of the current help file
*
* NOTE:
*  This function uses all sorts of "internal" knowledge and calls to
*  do it's job.
*
* Input:
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near dumpCmd () {
char	buf[BUFSIZ];
int  cbKeyPhrase;
fdb	fdbLocal;			/* local copy of fdb to use	*/
uchar far *fpT;
ushort far *fpW;
int     i;
nc	ncNext; 			/* nc init of appended file	*/
//uchar	uc;

cls();
ncNext = ncCur;
while (ncNext.cn) {
    if (LoadFdb (ncNext.mh, &fdbLocal)) {
	sprintf (buf,"fhHelp            %u\r\n",    fdbLocal.fhHelp);
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"ncInit            %08lx\r\n", fdbLocal.ncInit);
	outtext (buf, BRIGHTWHITE);
	for (i=0; i<HS_count; i++) {
	    sprintf (buf,"rgmhSections[%18s]    %04x\r\n", szHS[i], fdbLocal.rgmhSections[i]);
	    outtext (buf, BRIGHTWHITE);
	    }
	sprintf (buf,"ftype             %02x\r\n",  fdbLocal.ftype );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"fname             %14s\r\n",  fdbLocal.fname );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"foff              %08lx\r\n", fdbLocal.foff  );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"ncLink            %08lx\r\n", fdbLocal.ncLink);
	outtext (buf, BRIGHTWHITE);

	sprintf (buf,"hdr.wMagic        %04x\r\n",  fdbLocal.hdr.wMagic     );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.wVersion      %04x\r\n",  fdbLocal.hdr.wVersion   );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.wFlags        %04x\r\n",  fdbLocal.hdr.wFlags     );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.appChar       %04x\r\n",  fdbLocal.hdr.appChar    );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.cTopics       %04x\r\n",  fdbLocal.hdr.cTopics    );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.cContexts     %04x\r\n",  fdbLocal.hdr.cContexts  );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.cbWidth       %04x\r\n",  fdbLocal.hdr.cbWidth    );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.cPreDef       %04x\r\n",  fdbLocal.hdr.cPreDef    );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.fname         %s\r\n",    fdbLocal.hdr.fname	    );
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.reserved[0]   %04x\r\n",  fdbLocal.hdr.reserved[0]);
	outtext (buf, BRIGHTWHITE);
	sprintf (buf,"hdr.reserved[1]   %04x\r\n",  fdbLocal.hdr.reserved[1]);

	for (i=0; i<HS_count; i++) {
	    sprintf (buf,"hdr.tbPos[%18s]       %08lx\r\n", szHS[i], fdbLocal.hdr.tbPos[i]);
	    outtext (buf, BRIGHTWHITE);
	    }
	outtext ("----- ----- -----\r\n", LIGHTGREEN);
/*
 * Topic Index
 * This is just a table of (long) offsets within the current file. We just
 * report the values, and also calculate the size of each entry by looking
 * at the position of the entry following.
 */
        fpT = HelpLock (LoadPortion( HS_INDEX ,ncNext.mh));
	if (fpT) {
	    outtext ("Topic Index:\r\n", LIGHTRED);
		for (i = 0; i < (int)fdbLocal.hdr.cTopics; i++) {
		sprintf (buf, "  %2d: %08lx, %ld bytes\r\n", i, ((long far *)fpT)[i], ((long far *)fpT)[i+1]-((long far *)fpT)[i]);
		outtext (buf, BRIGHTWHITE);
		}
	    outtext ("----- ----- -----\r\n", LIGHTGREEN);
	    }
/*
 * context strings
 * This is just a table of null terminated strings, in no particular order.
 * We just list them out sequentially.
 */
        fpT = HelpLock (LoadPortion( HS_CONTEXTSTRINGS ,ncNext.mh));
	if (fpT) {
	    outtext ("Context strings:\r\n", LIGHTRED);
		for (i=0; i<(int)fdbLocal.hdr.cContexts; i++) {

		sprintf (buf, "  %03d: ", i);
                // rjsa hfstrcpy ((char far *)buf+7, fpT);
                strcpy ((char far *)buf+7, fpT);
		strcat (buf, "\r\n");
		outtext (buf, BRIGHTWHITE);

                // rjsa fpT += hfstrlen(fpT) +1;
                fpT += strlen(fpT) +1;
		}
	    outtext ("----- ----- -----\r\n", LIGHTGREEN);
	    }
/*
 * Context Map
 * This is the mapping of context strings to actual topic numbers. The context
 * strings map one to one to the entries in this table, which in turn contains
 * indexes into the topic index at the head of the file. We just dump this
 * table sequentially.
 */
        fpT = HelpLock (LoadPortion( HS_CONTEXTMAP ,ncNext.mh));
	if (fpT) {
	    outtext ("Context map:\r\n", LIGHTRED);
	    outtext ("  Ctx  Topic\r\n",BRIGHTWHITE);
	    outtext ("  ---  -----\r\n",BRIGHTWHITE);
		for (i=0; i<(int)fdbLocal.hdr.cContexts; i++) {
		sprintf (buf, "  %03d: %04d\r\n", i, ((ushort far *)fpT)[i]);
		outtext (buf, BRIGHTWHITE);
		}
	    outtext ("----- ----- -----\r\n", LIGHTGREEN);
	    }
/*
 * keyword table
 * This is a table of byte-prefixed strings, which we output in order,
 * synthesizing the tokens that they would be in the text as well.
 */
        fpT = HelpLock (LoadPortion( HS_KEYPHRASE, ncNext.mh));
	if (fpT) {
	    cbKeyPhrase = 0;
	    for (i=HS_HUFFTREE; i<HS_count; i++)
		if (fdbLocal.hdr.tbPos[i]) {
		    cbKeyPhrase = (ushort)(fdbLocal.hdr.tbPos[i] - fdbLocal.hdr.tbPos[HS_KEYPHRASE]);
		    break;
		    }

	    outtext ("Keyphrase Table:\r\n", LIGHTRED);
	    outtext ("  Token Phrase\r\n",BRIGHTWHITE);
	    outtext ("  ----- ------\r\n",BRIGHTWHITE);
	    i = 0;
            fpT += 1024 * sizeof (PVOID);
	    fpW = (ushort far *)(fpT + cbKeyPhrase);
	    while (fpT < (uchar far *)fpW) {
		sprintf (buf, "  %04x: ", i+(C_KEYPHRASE0 << 8));
		fpT = phrasecopy (buf+8, fpT);
		strcat (buf, "\r\n");
		outtext (buf, BRIGHTWHITE);
		i++;
		}
	    outtext ("----- ----- -----\r\n", LIGHTGREEN);
	    }
/*
 * huffman table
 * here we try to get fancy and output some information about the table format
 */
        fpW = HelpLock (LoadPortion( HS_HUFFTREE, ncNext.mh));
	if (fpW) {
	    outtext ("Huffman Tree:\r\n", LIGHTRED);
	    i = 0;
	    while (*fpW) {
		sprintf (buf, "  0x%03x: 0x%04x, %s\r\n", i++, *fpW, *fpW & 0x8000 ? "Leaf" : "Node");
		fpW++;
		outtext (buf, BRIGHTWHITE);
		}
	    }
	outtext ("===== ===== =====\r\n", YELLOW);
	ncNext = fdbLocal.ncLink;
	}
    else {
	sprintf(buf, "Cannot load fdb for %08lx\r\n",ncCur);
	outtext (buf, LIGHTRED);
	return;
	}
    }
/* end dumpCmd */}

/*** dumpfileCmd - process dump command
*
*  Dumps the contents of the current help file
*
* NOTE:
*  This function uses all sorts of "internal" knowledge and calls to
*  do it's job.
*
* Input:
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near dumpfileCmd (char *fname) {
char	buf[BUFSIZ];
int  cbKeyPhrase;
fdb	fdbLocal;			/* local copy of fdb to use	*/
uchar far *fpT;
ushort far *fpW;
int     i;
nc	ncNext; 			/* nc init of appended file	*/
//uchar	uc;

FILE* fh = fopen(fname, "w");
if (!fh) {
	return;
}
ncNext = ncCur;
while (ncNext.cn) {
    if (LoadFdb (ncNext.mh, &fdbLocal)) {
	sprintf (buf,"fhHelp            %u\r\n",	fdbLocal.fhHelp);
	fprintf( fh, buf );
	sprintf (buf,"ncInit            %08lx\r\n", fdbLocal.ncInit);
	fprintf( fh, buf );
	for (i=0; i<HS_count; i++) {
	    sprintf (buf,"rgmhSections[%18s]    %04x\r\n", szHS[i], fdbLocal.rgmhSections[i]);
		fprintf( fh, buf );
	    }
	sprintf (buf,"ftype             %02x\r\n",  fdbLocal.ftype );
	fprintf( fh, buf );
	sprintf (buf,"fname             %14s\r\n",  fdbLocal.fname );
	fprintf( fh, buf );
	fprintf( fh, buf );
	sprintf (buf,"foff              %08lx\r\n", fdbLocal.foff  );
	fprintf( fh, buf );
	sprintf (buf,"ncLink            %08lx\r\n", fdbLocal.ncLink);
	fprintf( fh, buf );

	sprintf (buf,"hdr.wMagic        %04x\r\n",  fdbLocal.hdr.wMagic     );
	fprintf( fh, buf );
	sprintf (buf,"hdr.wVersion      %04x\r\n",  fdbLocal.hdr.wVersion   );
	fprintf( fh, buf );
	sprintf (buf,"hdr.wFlags        %04x\r\n",  fdbLocal.hdr.wFlags     );
	fprintf( fh, buf );
	sprintf (buf,"hdr.appChar       %04x\r\n",  fdbLocal.hdr.appChar    );
	fprintf( fh, buf );
	sprintf (buf,"hdr.cTopics       %04x\r\n",  fdbLocal.hdr.cTopics    );
	fprintf( fh, buf );
	sprintf (buf,"hdr.cContexts     %04x\r\n",  fdbLocal.hdr.cContexts  );
	fprintf( fh, buf );
	sprintf (buf,"hdr.cbWidth       %04x\r\n",  fdbLocal.hdr.cbWidth    );
	fprintf( fh, buf );
	sprintf (buf,"hdr.cPreDef       %04x\r\n",  fdbLocal.hdr.cPreDef    );
	fprintf( fh, buf );
	sprintf (buf,"hdr.fname         %s\r\n",    fdbLocal.hdr.fname	    );
	fprintf( fh, buf );
	sprintf (buf,"hdr.reserved[0]   %04x\r\n",  fdbLocal.hdr.reserved[0]);
	fprintf( fh, buf );
	sprintf (buf,"hdr.reserved[1]   %04x\r\n",  fdbLocal.hdr.reserved[1]);

	for (i=0; i<HS_count; i++) {
	    sprintf (buf,"hdr.tbPos[%18s]       %08lx\r\n", szHS[i], fdbLocal.hdr.tbPos[i]);
		fprintf( fh, buf );
	    }
	fprintf( fh,"----- ----- -----\r\n"  );
/*
 * Topic Index
 * This is just a table of (long) offsets within the current file. We just
 * report the values, and also calculate the size of each entry by looking
 * at the position of the entry following.
 */
        fpT = HelpLock (LoadPortion( HS_INDEX ,ncNext.mh));
	if (fpT) {
		fprintf( fh,"Topic Index:\r\n"	);
		for (i = 0; i < (int)fdbLocal.hdr.cTopics; i++) {
		sprintf (buf, "  %2d: %08lx, %ld bytes\r\n", i, ((long far *)fpT)[i], ((long far *)fpT)[i+1]-((long far *)fpT)[i]);
		fprintf( fh, buf );
		}
		fprintf( fh,"----- ----- -----\r\n"  );
	    }
/*
 * context strings
 * This is just a table of null terminated strings, in no particular order.
 * We just list them out sequentially.
 */
        fpT = HelpLock (LoadPortion( HS_CONTEXTSTRINGS ,ncNext.mh));
	if (fpT) {
	fprintf( fh, "Context strings:\r\n" );
		for (i=0; i<(int)fdbLocal.hdr.cContexts; i++) {

		sprintf (buf, "  %03d: ", i);
                // rjsa hfstrcpy ((char far *)buf+7, fpT);
                strcpy ((char far *)buf+7, fpT);
		strcat (buf, "\r\n");
		fprintf( fh, buf );

                // rjsa fpT += hfstrlen(fpT) +1;
                fpT += strlen(fpT) +1;
		}
		fprintf( fh,"----- ----- -----\r\n"  );
	    }
/*
 * Context Map
 * This is the mapping of context strings to actual topic numbers. The context
 * strings map one to one to the entries in this table, which in turn contains
 * indexes into the topic index at the head of the file. We just dump this
 * table sequentially.
 */
        fpT = HelpLock (LoadPortion( HS_CONTEXTMAP ,ncNext.mh));
	if (fpT) {
		fprintf( fh, "Context map:\r\n" );
		fprintf( fh, "  Ctx  Topic\r\n" );
		fprintf( fh, "  ---  -----\r\n" );
		for (i=0; i<(int)fdbLocal.hdr.cContexts; i++) {
		sprintf (buf, "  %03d: %04d\r\n", i, ((ushort far *)fpT)[i]);
		fprintf( fh, buf );
		}
		fprintf( fh, "----- ----- -----\r\n" );
	    }
/*
 * keyword table
 * This is a table of byte-prefixed strings, which we output in order,
 * synthesizing the tokens that they would be in the text as well.
 */
        fpT = HelpLock (LoadPortion( HS_KEYPHRASE, ncNext.mh));
	if (fpT) {
	    cbKeyPhrase = 0;
	    for (i=HS_HUFFTREE; i<HS_count; i++)
		if (fdbLocal.hdr.tbPos[i]) {
		    cbKeyPhrase = (ushort)(fdbLocal.hdr.tbPos[i] - fdbLocal.hdr.tbPos[HS_KEYPHRASE]);
		    break;
		    }

		fprintf( fh, "Keyphrase Table:\r\n" );
		fprintf( fh, "  Token Phrase\r\n" );
		fprintf( fh, "  ----- ------\r\n" );
	    i = 0;
            fpT += 1024 * sizeof (PVOID);
	    fpW = (ushort far *)(fpT + cbKeyPhrase);
	    while (fpT < (uchar far *)fpW) {
		sprintf (buf, "  %04x: ", i+(C_KEYPHRASE0 << 8));
		fpT = phrasecopy (buf+8, fpT);
		strcat (buf, "\r\n");
		fprintf( fh, buf );
		i++;
		}
		fprintf( fh,"----- ----- -----\r\n"  );
	    }
/*
 * huffman table
 * here we try to get fancy and output some information about the table format
 */
        fpW = HelpLock (LoadPortion( HS_HUFFTREE, ncNext.mh));
	if (fpW) {
		fprintf( fh, "Huffman Tree:\r\n" );
	    i = 0;
	    while (*fpW) {
		sprintf (buf, "  0x%03x: 0x%04x, %s\r\n", i++, *fpW, *fpW & 0x8000 ? "Leaf" : "Node");
		fpW++;
		fprintf( fh, buf );
		}
	    }
	fprintf( fh, "===== ===== =====\r\n" );
	ncNext = fdbLocal.ncLink;
	}
    else {
	sprintf(buf, "Cannot load fdb for %08lx\r\n",ncCur);
	fprintf( fh, buf );
	fclose(fh);
	return;
	}
    }
/* end dumpCmd */}


/*** fileCmd - process file command
*
*  Opens the help file specified.
*
* Input:
*  pName	= name of help file to be added
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near fileCmd (
char	*pName
) {
char	buf[BUFSIZ];
int     i;
nc	ncInit;

sprintf (buf,"Opening %s...\r\n",pName);
outtext (buf, BRIGHTWHITE);
/*
 * search file table for available slot
 */
for (i=0; i<MAXFILES; i++)
    if (!ncTbl[i].cn)
	break;
if (i >= MAXFILES) {
    sprintf(buf, "Cannot open %s: htest's open file limit exceeded\r\n",pName);
    outtext (buf, LIGHTRED);
    return;
    }

iNcCur = i;

ncInit = HelpOpen(pName);

for (i=0; i<MAXFILES; i++)
    if ((ncTbl[i].mh == ncInit.mh) && (ncTbl[i].cn == ncInit.cn)) {
	iNcCur = i;
	sprintf (buf, "File #%d; Initial Context: 0x%04lx (file already open)\r\n",iNcCur,ncInit);
	outtext (buf, BRIGHTWHITE);
	return;
	}

if (ISERROR(ncInit)) {
    sprintf(buf, "Cannot open %s: 0x%04lx, %s\r\n",pName,ncInit, errTbl[ncInit.cn]);
    outtext (buf, LIGHTRED);
    return;
    }
/*
 * output initial context, and the available memory
 */
ncCur = ncTbl[iNcCur] = ncInit;
sprintf (buf, "File #%d; Initial Context: 0x%04lx\r\n",iNcCur,ncInit.cn);
outtext (buf, BRIGHTWHITE);

lookupCmd(NULL, 0);
/* end fileCmd */}

/*** helpCmd - display help on commands
*
* Input:
*  none
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near helpCmd () {

outtext ("HTEST - Help Engine Test Harness\r\n",			      BRIGHTWHITE);
outtext ("\r\n",							      BRIGHTWHITE);
outtext ("Comands:\r\n",						      BRIGHTWHITE);
outtext ("\r\n",							      BRIGHTWHITE);
outtext ("ctrl on/off - turn on/off display of control lines\r\n",	BRIGHTWHITE);
outtext ("disp      - display first screen of most recently read topic\r\n",  BRIGHTWHITE);
outtext ("down      - move ahead one line in topic and display\r\n",	      BRIGHTWHITE);
outtext ("dump      - dump file info (very large)\r\n", 		      BRIGHTWHITE);
outtext ("exit      - exit htest\r\n",					      BRIGHTWHITE);
outtext ("file x    - open new help file, or make help file current\r\n",     BRIGHTWHITE);
outtext ("help      - display this screen\r\n", 			      BRIGHTWHITE);
outtext ("look x    - loop up context string & fetch topic\r\n",	      BRIGHTWHITE);
outtext ("next      - fetch next physical topic\r\n",			      BRIGHTWHITE);
outtext ("prev      - fetch previous physical topic\r\n",		      BRIGHTWHITE);
outtext ("up        - move back one line in topic and display\r\n",	      BRIGHTWHITE);
outtext ("xref x    - display all xrefs in current topic, or look up #x\r\n", BRIGHTWHITE);
outtext ("+         - move & redisplay one page down\r\n",		      BRIGHTWHITE);
outtext ("-         - move & redisplay one page up\r\n",		      BRIGHTWHITE);
/* end helpCmd */}

/*** lookupCmd - process file command
*
*  Looks up the specified string in the current helpfile, or the next help
*  topic.
*
* Input:
*  pString	= help string to look up
*  dir		= direction: 0= look up string, 1=get next, -1= get previous
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near lookupCmd (
char	*pString,
int     dir
) {
char	    buf[BUFSIZ];
unsigned    cbCompressed;
unsigned    cbUncompressed;
char far    *pCompressed;
/*
 * Start with the simple look up of the conetxt to get an nc. Report on
 * failure.
 */
if (pString)
    ncCur = HelpNc(pString,ncTbl[iNcCur]);
else if (dir>0) {
    if (!ncCur.cn)
	ncCur = ncTbl[iNcCur];
    else
        ncCur = HelpNcNext(ncCur);
    }
else if (dir<0) {
    if (!ncCur.cn)
	ncCur = ncTbl[iNcCur];
    else if (ncCur.cn != ncTbl[iNcCur].cn)
        ncCur = HelpNcPrev(ncCur);
    }
else
    ncCur = ncTbl[iNcCur];

if (!ncCur.cn) {
    outtext ("Lookup Failed: HelpNc/HelpNcNext/HelpNcPrev returned 0", LIGHTRED);
    return;
    }
/*
 * It exists. Indicate what file we're looking in, what we found, and the
 * nc that was returned
 */
sprintf (buf, "File #%d; Looking up:%s\r\n",iNcCur,
	      pString ? (*pString ? pString : "local context")
		      : (dir ? ((dir>0) ? "**NEXT**" : "**PREV**")
			     : "current"));
outtext (buf, BRIGHTWHITE);
sprintf (buf, "nc returned = %08lx\r\n",ncCur.cn);
outtext (buf, BRIGHTWHITE);
/*
 * Free up memory for previously current topic
 */
if (mhTopicCur)
    free(mhTopicCur);
/*
 * Get the compressed memory size required, and report it. Alloc it.
 */
cbCompressed = HelpNcCb(ncCur);
sprintf (buf, "size of compressed topic = %d\r\n",cbCompressed);
outtext (buf, BRIGHTWHITE);
pCompressed = malloc(cbCompressed);
/*
 * read in the compressed topic, getting the size required for the
 * uncompressed results. Report that, and allocate it.
 */
cbUncompressed = HelpLook(ncCur,pCompressed);
sprintf (buf, "size of UNcompressed topic = %d\r\n",cbUncompressed);
outtext (buf, BRIGHTWHITE);
mhTopicCur = malloc(cbUncompressed);
//pTopicCur = MAKEP (mhTopicCur, 0);
pTopicCur  = mhTopicCur;
/*
 * Decompress the topic.
 */
HelpDecomp(pCompressed,pTopicCur,ncCur);
outtext ("Decompressed\r\n", BRIGHTWHITE);
/*
 * exercise SzContext and cLines routines, reporting results
 */
HelpSzContext(buf,ncCur);
strcat (buf, "\r\n");
outtext (buf, BRIGHTWHITE);
sprintf(buf,"%d lines\r\n", HelpcLines(pTopicCur));
outtext (buf, BRIGHTWHITE);
/*
 * Report the amount of available memory at this point, and then free up the
 * compressed text
 */
free(pCompressed);

/* end lookupCmd */}

/*** xrefCmd - process xref command
*
*  Display or execute cross reference
*
* Input:
*  pText    = pointer to ascii text which, if a non-zero number, indicates the
*	      xref to execute. If zero, display all
*
* Output:
*  Returns nothing
*
*************************************************************************/
void pascal near xrefCmd (
char	*pText
) {
hotspot hsCur;				/* hot spot definition		*/
int     i;                              /* working counter              */
int     iReq;                           /* request value                */
char	*pT;				/* temp pointer 		*/

iReq = atoi (pText);
hsCur.line = hsCur.col = 1;
i = 1;
while (HelpHlNext(0,pTopicCur,&hsCur)) {
/*
 * if not explicit request, then list as much as we can
 */
    if (!iReq) {
	sprintf (buf, "Xref [%d] @ line: %05d columns %02d to %02d = "
		    ,i
		    ,hsCur.line
		    ,hsCur.col
		    ,hsCur.ecol);
	pT = buf + strlen(buf);
	if (*hsCur.pXref)
	    while (*pT++ = *hsCur.pXref++);
	else
	    sprintf(pT, "Local >> topic # 0x%04x ",*(ushort far *)(hsCur.pXref+1));
	strcat (buf, "\r\n");
	outtext (buf, LIGHTGREEN);
	}
    else if (i == iReq) {
	pT = buf;
	if (*hsCur.pXref)
	    while (*pT++ = *hsCur.pXref++);
	else {
	    *pT++ = *hsCur.pXref++;
	    *pT++ = *hsCur.pXref++;
	    *pT++ = *hsCur.pXref++;
	    }
	lookupCmd (buf, 0);
	return;
	}
    ++i;
	hsCur.col = hsCur.ecol+(ushort)1;
    }
/* end xrefCmd */}

/*** outtext - output text with specific colors
*
*  sets the forground color and location as appropriate, and displays the
*  desired text. Checks for redirection, and if redirected, just outputs the
*  text to stdout.
*
* Input:
*  ptext	= pointer to text to output
*  color	= color to use
*
* Output:
*  Returns
*
*************************************************************************/
void pascal near outtext (
char	*pText,
BYTE     color
) {
outtextat (pText, curline++, 0, color);
if (curline >= lastline) {
    if (isatty(_fileno(stdout))
	&& !fBoth) {

	outtextat ("More...", lastline, 0, BRIGHTWHITE);
        // rjsa VioSetCurPos (lastline, 8, 0);
#if defined (OS2)
        consoleSetCursor(lastline,8);
#else
        consoleSetCursor(Scr,lastline,8);
#endif
	gets (buf);
	}
    curline = 0;
    cls ();
    }

/* end outtext */}

/*** outtextat - put text with specific colors at a specific place
*
*  sets the forground color and location as appropriate, and displays the
*  desired text. Checks for redirection, and if redirected, just outputs the
*  text to stdout.
*
* Input:
*  ptext	= pointer to text to output
*  col		= column to put into
*  color	= color to use
*
* Output:
*  Returns
*
*************************************************************************/
void pascal near outtextat (
char	*pText,
int     line,
int     col,
BYTE     color
) {
char    *pEol;                          /* ptr to nl, if present        */
int     len;

color |= (ColorByte & 0xf0);
if ((isatty(_fileno(stdout)) || fBoth) && (line <= lastline)) {
    len = strlen(pText);
    if (pEol = strchr (pText, '\r'))
	*pEol = 0;
    // rjsa VioWrtCharStrAtt (pText, strlen(pText), line, col, (PBYTE)&color, 0);
	WrtCharStrAtt (pText, strlen(pText), line, col, (PBYTE)&color);

    if (pEol)
	*pEol = '\r';
    }
if (!isatty(_fileno(stdout)) || fBoth)
    printf ("%s",pText);
/* end outtextat */}

/*** assertDos - asserts that a dos call returned a zero
*
*  Just prints the number passed it if non-zero, and quits
*
* Input:
*  Return code from a dos call
*
* Output:
*  Returns only if zero passed in
*
*************************************************************************/
void pascal near assertDos (
USHORT  rv,
CHAR *  pFile,
USHORT  LineNo
) {
if (rv) {
    printf ("assertDos: %u (0x%04x) File %s, line %u\n", rv, rv, pFile, LineNo);
    exit (1);
    }
/* end assertDos*/}

/*** cls - clear screen
*
*  Clear screen to current backround color
*
* Input:
*  none
*
* Output:
*  Returns screen clear
*
*************************************************************************/
void pascal near cls () {
curline = 0;
// rjsa VioScrollUp (0, 0, 0xffff, 0xffff, 0xffff, cell, 0);
consoleSetAttribute( Scr, 0x1f );
consoleClearScreen(Scr, TRUE);
/* end cls */}

/*** phrasecopy - copy a keyword phrase from the table
*
*  Copies a byte-length-prefixed string from far memory to a null terminated
*  string in near memory.
*
* Input:
*  dst		- near pointer to destination
*  src		- far pointer to source
*
* Output:
*  Returns far pointer to byte following source string
*
*************************************************************************/
uchar far * pascal near phrasecopy (
uchar	*dst,
uchar far *src
) {
register int    i;

if (i = (int)*src++)
    while (i--)
	*dst++ = *src++;
*dst = 0;
return src;
/* end phrasecopy */}



void far * pascal HelpLock(mhCur)
mh	mhCur;
{
//return MAKEP(mhCur,0);
return mhCur;
}

void pascal HelpUnlock(mhCur)
mh	mhCur;
{
	mhCur;
}

void pascal HelpDealloc(mhCur)
mh	mhCur;
{
if (mhCur)
    free(mhCur);
}




USHORT WrtCellStr (PBYTE buf, int cb, int row, int col) {
    int cl = col;
    //consoleSetCursor(Scr,row,col);
    while (cb) {
        UCHAR   c;
        UCHAR   attr;

        c = *buf++;
        attr = *buf++;

        //consoleSetAttribute(Scr,attr);
        //consoleWrite(Scr,&c,1);

        consoleWriteLine( Scr, &c, 1, row, cl, attr, FALSE );
        cl++;

		cb -= 2;
	}
    consoleShowScreen(Scr);
    return 0;
}


USHORT	WrtLineAttr ( PBYTE 	pText,
					  lineattr	*rgAttr,
					  int		cb,
					  int		row,
					  int		col
					  ) {

	lineattr *Attr	= rgAttr;
	char	 *p 	= pText;
	int 	 l = cb;
	int 	 len;

    consoleSetCursor(Scr, row, col );

	while (cb > 0) {

		if ( Attr->cb == 0xFFFF || Attr->attr == 0xFFFF ) {
			len = cb;
		} else {
			len = Attr->cb;
		}

		outtextat (p, row, col, mpAttr[Attr->attr] );
		col += len;
		p	+= len;
		cb	-= len;
		Attr++;

	}
	return (USHORT)l;
}



USHORT  WrtCharStrAtt (PBYTE pText, int cb, int row, int col, PBYTE pcolor) {
    //consoleSetCursor(Scr,row,col);
    //consoleSetAttribute(Scr,*pcolor);
    //consoleWrite( Scr,pText, cb );
    consoleWriteLine( Scr, pText, cb, row, col, *pcolor, FALSE );
    consoleShowScreen(Scr);
    return 0;
}

/**********************************************************************
 *
 *  LoadTheDll
 *
 *      Loads the help engine dll (mshelp.dll) and initializes the
 *      pointers to the dll's entry points.
 *
 **********************************************************************/

void
LoadTheDll (
    void) {


#if defined (OS2)
    USHORT  rc;
    CHAR    szFullName[256];
    CHAR    szErrorName[256];
    USHORT  i;


    strcpy(szFullName, HELPDLL_BASE);
    strcpy(szErrorName, HELPDLL_NAME);

    ASSERTDOS(rc = DosLoadModule(szErrorName,
                       256,
                       szFullName,
                       &hModule));


    for (i=0; i<LASTENTRYPOINT; i++) {
        ASSERTDOS (rc = DosQueryProcAddr(hModule,
                                         0L,
                                         szEntryName[i],
                                         (PFN*)&(pEntry[i])));
    }
#else

#if defined (HELP_HACK)

	//pEntry[0] =	(PHF)HelpcLines;
	//pEntry[1] =	(PHF)HelpClose;
	//pEntry[2] =	(PHF)HelpCtl;
	//pEntry[3] =	(PHF)HelpDecomp;
	//pEntry[4] =	(PHF)HelpGetCells;
	//pEntry[5] =	(PHF)HelpGetInfo;
	//pEntry[6] =	(PHF)HelpGetLine;
	//pEntry[7] =	(PHF)HelpGetLineAttr;
	//pEntry[8] =	(PHF)HelpHlNext;
	//pEntry[9] =	(PHF)HelpLook;
	//pEntry[10] =	(PHF)HelpNc;
	//pEntry[11] =	(PHF)HelpNcBack;
	//pEntry[12] =	(PHF)HelpNcCb;
	//pEntry[13] =	(PHF)HelpNcCmp;
	//pEntry[14] =	(PHF)HelpNcNext;
	//pEntry[15] =	(PHF)HelpNcPrev;
	//pEntry[16] =	(PHF)HelpNcRecord;
	//pEntry[17] =	(PHF)HelpNcUniq;
	//pEntry[18] =	(PHF)HelpOpen;
	//pEntry[19] =	(PHF)HelpShrink;
	//pEntry[20] =	(PHF)HelpSzContext;
	//pEntry[21] =	(PHF)HelpXRef;
	//pEntry[22] =	(PHF)LoadFdb;
	//pEntry[23] =	(PHF)LoadPortion;



#else
    USHORT  i;
    hModule = LoadLibrary(HELPDLL_NAME);
    for (i=0; i<LASTENTRYPOINT; i++) {
        pEntry[i] = (PHF)GetProcAddress(hModule, (LPSTR)szEntryName[i]);
	}
#endif

#endif
}