Initial import of xtrkcad version 1:4.0.2-2

1 files changed, 2178 insertions, 0 deletions

diff --git a/app/help/prochelp.c b/app/help/prochelp.c
new file mode 100644
index 0000000..d1dd256
--- /dev/null
+++ b/app/help/prochelp.c
@@ -0,0 +1,2178 @@
+
+/*  XTrkCad - Model Railroad CAD
+ *  Copyright (C) 2005 Dave Bullis
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#if defined (__sun) && defined (__SVR4)
+#include <ctype.h>
+#endif
+#include "readpng.h"
+
+#define PROGNAME	"prochelp"
+
+char line[1024];
+int lineNum;
+FILE * ifile;
+FILE * ofile;
+int wordwrap = 1;
+int listLevel = -1;
+int listType[10];
+int listCount[10];
+int lineWidth = 80;
+int listWidth = 80;
+int verbose = 0;
+int toc = 0;
+char * dirs[10] = { "." };
+char ** dirList = &dirs[1];
+int FontSize = 22;
+double MarginTop = -1;
+double MarginBottom = -1;
+double MarginLeft = -1;
+double MarginRight = -1;
+double MarginGutter = -1;
+
+#define LISTNONE	(0)
+#define LISTBULLET	(1)
+#define LISTDASH	(2)
+#define LISTNUMBER	(3)
+
+int USE_BMP = 0;
+
+
+typedef struct {
+	void (*start)( char *, char * );
+	void (*finish)( void );
+	void (*newParagraph)( void );
+	void (*startLine)( int );
+	void (*doBold)( char * );
+	void (*doItalic)( char * );
+	void (*doXref)( char *, char *, char * );
+	void (*doPicture)( char *, int );
+	void (*endLine)( void );
+	void (*putChar)( char );
+	void (*doSection)( char, char *, char *, char *, char *, int );
+	void (*doHeader)( char * );
+	void (*doStartDisplay)( void );
+	void (*doEndDisplay)( void );
+	void (*doThread)( char * );
+	void (*doListStart)( void );
+	void (*doListItem)( void );
+	void (*doListEnd)( void );
+	void (*page)( void );
+
+	} dispatchTable;
+dispatchTable *curMode;
+
+struct tocList_t;
+typedef struct tocList_t * tocList_p;
+typedef struct tocList_t {
+	tocList_p next;
+	char section;
+	long num;
+	char * title;
+	} tocList_t;
+tocList_p tocHead = NULL;
+tocList_p tocTail = NULL;
+long tocNum = 37061946;
+	
+
+void no_op( void )
+{
+}
+FILE * openFile( char * filename )
+{
+	FILE * f;
+	char tmp[1024];
+	char ** d;
+
+	for ( d=dirs; *d; d++ ) {
+		sprintf( tmp, "%s/%s", *d, filename );
+		f = fopen( tmp, "r" );
+		if (f)
+			return f;
+	}
+	fprintf( stderr, "Can't open %s\n", filename );
+	exit(1);
+}
+
+void normalStart( char * inName, char * outName )
+{
+	ifile = openFile( inName );
+	if ( strcmp( outName, "-" ) == 0 ) {
+		ofile = stdout;
+	} else {
+		ofile = fopen( outName, "w" );
+		if (ofile == NULL) {
+			perror( outName );
+			exit( 1 );
+		}
+	}
+}
+void normalFinish( void )
+{
+	if (ofile)
+		fclose( ofile );
+}
+void process( FILE * );
+
+/******************************************************************************
+ *
+ *	COMMON RTF
+ *
+ *****************************************************************************/
+
+int rtfNeedPar = FALSE;
+int rtfNeedGap = FALSE;
+int rtfNeedFI0 = FALSE;
+int rtfGapHeight = -1;
+int rtfBigGap = 60;
+
+void rtfFlushParagraph( void )
+{
+	if ( rtfNeedPar ) {
+		if ( rtfNeedGap==TRUE && rtfGapHeight!=rtfBigGap ) {
+			fprintf( ofile, "\\sb%d", rtfBigGap );
+			rtfGapHeight = rtfBigGap;
+		}
+		if ( rtfNeedGap==FALSE && rtfGapHeight!=0 ) {
+			fprintf( ofile, "\\sb0" );
+			rtfGapHeight = 0;
+		}
+		fprintf( ofile, "\\par\n" );
+		if ( rtfNeedFI0 )
+			fprintf( ofile, "\\fi0\n" );
+		rtfNeedPar = FALSE;
+		rtfNeedGap = FALSE;
+		rtfNeedFI0 = FALSE;
+	}
+}
+
+
+void rtfPutChar( char ch )
+{
+	if ( ((ch) & 0x80) ){
+		fprintf( ofile, "\\'%2.2X", (unsigned char)ch );
+	} else if ( (ch) == '\\' ){
+		fprintf( ofile, "\\\\" );
+	} else {
+		fputc( ch, ofile );
+	}
+	rtfNeedPar = TRUE;
+}
+void rtfPutString( char * cp )
+{
+	while (*cp) {
+		rtfPutChar( *cp++ );
+	}
+}
+void rtfNewParagraph( void )
+{
+	if ( wordwrap ) {
+		rtfFlushParagraph();
+#ifdef LATER
+		if ( listLevel < 0 ) {
+			rtfFlushParagraph();
+			rtfNeedGap = 1;
+		} else {
+			if ( rtfNeedPar ) {
+				fprintf( ofile, "\\line\r\n" );
+				rtfNeedPar = FALSE;
+			}
+		}
+#endif
+	}
+}
+void rtfStartLine( int lastBlank )
+{
+	if ( !wordwrap ) {
+		fprintf( ofile, "\\tab\r\n" );
+	} else if ( lastBlank ) {
+		rtfFlushParagraph();
+	}
+}
+void rtfBold( char * name )
+{
+	fprintf( ofile, "{\\b " );
+	rtfPutString( name );
+	fprintf( ofile, "}" );
+}
+void rtfItalic( char * name )
+{
+	fprintf( ofile, "{\\i " );
+	rtfPutString( name );
+	fprintf( ofile, "}" );
+}
+void rtfEndLine( void )
+{
+	if ( !wordwrap ) {
+		rtfNeedPar = TRUE;
+		rtfFlushParagraph();
+	}
+}
+void rtfStartDisplay( void )
+{
+	rtfFlushParagraph();
+}
+void rtfListStart( void )
+{
+	rtfFlushParagraph();
+	if (listLevel>0) {
+		fprintf( ofile, "\\pard" );
+/*
+		if ( rtfNeedGap ) {
+			fprintf( ofile, "\\sb%d", rtfBigGap );
+			rtfGapHeight = rtfBigGap;
+			rtfNeedGap = FALSE;
+		}
+*/
+		rtfGapHeight = -1;
+	}
+	fprintf( ofile, "\\tx360\\li%d\r\n", 360*(listLevel+1) );
+}
+void rtfListItem( void )
+{
+	/*if (listLevel == 0 || listCount[listLevel] > 1)*/
+	rtfFlushParagraph();
+	fprintf( ofile, "\\fi-360 " );
+	rtfNeedFI0 = TRUE;
+	switch (listType[listLevel]) {
+	case LISTNONE:
+#ifdef LATER
+		if ( listCount[listLevel] > 0 )
+			fprintf( ofile, "\\fi-360 " );
+		rtfNeedFI0 = TRUE;
+#endif
+		break;
+	case LISTBULLET:
+		fprintf( ofile, "{\\f1\\'B7}\\tab" );
+		break;
+	case LISTDASH:
+		fprintf( ofile, "{\\b -}\\tab" );
+		break;
+	case LISTNUMBER:
+		fprintf( ofile, "{\\b %d}\\tab", listCount[listLevel] );
+		break;
+	}
+	fprintf( ofile, "\r\n" );
+}
+void rtfListEnd( void )
+{
+	if (listLevel == -1)
+		fprintf( ofile, "\\par\\pard\r\n" );
+	else
+		fprintf( ofile, "\\par\\pard\\tx360\\li%d\\fi-360\r\n", 360*(listLevel+1) );
+	rtfNeedPar = FALSE;
+	rtfGapHeight = -1;
+	rtfNeedGap = FALSE;
+}
+
+void rtfPage( void )
+{
+	rtfFlushParagraph();
+	fprintf( ofile, "\\page\r\n" );
+}
+
+/******************************************************************************
+ *
+ *	MSW-HELP
+ *
+ *****************************************************************************/
+
+int pageCnt = 0;
+
+struct {
+	char * name;
+	int count;
+	} threads[100];
+int threadCnt = 0;
+
+
+char * remap_minus( char * cp )
+{
+    char * cp0 = cp;
+    for ( ; *cp; cp++ )
+	if ( *cp == '-' )
+	    *cp = '_';
+    return cp0;
+}
+
+int lookupThread( char * name )
+{
+	int inx;
+	if (!name) {
+		fprintf( stderr, "%d: NULL thread string\n", lineNum );
+		return 0;
+	}
+	for (inx=0;inx<threadCnt;inx++) {
+		if (strcmp(threads[inx].name,name)==0) {
+			return ++(threads[inx].count);
+		}
+	}
+	threads[threadCnt].name = strdup( name );
+	threads[threadCnt].count = 1;
+	threadCnt++;
+	return 1;
+}
+
+void mswhelpXref( char * name, char * ref1, char * ref2 )
+{
+	fprintf( ofile, "{\\uldb " );
+	rtfPutString( name );
+	fprintf( ofile, "}{\\v %s}", ref1 );
+}
+void mswhelpPicture( char * name, int inLine )
+{
+	if (inLine) {
+		fprintf( ofile, "\\{bml %s.shg\\}\\tab", name );
+		rtfNeedPar = TRUE;
+	} else {
+		fprintf( ofile, "{\\qc\\{bmc %s.shg\\}\\par\\pard}\r\n", name );
+		rtfNeedPar = FALSE;
+		rtfNeedGap = FALSE;
+		rtfGapHeight = -1;
+	}
+}
+void mswhelpSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	if (pageCnt != 0 && newpage)
+		fprintf( ofile, "\\page\r\n" );
+	pageCnt++;
+	if (context && context[0] != '\0')
+		fprintf( ofile, "#{\\footnote %s}\r\n", remap_minus(context) );
+	if (newpage && title && title[0] != '\0') {
+		fprintf( ofile, "${\\footnote %s}\r\n", title );
+	}
+	if (keywords && keywords[0] != '\0')
+		fprintf( ofile, "K{\\footnote %s}\r\n", keywords );
+	if (picture && picture[0] != '\0') {
+		mswhelpPicture( picture, 1 );
+	}
+	if (title && title[0] != '\0')
+		fprintf( ofile, "{\\b\\fs30 %s}\r\n", title );
+	fprintf( ofile, "\\par\r\n" );
+	rtfNeedPar = FALSE;
+}
+void mswhelpHeader( char * line )
+{
+	if ( line[0] == '*' )
+		return;
+	fprintf( ofile, "#{\\footnote %s}\r\n", remap_minus(line) );
+}
+void mswhelpThread( char * thread )
+{
+	int threadCnt;
+	threadCnt = lookupThread( thread );
+	fprintf( ofile, " +{\\footnote %s:%02d}\r\n", thread, threadCnt );
+}
+dispatchTable mswhelpTable = {
+	normalStart,
+	normalFinish,
+	rtfNewParagraph,
+	rtfStartLine,
+	rtfBold,
+	rtfItalic,
+	mswhelpXref,
+	mswhelpPicture,
+	rtfEndLine,
+	rtfPutChar,
+	mswhelpSection,
+	mswhelpHeader,
+	rtfStartDisplay,
+	(void*)no_op,
+	mswhelpThread,
+	rtfListStart,
+	rtfListItem,
+	rtfListEnd,
+	(void*)no_op
+	};
+
+/******************************************************************************
+ *
+ *	MSW-WORD
+ *
+ *****************************************************************************/
+
+
+struct BMFH {
+	char type[2];
+	short size[2];
+	short rsvd1;
+	short rsvd2;
+	short off[2];
+	};
+
+struct BMIH {
+	long size;
+	long width;
+	long height;
+	short planes;
+	short colors;
+	long comp;
+	long imageSize; 
+	long xPelsPerMeter;
+	long yPelsPerMeter;
+	long clrUsed;
+	long clrImportant; 
+	};
+
+struct BMIH2 {
+	long size;
+	short width;
+	short height;
+	short planes;
+	short colors;
+	};
+
+unsigned short S( short val )
+{
+    union {
+	short inVal;
+	unsigned char outVal[2];
+	} convShort;
+    short ret;
+    convShort.inVal = val;
+    ret = (((short)convShort.outVal[0])<<8) + ((short)convShort.outVal[1]);
+    return ret;
+}
+
+
+long L( long val )
+{
+    union {
+	long inVal;
+	unsigned char outVal[4];
+	} convLong;
+    long ret;
+    convLong.inVal = val;
+    ret = (((long)convLong.outVal[0])<<24) + (((long)convLong.outVal[1])<<16) + (((long)convLong.outVal[2])<<8) + ((long)convLong.outVal[3]);
+    return ret;
+}
+
+
+void dumpBytes( char * buff, long size, FILE * outF )
+{
+    long inx, off, rc;
+    for (inx=0, off=1; inx<size; inx++,off++) {
+	fprintf( outF, "%0.2x", (unsigned char)buff[inx] );
+	if (off >= 40) {
+		fprintf( outF, "\n" );
+		off = 0;
+	}
+    }
+    if (off != 1)
+	fprintf( outF, "\n" );
+}
+
+
+void conv24to8( long * colorTab, unsigned char * buff, int channels, int width24, int width8, int height )
+{
+	long * lastColor, *cp;
+	long color;
+	unsigned char * ip;
+	unsigned char *op;
+	int h, w;
+	lastColor = colorTab;
+	memset( colorTab, 0, 1024 );
+	op = buff;
+	for (h=0; h<height; h++) {
+		ip = buff+(width24*h);
+		op = buff+(width8*h);
+		for (w=0; w<width24; w+=channels,op++ ) {
+			color =  ((long)(ip[0]))<<16;
+			color += ((long)(ip[1]))<<8;
+			color += ((long)(ip[2]));
+			ip += channels;
+			for ( cp=colorTab; cp<lastColor; cp++ ) {
+				if (color == *cp) {
+					*op = (unsigned char)(cp-colorTab);
+					goto nextPixel;
+				}
+			}
+			if (lastColor < &colorTab[256]) {
+				*op = (unsigned char)(lastColor-colorTab);
+				*lastColor++ = color;
+			} else {
+				*op = 0;
+			}
+nextPixel:
+			;
+		}
+		*op++ = 0;
+		*op++ = 0;
+	}
+} 
+
+
+void dumpBmp( char * bmpName, FILE * outF )
+{
+	long rc;
+	long size;
+	long fullSize;
+	long scanWidth, width8;
+	long h;
+	long picw, pich;
+	long fileSize, maxRecSize;
+	struct BMFH bmfh;
+	struct BMIH bmih;
+	struct BMIH2 bmih2;
+	char * buff;
+	long * colorTab;
+	long bmfhSize, bmfhOff;
+	FILE * bmpF;
+	int colormapOff;
+	int i, j;
+
+	bmpF = openFile( bmpName );
+	rc = fread( &bmfh, 1, sizeof bmfh, bmpF );
+	rc = fread( &bmih, 1, sizeof bmih, bmpF );
+	colormapOff = sizeof bmfh + sizeof bmih;
+	if (bmih.size == 12L) {
+	    fseek( bmpF, sizeof bmfh, SEEK_SET );
+	    rc = fread( &bmih2, 1, sizeof bmih2, bmpF );
+	    bmih.width = bmih2.width;
+	    bmih.height = bmih2.height;
+	    bmih.planes = bmih2.planes;
+	    bmih.colors = bmih2.colors;
+	    bmih.comp = 0;
+	    bmih.imageSize = 0;
+	    bmih.xPelsPerMeter = 0;
+	    bmih.yPelsPerMeter = 0;
+	    bmih.clrUsed = 0;
+	    bmih.clrImportant = 0;
+	    colormapOff = sizeof bmfh + sizeof bmih2;
+	}
+#ifdef LATER
+	bmfh.size = L(bmfh.size);
+	bmfh.off = L(bmfh.off);
+	bmih.size = L(bmih.size);
+	bmih.width = L(bmih.width);
+	bmih.height = L(bmih.height);
+	bmih.planes = S(bmih.planes);
+	bmih.colors = S(bmih.colors);
+	bmih.comp = L(bmih.comp);
+	bmih.imageSize = L(bmih.imageSize);
+	bmih.xPelsPerMeter = L(bmih.xPelsPerMeter);
+	bmih.yPelsPerMeter = L(bmih.yPelsPerMeter);
+	bmih.clrUsed = L(bmih.clrUsed);
+	bmih.clrImportant = L(bmih.clrImportant);
+#endif
+	bmfhSize = ((unsigned short)bmfh.size[0]) + (((long)bmfh.size[1])<<16);
+	bmfhOff = ((unsigned short)bmfh.off[0]) + (((long)bmfh.off[1])<<16);
+	if (verbose) {
+	fprintf( stdout, "BMFH  type %c%c,  size %ld,  off %ld\n",
+		bmfh.type[0], bmfh.type[1], bmfhSize, bmfhOff );
+	fprintf( stdout, "BMIH  size %ld,  width %ld,  height %ld,  planes %d,  colors %d\n  comp %ld,  imageSize %ld,  xDPM %ld,  yDPM %ld,  clrUsed %ld,  clrImportant %ld\n",
+		bmih.size, bmih.width, bmih.height, bmih.planes, bmih.colors,
+		bmih.comp, bmih.imageSize, bmih.xPelsPerMeter, bmih.yPelsPerMeter,
+		bmih.clrUsed, bmih.clrImportant );
+	}
+	scanWidth = (bmih.width*bmih.colors+7)/8;
+	scanWidth = ((scanWidth+3)/4)*4;
+	fullSize = size = bmfhSize - bmfhOff;
+	if ( fullSize != bmih.height*scanWidth ) {
+		fprintf( stderr, "%s: height*scanWidth(%ld)(%ld) != fullSize(%ld)\n", bmpName, scanWidth, bmih.height*scanWidth, fullSize );
+		return;
+	}
+	if ( bmih.colors != 24 && bmih.colors != 8 && bmih.colors != 4 && bmih.colors != 1) {
+		return;
+	}
+	if ( bmih.planes != 1 ) {
+		fprintf( stderr, "%s: planes(%d) != 1\n", bmpName, bmih.planes );
+		return;
+	}
+	if ( bmih.comp != 0 ) {
+		fprintf( stderr, "%s: comp(%d) != 0\n", bmpName, bmih.comp );
+		return;
+	}
+
+	if (bmih.colors != 8) {
+		size = (((bmih.width+3)/4)*4) * bmih.height;
+	}
+	fileSize = (size+1024)/2 + 70;
+	maxRecSize = (size+1024)/2 + 34;
+
+	picw = bmih.width*26L;
+	pich = bmih.height*26L;
+	if ( outF ) {
+	buff = NULL;
+	fprintf( outF, "{\\pict\\wmetafile8\\picw%ld\\pich%ld\\picwgoal%ld\\pichgoal%ld\\picbmp\\picbpp%d\n",
+		picw, pich, bmih.width*15L, bmih.height*15L, 8/*bmih.colors*/ );
+	fprintf( outF, "010009000003%0.8lx0000%0.8lx0000\n",
+		L(fileSize), L(maxRecSize) );
+	fprintf( outF, "050000000b0200000000\n" ); /* SetWindowOrg(0,0) */
+	fprintf( outF, "050000000c02%0.4x%0.4x\n", S((short)bmih.height), S((short)bmih.width) );
+	fprintf( outF, "05000000090200000000\n" ); /* SetTextColor( 0 ) */
+	fprintf( outF, "050000000102d8d0c800\n" ); /* SetBkColor( 0 ) */
+	fprintf( outF, "0400000007010300\n" ); /* SetStretchBltMode(0300) */
+	fprintf( outF, "%0.8lx430f\n", L(maxRecSize) );
+	fprintf( outF, "2000cc000000%0.4x%0.4x00000000%0.4x%0.4x00000000\n",
+		S((short)bmih.height), S((short)bmih.width), S((short)bmih.height), S((short)bmih.width) );
+	fprintf( outF, "28000000%0.8lx%0.8lx%0.4x%0.4x000000000000000000000000000000000000000000000000\n",
+		L(bmih.width), L(bmih.height), S(bmih.planes), S(8/*bmih.colors*/) );
+	switch ( bmih.colors ) {
+	case 8:
+		buff = (char*)malloc(1024);
+		fseek( bmpF, colormapOff, 0 );
+		rc = fread( buff, 1024, 1, bmpF );
+		if (bmih.size == 12L) {
+		    for (h=255; h>=0; h--) {
+		        for (i=3; i>=0; i--)
+			    buff[h*4+i] = buff[h*3+i];
+		        buff[h*4+3] = 0;
+		    }
+		}
+		dumpBytes( buff, 1024, outF );
+		rc = fseek( bmpF, bmfhOff, 0 );
+		buff = (char*)realloc( buff, (int)scanWidth );
+		for ( h=0; h<bmih.height; h++ ) {
+			rc = fread( buff, (int)scanWidth, 1, bmpF );
+			dumpBytes( buff, scanWidth, outF );
+		}
+		break;
+	case 4:
+		buff = (char*)malloc(1024);
+		fseek( bmpF, colormapOff, 0 );
+		memset( buff, 0, 1024 );
+		rc = fread( buff, 3*16, 1, bmpF );
+		for (h=15; h>=0; h--) {
+		    for (i=3; i>=0; i--)
+			buff[h*4+i] = buff[h*3+i];
+		    buff[h*4+3] = 0;
+		}
+		dumpBytes( buff, 1024, outF );
+		rc = fseek( bmpF, bmfhOff, 0 );
+		buff = (char*)realloc( buff, (int)scanWidth*2+10 );
+		width8 = (bmih.width+3)/4*4;
+		for ( h=0; h<bmih.height; h++ ) {
+			rc = fread( buff, (int)scanWidth, 1, bmpF );
+			for (i=scanWidth-1; i>=0; i--) {
+			    buff[i*2+1] = buff[i]&0xF;
+			    buff[i*2] = (buff[i]>>4)&0xF;
+			}
+			dumpBytes( buff, width8, outF );
+		}
+		break;
+	case 1:
+		buff = (char*)malloc(1024);
+		fseek( bmpF, colormapOff, 0 );
+		memset( buff, 0, 1024 );
+		rc = fread( buff, 3*2, 1, bmpF );
+		for (h=1; h>=0; h--) {
+		    for (i=3; i>=0; i--)
+			buff[h*4+i] = buff[h*3+i];
+		    buff[h*4+3] = 0;
+		}
+		dumpBytes( buff, 1024, outF );
+		rc = fseek( bmpF, bmfhOff, 0 );
+		buff = (char*)realloc( buff, (int)scanWidth*8+10 );
+		width8 = (bmih.width+3)/4*4;
+		for ( h=0; h<bmih.height; h++ ) {
+			rc = fread( buff, (int)scanWidth, 1, bmpF );
+			for (i=scanWidth-1; i>=0; i--) {
+			    for (j=7; j>=0; j--) {
+				buff[i*8+j] = (buff[i]&(128>>j))?1:0;
+			    }
+			}
+			dumpBytes( buff, width8, outF );
+		}
+		break;
+	case 24:
+		buff = (char*)malloc( (int)(fullSize) );
+		rc = fread( buff, (int)(fullSize), 1, bmpF );
+		colorTab = (long*)malloc( 1024 );
+		width8 = ((bmih.width+3)/4)*4;
+		conv24to8( colorTab, buff, (int)scanWidth, 3, (int)width8, (int)bmih.height );
+		dumpBytes( (char*)colorTab, 1024, outF );
+		for ( h=0; h<bmih.height; h++ ) {
+			dumpBytes( buff, (int)width8, outF );
+			buff += (int)width8;
+		}
+		break;
+	default:
+		fprintf( stderr, "%s: colors(%d) != 24|8|4|1\n", bmpName, bmih.colors );
+		return;
+	}
+	fprintf( outF, "030000000000\n" );
+	fprintf( outF, "}\n" );
+	}
+	fclose( bmpF );
+}
+
+
+void dumpPng(
+	char * fileName,
+	FILE * outF )
+{
+	FILE * pngF;
+	int rc;
+	unsigned long image_rowbytes, width8, h;
+	long image_width, image_height;
+	int image_channels;
+	unsigned char * image_data;
+	double display_exponent = 1.0;
+
+	int bmih_colors = 24;
+	int bmih_planes = 1;
+
+	long size, fileSize, maxRecSize;
+	long colorTab[1024];
+ 	char pathName[1024];
+	char ** dir;
+
+	for ( dir=dirs; *dir; dir++ ) {
+		sprintf( pathName, "%s/%s", *dir, fileName );
+		pngF = fopen( pathName, "r" );
+		if ( pngF != NULL )
+			break;
+	}
+
+	if ( pngF == NULL ) {
+		perror( fileName );
+		return;
+	}
+        if ((rc = readpng_init(pngF, (long *) &image_width, (long *) &image_height)) != 0) {
+            switch (rc) {
+                case 1:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] is not a PNG file: incorrect signature\n",
+                      pathName);
+                    break;
+                case 2:
+                    fprintf(stderr, PROGNAME
+                      ":  [%s] has bad IHDR (libpng longjmp)\n",
+                      pathName);
+                    break;
+                case 4:
+                    fprintf(stderr, PROGNAME ":  insufficient memory\n");
+                    break;
+                default:
+                    fprintf(stderr, PROGNAME
+                      ":  unknown readpng_init() error\n");
+                    break;
+            }
+            return;
+	}
+
+	image_data = readpng_get_image(display_exponent, &image_channels, &image_rowbytes);
+	width8 = ((image_width+3)/4)*4;
+	size = width8*image_height;
+	fileSize = (size+1024)/2 + 70;
+        maxRecSize = (size+1024)/2 + 34;
+
+	fprintf( outF, "{\\pict\\wmetafile8\\picw%ld\\pich%ld\\picwgoal%ld\\pichgoal%ld\\picbmp\\picbpp%d\n",
+		image_width*26L, image_height*26L, image_width*15L, image_height*15L, 8/*bmih_colors*/ );
+	fprintf( outF, "010009000003%0.8lx0000%0.8lx0000\n",
+		L(fileSize), L(maxRecSize) );
+	fprintf( outF, "050000000b0200000000\n" ); /* SetWindowOrg(0,0) */
+	fprintf( outF, "050000000c02%0.4x%0.4x\n", S((short)image_height), S((short)image_width) );
+	fprintf( outF, "05000000090200000000\n" ); /* SetTextColor( 0 ) */
+	fprintf( outF, "050000000102d8d0c800\n" ); /* SetBkColor( 0 ) */
+	fprintf( outF, "0400000007010300\n" ); /* SetStretchBltMode(0300) */
+	fprintf( outF, "%0.8lx430f\n", L(maxRecSize) );
+	fprintf( outF, "2000cc000000%0.4x%0.4x00000000%0.4x%0.4x00000000\n",
+		S((short)image_height), S((short)image_width), S((short)image_height), S((short)image_width) );
+	fprintf( outF, "28000000%0.8lx%0.8lx%0.4x%0.4x000000000000000000000000000000000000000000000000\n",
+		L(image_width), L(image_height), S(bmih_planes), S(8/*bmih.colors*/) );
+	width8 = ((image_width+3)/4)*4;
+	conv24to8( colorTab, (char *) image_data, image_channels, image_width*image_channels, width8, image_height );
+	dumpBytes( (char *)colorTab, 1024, outF );
+	for ( h=0; h<image_height; h++ ) {
+		dumpBytes( (char *) image_data+(h)*width8, (int)width8, outF );
+	}
+	fprintf( outF, "030000000000\n" );
+	fprintf( outF, "}\n" );
+
+	readpng_cleanup(0);
+	fclose( pngF );
+	free( image_data );
+
+}
+
+void mswwordXref( char * name, char * ref1, char * ref2 )
+{
+	rtfBold( name );
+}
+void mswwordPicture( char * name, int inLine )
+{
+	char tmp[80];
+	if (!inLine) {
+		rtfFlushParagraph();
+		fprintf( ofile, "{\\qc\\sb%d", rtfNeedGap?rtfBigGap:0 );
+	}
+	if ( USE_BMP ) {
+		sprintf( tmp, "%s.bmp", name );
+		dumpBmp( tmp, ofile );
+	} else {
+		sprintf( tmp, "%s.png", name );
+		dumpPng( tmp, ofile );
+	}
+	if (inLine) {
+		/*fprintf( ofile, "\\tab " );*/
+		rtfNeedPar = TRUE;
+	} else {
+		fprintf( ofile, "\\par\\pard}\n" );
+		rtfNeedPar = FALSE;
+		rtfNeedGap = FALSE;
+		rtfGapHeight = -1;
+	}
+}
+int sectionNum[3] = { 0, 0, 0 };
+void mswwordSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	char tmp[1024];
+	char sectionNumS[20];
+	rtfFlushParagraph();
+	if (pageCnt != 0 && newpage) {
+		fprintf( ofile, "\\page\n" );
+	} 
+	pageCnt++;
+	if (toc) {
+		fprintf( ofile, "{\\*\\bkmkstart _Toc%ld}\n", tocNum );
+	}
+	fprintf( ofile,"\
+{\\pntext\\pard\\plain\\b\\f5\\fs28\\kerning28 \
+" );
+	switch ( section ) {
+	case 'A':
+		sprintf( sectionNumS, "%d. ", ++sectionNum[0] );
+		sectionNum[1] = sectionNum[2] = 0;
+		break;
+	case 'B':
+		sprintf( sectionNumS, "%d.%d ", sectionNum[0], ++sectionNum[1] );
+		sectionNum[2] = 0;
+		break;
+	case 'C':
+#ifdef LATER
+		sprintf( sectionNumS, "%d.%d.%d ", sectionNum[0], sectionNum[1], ++sectionNum[2] );
+#else
+		sprintf( sectionNumS, "" );
+#endif
+		break;
+	default:
+		sprintf( sectionNumS, "bad section (%c) ", section );
+	}
+	fprintf( ofile, "\
+%s\\tab}\
+\\pard\\plain \\s%d\\sb240\\sa60\\keepn\\widctlpar\
+{\\*\\pn \\pnlvl%d\\pndec\\pnprev1\\pnstart1\\pnindent720\\pnhang\
+{\\pntxta .}\
+}\
+\\b\\f5\\fs28\\kerning28 %s\
+", sectionNumS, section-'A'+1, section-'A'+1, title );
+	if (picture && picture[0] != '\0') {
+		fprintf( ofile, " " );
+		mswwordPicture( picture, 1 );
+	}
+	if (toc) {
+		fprintf( ofile, "{\\*\\bkmkend _Toc%ld}\n", tocNum );
+	}
+	fprintf( ofile, "\
+\\par \
+\\pard\\plain \\widctlpar \\f4\\fs%d \
+\n", FontSize );
+	if (toc) {
+		tocList_p tl;
+		tl = (tocList_p)malloc( sizeof *tl );
+		tl->section = section;
+		tl->title = (char*)malloc( strlen(sectionNumS) + strlen(title) + 1 );
+		sprintf( tl->title, "%s%s", sectionNumS, title );
+		tl->num = tocNum++;
+		tl->next = NULL;
+		if (tocHead == NULL)
+			tocHead = tl;
+		else
+			tocTail->next = tl;
+		tocTail = tl;
+	}
+	rtfNeedPar = FALSE;
+	rtfNeedGap = TRUE;
+	rtfGapHeight = -1;
+}
+
+void mswwordStart( char * inName, char * outName )
+{
+	normalStart( inName, outName );
+	if ( MarginGutter >= 0.0 )
+		fprintf( ofile, "\\margmirror\\gutter%d\n", (int)(MarginGutter*1440.0) );
+	if (MarginTop >= 0.0)
+		fprintf( ofile, "\\margt%d\n", (int)(MarginTop*1440.0) );
+	if (MarginBottom >= 0.0)
+		fprintf( ofile, "\\margb%d\n", (int)(MarginBottom*1440.0) );
+	if (MarginRight >= 0.0)
+		fprintf( ofile, "\\margr%d\n", (int)(MarginRight*1440.0) );
+	if (MarginLeft >= 0.0)
+		fprintf( ofile, "\\margl%d\n", (int)(MarginLeft*1440.0) );
+}
+
+void mswwordFinish( void )
+{
+	char lastSection = 'A';
+	tocList_p tl;
+	rtfFlushParagraph();
+	if (toc) {
+		fprintf( ofile, "\
+\\sect \\sectd \\pgnrestart\\pgnlcrm\\linex0\\endnhere\
+\\pard\\plain \\qc\\widctlpar \\f4\\fs22 \
+{\\b\\fs36\\lang1024\\kerning28 Contents \\par \\par }\
+\\pard\\plain \\s17\\widctlpar\\tqr\\tldot\\tx8640 \\f4\\fs%d\n", FontSize );
+		for ( tl=tocHead; tl; tl=tl->next ) {
+			if ( tl->section != lastSection ) {
+				fprintf( ofile, "\
+\\pard\\plain \\s%d\\li%d\\widctlpar\\tqr\\tldot\\tx8640 \\f4\\fs%d\n",
+					tl->section-'A'+17,
+					(tl->section-'A')*200, FontSize );
+				lastSection = tl->section;
+			}
+			fprintf( ofile, "\
+{\\lang1024\\kerning28 %s}{\\lang1024 \\tab }\
+{\\field{\\*\\fldinst {\\lang1024  GOTOBUTTON _Toc%ld  }\n\
+{\\field{\\*\\fldinst {\\lang1024  PAGEREF _Toc%ld }}\
+{\\fldrslt {\\lang1024 3}}}}}{\\lang1024 \\par }\n",
+				tl->title, tl->num, tl->num);
+		}
+		fprintf( ofile,
+"\\pard\\plain \\widctlpar \\f4\\fs%d\n}\n}\n"
+/*\\pard\\plain \*/
+"\\widctlpar \\f4\\fs%d\n" , FontSize, FontSize);
+	}
+	normalFinish();
+}
+
+
+dispatchTable mswwordTable = {
+	mswwordStart,
+	mswwordFinish,
+	rtfNewParagraph,
+	rtfStartLine,
+	rtfBold,
+	rtfItalic,
+	mswwordXref,
+	mswwordPicture,
+	rtfEndLine,
+	rtfPutChar,
+	mswwordSection,
+	(void*)no_op,
+	rtfStartDisplay,
+	(void*)no_op,
+	(void*)no_op,
+	rtfListStart,
+	rtfListItem,
+	rtfListEnd,
+	rtfPage
+	};
+
+/******************************************************************************
+ *
+ *	TEXT
+ *
+ *****************************************************************************/
+
+char textBuff[1024];
+char *textBuffP = textBuff;
+int textNewLine = 1;
+int textIndent = 0;
+int textAllowLeadingBlanks = 0;
+int textNoIndent = 0;
+int textLineLength;
+
+void textPutChar( char ch )
+{
+	char *cp, *cq;
+	int indent;
+	int width;
+
+	if (textNewLine) {
+		textLineLength = 0;
+		if (ch == ' ' && !textAllowLeadingBlanks) {
+			return;
+		}
+		if (!textNoIndent) {
+			for (indent=0; indent<textIndent; indent++) {
+				memmove( textBuffP, "    ", 4 );
+				textBuffP += 4;
+				textLineLength += 4;
+			}
+		}
+	}
+	textNewLine = 0;
+	*textBuffP++ = ch;
+	if (ch == '\010')
+		textLineLength--;
+	else
+		textLineLength++;
+	width = (textIndent>0?listWidth:lineWidth);
+	if ( wordwrap && width > 0 && textLineLength > width ) {
+		for (cp = textBuffP-1; *cp != ' ' && cp>textBuff+lineWidth/2; cp-- );
+		while ( *cp == ' ' && cp>textBuff+lineWidth/2 ) cp--;
+		cp++;
+		fwrite( textBuff, cp-textBuff, 1, ofile );
+		fwrite( "\n", 1, 1, ofile );
+		textNewLine = 1;
+		while (*cp == ' ' && cp<textBuffP) cp++;
+		if (textBuffP!=cp) {
+			cq = textBuff+textIndent*4;
+			memmove( cq, cp, textBuffP-cp );
+			cq = textBuff;
+			for (indent=0; indent<textIndent; indent++) {
+				memmove( cq, "    ", 4 );
+				cq += 4;
+			}
+			textBuffP = cq + (textBuffP-cp);
+			textNewLine = 0;
+			for ( cp=textBuff,textLineLength=0; cp<textBuffP; cp++ ) {
+				if (*cp == '\010')
+					textLineLength--;
+				else
+					textLineLength++;
+			}
+		} else {
+			textBuffP = textBuff;
+		}
+	} else if (textBuffP - textBuff >= sizeof textBuff ) {
+		fwrite( textBuff, textBuffP-textBuff, 1, ofile );
+		textBuffP = textBuff;
+		textLineLength = 0;
+	}
+}
+void textBreakLine( void )
+{
+	if ( !textNewLine ) {
+		fwrite( textBuff, textBuffP-textBuff, 1, ofile );
+		fwrite( "\n", 1, 1, ofile );
+		textNewLine = 1;
+		textBuffP = textBuff;
+		textLineLength = 0;
+	}
+}
+void textSaveLine( char * tmp )
+{
+	if (!textNewLine) {
+		int len = textBuffP-textBuff;
+		memcpy( tmp, textBuff, len );
+		tmp[len] = '\0';
+		textNewLine = 1;
+		textBuffP = textBuff;
+		textLineLength = 0;
+	} else {
+		tmp[0] = '\0';
+	}
+}
+void textRestoreLine( char * tmp )
+{
+	int len = strlen( tmp );
+	if (len > 0) {
+		memcpy( textBuffP, tmp, len );
+		textBuffP += len;
+		textLineLength += len;
+		textNewLine = 0;
+	}
+}
+void textFinish( void )
+{
+	textBreakLine();
+	normalFinish();
+}
+void textPutString( char * cp )
+{
+	while (*cp)
+		textPutChar( *cp++ );
+}
+void textNewParagraph( void )
+{
+	textBreakLine();
+	if (wordwrap) {
+		fwrite( "\n", 1, 1, ofile );
+	}
+}
+void textStartLine( int lastlineblank )
+{
+}
+void textBold( char * name )
+{
+	char * cp;
+	/*textPutChar( '<' );*/
+	for ( cp = name; *cp; cp++ ) {
+		textPutChar( *cp );
+		if (*cp != ' ') {
+			textPutChar( '\010' );
+			textPutChar( *cp );
+		}
+	}
+	/*textPutString( name );*/
+	/*textPutChar( '>' );*/
+}
+void textItalic( char * name )
+{
+	char * cp;
+	/*textPutChar( '<' );*/
+	for ( cp = name; *cp; cp++ ) {
+		textPutChar( *cp );
+		if (*cp != ' ') {
+			textPutChar( '\010' );
+			textPutChar( *cp );
+		}
+	}
+	/*textPutString( name );*/
+	/*textPutChar( '>' );*/
+}
+void textXref( char * name, char * ref1, char * ref2 )
+{
+	textBold( name );
+	/*textPutChar( '<' );
+	textPutString( name );
+	textPutChar( '>' );*/
+	if (ref2) {
+		textPutString( " (See " );
+		textPutString( ref2 );
+		textPutString( " for Details)" );
+	}
+}
+void textPicture( char * picture, int inLine )
+{
+	textPutString( "<<" );
+	textPutString( picture );
+	textPutString( ">>" );
+	if (inLine) {
+		textPutString( "  " );
+	} else {
+		textBreakLine();
+		fwrite( "\n", 1, 1, ofile );
+	}
+}
+void textEndLine( void )
+{
+	if ( !wordwrap )
+		textBreakLine();
+}
+void textSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	int len;
+	textBreakLine();
+	if (pageCnt > 0 && newpage) {
+		fwrite( "\014\n", 1, 2, ofile );
+	}
+	pageCnt++;
+	textBold( title );
+	/*textPutString( title );*/
+	textBreakLine();
+	for ( len = strlen(title); len>0; len-- ) {
+		textBold( "=" );
+		/*fwrite( "=", 1, 1, ofile );*/
+	}
+	textBreakLine();
+	fwrite( "\n", 1, 1, ofile );
+}
+void textHeader( char * line )
+{
+}
+void textStartIndent( void )
+{
+	textBreakLine();
+	textIndent++;
+}
+void textEndIndent( void )
+{
+	textBreakLine();
+	if (textIndent < 0) {
+		fprintf( stderr, "%d: textIndent < 0\n", lineNum );
+		textIndent = 0;
+	} else {
+		textIndent--;
+	}
+}
+void textListItem( void )
+{
+	char num[4];
+	textBreakLine();
+	textIndent--;
+	textAllowLeadingBlanks = 1;
+	switch( listType[listLevel] ) {
+	case LISTNONE:
+	default:
+		textPutString( "  " );
+		break;
+	case LISTBULLET:
+		textPutString( "  o " );
+		break;
+	case LISTDASH:
+		textPutString( "  - " );
+		break;
+	case LISTNUMBER:
+		sprintf( num, "%3.3d", listCount[listLevel] );
+		textPutString( num );
+		textPutChar( ' ' );
+		break;
+	}
+	textAllowLeadingBlanks = 0;
+	textIndent++;
+}
+void textPage( void )
+{
+	fwrite( "\014\n", 1, 2, ofile );
+}
+dispatchTable textTable = {
+	normalStart,
+	textFinish,
+	textNewParagraph,
+	textStartLine,
+	textBold,
+	textItalic,
+	textXref,
+	textPicture,
+	textEndLine,
+	textPutChar,
+	textSection,
+	textHeader,
+	textStartIndent,
+	textEndIndent,
+	(void*)no_op,
+	textStartIndent,
+	textListItem,
+	textEndIndent,
+	textPage
+	};
+
+/******************************************************************************
+ *
+ *	XVIEW
+ *
+ *****************************************************************************/
+
+
+void xviewStart( char * inName, char * outName )
+{
+	normalStart( inName, outName );
+	lineWidth = 0;
+}
+
+void xviewBold( char * name )
+{
+	char * cp;
+	textPutChar( '<' );
+	textPutString( name );
+	textPutChar( '>' );
+}
+void xviewItalic( char * name )
+{
+	char * cp;
+	textPutChar( '<' );
+	textPutString( name );
+	textPutChar( '>' );
+}
+void xviewXref( char * name, char * ref1, char * ref2 )
+{
+	xviewBold( name );
+	if (ref2) {
+		textPutString( " (See " );
+		textPutString( ref2 );
+		textPutString( " for Details)" );
+	}
+}
+void xviewSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	int indent;
+	int len;
+
+	static char * stars = "************";
+	indent = line[1]-'A'+1;
+	textBreakLine();
+	if (pageCnt > 0 && newpage) {
+		fwrite( "\n", 1, 1, ofile );
+	}
+	if ( newpage ) {
+		pageCnt++;
+		textNoIndent = 1;
+		textPutChar( ':' );
+		textPutString( stars+strlen(stars)-indent );
+		textPutChar( '-' );
+		textPutString( title );
+		textBreakLine();
+		if (context) {
+			textPutChar( ':' );
+			textPutString( context );
+			textPutChar( ' ' );
+			textBreakLine();
+		}
+	}
+	textNoIndent = 0;
+	xviewBold( title );
+	textBreakLine();
+	for ( len = strlen(title); len>0; len-- )
+		fwrite( "=", 1, 1, ofile );
+	fwrite( "\n\n", 1, 2, ofile );
+}
+void xviewHeader( char * line )
+{
+	char tmp[1024];
+	textSaveLine( tmp );
+	textNoIndent = 1;
+	textPutChar( ':' );
+	textPutString( line );
+	textPutChar( ' ' );
+	textBreakLine();
+	textNoIndent = 0;
+	textRestoreLine( tmp );
+}
+dispatchTable xviewTable = {
+	xviewStart,
+	normalFinish,
+	textNewParagraph,
+	textStartLine,
+	xviewBold,
+	xviewItalic,
+	xviewXref,
+	(void*)no_op,	/* picture */
+	textEndLine,
+	textPutChar,
+	xviewSection,
+	xviewHeader,
+	textStartIndent,	/* startDisplay */
+	textEndIndent,		/* endDisplay */
+	(void*)no_op,
+	textStartIndent,	/* listStart */
+	textListItem,
+	textEndIndent,		/* listEnd */
+	(void*)no_op
+	};
+
+/******************************************************************************
+ *
+ *	HTML
+ *
+ *****************************************************************************/
+
+char * htmlName;
+char htmlFileName[1024];
+
+struct {
+	char * name;
+	int index;
+	int section;
+	} links[500];
+int linkCnt = 0;
+
+void setLink( char * name, int sectionNumber )
+{
+	links[linkCnt].name = strdup( name );
+	links[linkCnt].section = sectionNumber;
+	linkCnt++;
+}
+
+
+void getLinks( int sectionNumber, int * prev, int * next )
+{
+    int cur, inx;
+
+	*prev = -1;
+	*next = -1;
+	for ( cur = 0; cur < linkCnt; cur++ ) {
+		if ( links[cur].section == sectionNumber ) {
+			for (inx = cur-1; inx >= 0; inx-- ) {
+				if ( strcmp( links[cur].name, links[inx].name ) == 0 ) {
+					*prev = links[inx].section;
+					break;
+				}
+			}
+			for (inx = cur+1; inx < linkCnt; inx++ ) {
+				if ( strcmp( links[cur].name, links[inx].name ) == 0 ) {
+					*next = links[inx].section;
+					break;
+				}
+			}
+		}
+	}
+			
+}
+
+
+struct {
+	char * name;
+	int sectionNumber;
+	int subSection;
+	} sections[500];
+int sectionCnt = 0;
+int lastSection = 0;
+int curSection = 0;
+int subSection = 0;
+
+
+void defineSection( char * name, int sectionNumber )
+{
+	if (!name) {
+		fprintf( stderr, "%d: NULL context string\n", lineNum );
+		return;
+	}
+	sections[sectionCnt].name = strdup( name );
+	sections[sectionCnt].sectionNumber = sectionNumber;
+	if (lastSection != sectionNumber) {
+		subSection = 0;
+	}
+	sections[sectionCnt].subSection = subSection++;
+	sectionCnt++;
+}
+
+
+int lookupSection( char * name, int *subSection )
+{
+	int inx;
+	if (!name) {
+		return -1;
+	}
+	for (inx=0; inx<sectionCnt; inx++) {
+		if (strcmp( name, sections[inx].name ) == 0) {
+			*subSection = sections[inx].subSection;
+			return sections[inx].sectionNumber;
+		}
+	}
+	fprintf( stderr, "%d: undefined reference to %s\n", lineNum, name );
+	return -1;
+}
+
+
+void genHtmlLinks( int sectionNumber, int begin )
+{
+	int prev, next;
+    int comma = 0;
+
+	if (ofile) {
+		if (sectionNumber != 0) {
+			if (!begin) fprintf( ofile, "\n<p></p><p></p><hr><p>" );
+			fprintf( ofile, "<a href=%s.html><b>Return to Contents</b></a>",
+					htmlName );
+			comma = 1;
+		}
+		getLinks( sectionNumber, &prev, &next );
+		if (prev > 0) {
+			if (comma)
+				fprintf( ofile, ", " );
+			else
+				if (!begin) fprintf( ofile, "\n<p></p><p></p><hr><p>" );
+			fprintf( ofile, "<a href=%s-%d.html><b>Previous Page</b></a>",
+					htmlName, prev );
+			comma = 1;
+		}
+		if (next > 0) {
+			if (comma)
+				fprintf( ofile, ", " );
+			else
+				if (!begin) fprintf( ofile, "\n<p></p><p></p><hr><p>" );
+			fprintf( ofile, "<a href=%s-%d.html><b>Next Page</b></a>",
+					htmlName, next );
+			comma = 1;
+		}
+		if (comma)
+			if (begin)
+				fprintf( ofile, "</p><hr><p></p>\n" );
+			else
+				fprintf( ofile, "</p>\n" );
+	}
+}
+
+int preHtmlSectionNumber = -1;
+void preHtmlSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	if ( !newpage )
+		return;
+	preHtmlSectionNumber++;
+	defineSection( context, preHtmlSectionNumber );
+}
+void preHtmlHeader( char * line )
+{
+	if ( line[0] == '*' )
+		return;
+	defineSection( line, preHtmlSectionNumber );
+}
+void preHtmlThread( char * thread )
+{
+	setLink( thread, preHtmlSectionNumber );
+}
+dispatchTable preHtmlTable = {
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	preHtmlSection,
+	preHtmlHeader,
+	(void*)no_op,
+	(void*)no_op,
+	preHtmlThread,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op
+	};
+
+dispatchTable htmlTable;
+
+void htmlStart( char * inName, char * outName )
+{
+	curMode = &preHtmlTable;
+	ifile = openFile( inName );
+	process( ifile );
+	fclose( ifile );
+	curMode = &htmlTable;
+
+	ifile = openFile( inName );
+	htmlName = outName;
+	sprintf( htmlFileName, "%s.html", htmlName );
+	ofile = fopen( htmlFileName, "w" );
+	if (ofile == NULL) {
+		perror( outName );
+		exit( 1 );
+	}
+}
+void htmlFinish( void )
+{
+		genHtmlLinks( curSection, 0 );
+}
+void htmlNewParagraph( void )
+{
+    if (wordwrap) {
+		if ( listLevel < 0 )
+			fprintf( ofile, "<p>" );
+		else
+			fprintf( ofile, "<br>" );
+	} else {
+		fprintf( ofile, "\n" );
+	}
+}
+void htmlStartLine( int lastBlank )
+{
+    if (wordwrap)
+	fprintf( ofile, "\n" );
+    else
+	fprintf( ofile, "\t" );
+}
+void htmlBold( char * name )
+{
+	fprintf( ofile, "<b>%s</b>", name );
+}
+void htmlItalic( char * name )
+{
+	fprintf( ofile, "<i>%s</i>", name );
+}
+void htmlXref( char * name, char * ref1, char * ref2 )
+{
+	int sectionNumber, subSection;
+	sectionNumber = lookupSection( ref1, &subSection );
+	if (sectionNumber < 0)
+		return;
+	fprintf( ofile, "<a href=%s", htmlName );
+	if (sectionNumber != 0)
+		fprintf( ofile, "-%d", sectionNumber );
+	fprintf( ofile, ".html" );
+	if (subSection != 0)
+		fprintf( ofile, "#%d", subSection );
+	fprintf( ofile, ">%s</a>", name );
+}
+void htmlPicture( char * name, int inLine )
+{
+	fprintf( ofile, "<img src=%s.png>", name );
+	if (inLine)
+		fprintf( ofile, "\t" );
+	else
+		fprintf( ofile, "<p></p>\n" );
+}
+void htmlEndLine( void )
+{
+	if ( !wordwrap )
+		fprintf( ofile, "\n" );
+}
+void htmlPutChar( char ch )
+{
+	if ( ch == '<' )
+		fprintf( ofile, "&lt;" );
+	else if ( ch == '>' )
+		fprintf( ofile, "&gt;" );
+	else
+		fputc( ch, ofile );
+}
+void htmlSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	int sectionNumber, subSection;
+	if ( newpage ) {
+	/*if (line[1] == 'A')*/
+		sectionNumber = curSection;
+		curSection = lookupSection( context, &subSection );
+		if (curSection > 0) {
+			genHtmlLinks( sectionNumber, 0 );
+			if (ofile)
+				fclose( ofile );
+			sprintf( htmlFileName, "%s-%d.html", htmlName, curSection );
+			ofile = fopen( htmlFileName, "w" );
+			if (ofile == NULL) {
+				perror( htmlFileName );
+				exit(1);
+			}
+		}
+		fprintf( ofile, "<title>%s</title>\n", title );
+		genHtmlLinks( curSection, 1 );
+	}
+	if (picture && picture[0] != '\0')
+		fprintf( ofile, "<img src=%s.png>  ", picture );
+	fprintf( ofile, "<h%d>%s</h%d>\n",
+		line[1]-'A'+1, title, line[1]-'A'+1 );
+}
+void htmlHeader( char * line )
+{
+	int sectionNumber, subSection;
+	if ( line[0] == '*' )
+		return;
+	sectionNumber = lookupSection( line, &subSection );
+	if (sectionNumber < 0)
+		return;
+	fprintf( ofile, "<A Name=\"%d\">\n", sectionNumber );
+}
+void htmlStartDisplay( void )
+{
+	fprintf( ofile, "<p>\n<pre>" );
+}
+void htmlEndDisplay( void )
+{
+	fprintf( ofile, "</pre>\n" );
+}
+void htmlListStart( void )
+{
+	fprintf( ofile, "<ul>" );
+}
+void htmlListItem( void )
+{
+	fprintf( ofile, "<li>" );
+}
+void htmlListEnd( void )
+{
+	fprintf( ofile, "</ul>\n" );
+}
+dispatchTable htmlTable = {
+	htmlStart,
+	htmlFinish,
+	htmlNewParagraph,
+	htmlStartLine,
+	htmlBold,
+	htmlItalic,
+	htmlXref,
+	htmlPicture,
+	htmlEndLine,
+	htmlPutChar,
+	htmlSection,
+	htmlHeader,
+	htmlStartDisplay,
+	htmlEndDisplay,
+	(void*)no_op,
+	htmlListStart,
+	htmlListItem,
+	htmlListEnd,
+	(void*)no_op
+	};
+
+
+/******************************************************************************
+ *
+ *	DEFINES
+ *
+ *****************************************************************************/
+struct {
+	char * name;
+	int refCount;
+	int lineNum;
+	} defs[500];
+int defCnt = 0;
+
+void lookupDef( char * name, int def )
+{
+	int inx;
+	if (!name) {
+		fprintf( stderr, "%d: NULL context string\n", lineNum );
+		return;
+	}
+	for (inx=0;inx<defCnt;inx++) {
+		if (strcmp(defs[inx].name,name)==0) {
+			if (def) {
+				if (defs[inx].lineNum <= 0)
+					defs[inx].lineNum = lineNum;
+				else
+					fprintf( stderr, "%d: %s redefined (previous %d)\n",
+						lineNum, name, defs[inx].lineNum );
+			} else {
+				defs[inx].refCount++;
+			}
+			return;
+		}
+	}
+	if (defCnt >= 499) {
+		if (defCnt == 499) {
+			fprintf( stderr, "%d: too many defines\n", lineNum );
+			defCnt++;
+		}
+		return;
+	} else {
+		defs[defCnt].name = strdup( name );
+		defs[defCnt].lineNum = (def?lineNum:-1);
+		defs[defCnt].refCount = 0;
+		defCnt++;
+	}
+}
+
+void defsFinish( void )
+{
+	int inx;
+	for ( inx=0; inx<defCnt; inx++ )
+		fprintf( ofile, "%5d: %s [%d]\n",
+			defs[inx].lineNum, defs[inx].name, defs[inx].refCount );
+	fclose(ofile);
+}
+void defsSection( char section, char * title, char * context, char * picture, char * keywords, int newpage )
+{
+	lookupDef( context, 1 );
+}
+void defsHeader( char * line )
+{
+	if ( line[0] == '*' )
+		return;
+	lookupDef( line, 1 );
+}
+void defsXref( char * name, char * ref1, char * ref2 )
+{
+	lookupDef( ref1, 0 );
+}
+
+dispatchTable defsTable = {
+	normalStart,
+	defsFinish,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	defsXref,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	defsSection,
+	defsHeader,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op,
+	(void*)no_op
+	};
+
+/******************************************************************************
+ *
+ *	PARSE
+ *
+ *****************************************************************************/
+
+char * skipChars( char * cp )
+{
+	for ( ; *cp; cp++ ) {
+		if ( *cp != '$' )
+			continue;
+		if ( cp[1] == '{' )
+			continue;
+		break;
+	}
+	return cp;
+}
+
+static int lastlineblank = 0;
+void putline( char * line )
+{
+	int len;
+	char * cp, * cq;
+	char * name;
+	char * mswhelpref;
+	char * xvref;
+	int sectionNumber;
+	int subSection;
+
+	len = strlen(line);
+	if (len > 0 && line[len-1] == '\n')
+		line[--len] = '\0';
+	if (len > 0 && line[len-1] == '\r')
+		line[--len] = '\0';
+	if (len <= 0) {
+		if (lastlineblank)
+			return;
+		curMode->newParagraph();
+		lastlineblank = 1;
+		return;
+	} else {
+		curMode->startLine( lastlineblank );
+		lastlineblank = 0;
+	}
+
+#ifndef LATER
+	if (wordwrap) {
+		if (line[len-1] != ' ') {
+			line[len++] = ' ';
+			if (line[len-2] == '.')
+				line[len++] = ' ';
+		}
+		line[len] = '\0';
+	}
+#endif
+
+	for ( cp=line; *cp; cp++ ) {
+		if (*cp == '$') {
+			cp++;
+			switch (*cp) {
+			case '?':
+			case '$':
+				curMode->putChar( *cp );
+				break;
+			case '{':
+				curMode->putChar( '$' );
+				curMode->putChar( '{' );
+				break;
+			case 'B':
+				name = ++cp;
+				cp = skipChars( cp );
+				if (*cp=='\0')
+					break;
+				*cp = '\0';
+				curMode->doBold( name );
+				break;
+			case 'I':
+				name = ++cp;
+				cp = skipChars( cp );
+				if (*cp=='\0')
+					break;
+				*cp = '\0';
+				curMode->doItalic( name );
+				break;
+			case 'X':
+				name = ++cp;
+				while (*cp && *cp != '|') cp++;
+				if (*cp=='\0')
+					break;
+				*cp++ = '\0';
+				mswhelpref = cp;
+				while (*cp && *cp != '|' && *cp != '$') cp++;
+				if (*cp=='\0')
+					break;
+				if (*cp == '|') {
+					*cp++ = '\0';
+					xvref = cp;
+					while (*cp && *cp != '$') cp++;
+					if (*cp=='\0')
+						break;
+					for (cq=xvref; cq<cp; cq++)
+						if (*cq==',')
+							*cq = '|';
+				} else
+					xvref = NULL;
+				*cp = '\0';
+				curMode->doXref( name, mswhelpref, xvref );
+				break;
+			case 'G':
+				name = ++cp;
+				while (*cp && *cp != '$') cp++;
+				if (*cp=='\0')
+					break;
+				*cp = '\0';
+				curMode->doPicture( name, 1 );
+				break;
+			default:
+				fprintf( stderr, "%d Invalid $ command - %c\n", lineNum, *cp );
+				break;
+			}
+		} else {
+			if (*cp != '\014')
+				curMode->putChar( *cp );
+		}
+	}
+	curMode->endLine();
+}
+
+
+char * conds[100];
+char **condPtr = conds;
+
+void addCond( char * name )
+{
+	*condPtr++ = name;
+}
+int lookupCond( char * name )
+{
+	char ** p;
+	int ret = 1;
+	if (strlen(name) == 0)
+		return 1;
+	if (*name == '!') {
+		ret = 0;
+		name++;
+	}
+	for (p=conds; p<condPtr; p++) {
+		if (strcmp( *p, name )==0)
+			return ret;
+	}
+	return !ret;
+}
+
+void process( FILE * f )
+{
+	char key;
+	char * title;
+	char * context;
+	char * fileName;
+	char * keywords;
+	char * cp;
+	char tmp[1024];
+	int indent;
+	FILE * newFile;
+	int lineNum0;
+	int threadCnt;
+	int sectionNumber;
+	int subSection;
+	int valid;
+	int sectionNewPage;
+	int noSectionNewPage;
+	
+	lineNum0 = lineNum;
+	lineNum = 0;
+	while (fgets( line, sizeof line, f ) != NULL) {
+		lineNum++;
+		line[strlen(line)-1] = '\0';
+		if (line[0] == '?' && line[1] == '?') {
+			cp = line+2;
+			while (isblank(*cp)) cp++;
+			if ( strcmp(cp, "else") == 0 )
+				valid = !valid;
+			else
+				valid = lookupCond( cp );
+			continue;
+		}
+		if (!valid) {
+			continue;
+		}
+		if (line[0] == '\014')
+			continue;
+		if (line[0] != '?') {
+			putline( line );
+			continue;
+		}
+		sectionNewPage = 1;
+		switch (line[1]) {
+		case '#':
+			break;
+		case '+':
+			newFile = openFile( line+2 );
+			process( newFile );
+			fclose( newFile );
+			break;
+		case 'a': case 'b': case 'c':
+			line[1] += 'A'-'a';
+			sectionNewPage = 0;
+		case 'A': case 'B': case 'C':
+			if ( noSectionNewPage ) {
+				sectionNewPage = 0;
+				noSectionNewPage = 0;
+			}
+			context = fileName = keywords = NULL;
+			title = cp = line+2;
+			while (*cp && *cp != '|') cp++;
+			if (*cp) {
+				*cp++ = '\0';
+				if (*cp!='|')
+					context = cp;
+			}
+			while (*cp && *cp != '|') cp++;
+			if (*cp) {
+				*cp++ = '\0';
+				if (*cp!='|')
+					fileName = cp;
+			}
+			while (*cp && *cp != '|') cp++;
+			if (*cp) {
+				*cp++ = '\0';
+				if (*cp!='|')
+					keywords = cp;
+			}
+			curMode->doSection( line[1], title, context, fileName, keywords, sectionNewPage );
+			lastlineblank = 0;
+			break;
+		case 'H':
+			curMode->doHeader( line+2 );
+			break;
+		case 'W':
+			if (line[2] == '+') {
+				curMode->doEndDisplay();
+				wordwrap = 1;
+			} else if (line[2] == '-') {
+				curMode->doStartDisplay();
+				wordwrap = 0;
+			} else {
+				fprintf( stderr, "%d: Bad ?W command\n", lineNum);
+				exit(1);
+			}
+			lastlineblank = 0;
+			break;
+		case 'G':
+			curMode->doPicture( line+2, 0 );
+			lastlineblank = 0;
+			break;
+		case 'T':
+			curMode->doThread( line+2 );
+			break;
+		case 'L':
+			switch (line[2]) {
+			case 'S':
+				listLevel++;
+				listCount[listLevel] = 0;
+				switch (line[3]) {
+				case 'o':
+					listType[listLevel] = LISTBULLET;
+					break;
+				case '-':
+					listType[listLevel] = LISTDASH;
+					break;
+				case '1':
+					listType[listLevel] = LISTNUMBER;
+					break;
+				default:
+					listType[listLevel] = LISTNONE;
+				}
+				curMode->doListStart();
+				break;
+			case 'I':
+				if (listLevel<0) {
+					fprintf( stderr, "%d: ?LI not in list\n", lineNum );
+					break;
+				}
+				listCount[listLevel]++;
+				curMode->doListItem();
+				break;
+			case 'E':
+				listLevel--;
+				curMode->doListEnd();
+				break;
+			}
+			lastlineblank = 0;
+			break;
+		case 'P':
+			curMode->page();
+			lastlineblank = 0;
+			break;
+		case 'Q':
+			noSectionNewPage = 1;
+			break;
+		default:
+			fprintf( stderr, "%d: Invalid ? command: %c\n", lineNum, line[1] );
+		}
+	}
+	lineNum = lineNum0;
+}
+
+
+/******************************************************************************
+ *
+ *	MAIN
+ *
+ *****************************************************************************/
+
+int main ( int argc, char * argv[] )
+{
+	int inx;
+
+	curMode = NULL;
+	argv++; argc--;
+	while ( argc > 1 && argv[0][0] == '-' ) {
+		if ( strcmp( argv[0], "-xv" ) == 0 ) {
+			curMode = &xviewTable;
+			addCond( "xv" );
+		} else if ( strcmp( argv[0], "-mswhelp" ) == 0 ) {
+			curMode = &mswhelpTable;
+			addCond( "mswhelp" );
+		} else if ( strcmp( argv[0], "-mswword" ) == 0 ) {
+			curMode = &mswwordTable;
+			addCond( "mswword" );
+		} else if ( strcmp( argv[0], "-html" ) == 0 ) {
+			curMode = &htmlTable;
+			addCond( "html" );
+		} else if ( strcmp( argv[0], "-def" ) == 0 ) {
+			curMode = &defsTable;
+			addCond( "def" );
+		} else if ( strcmp( argv[0], "-text" ) == 0 ) {
+			curMode = &textTable;
+			addCond( "text" );
+		} else if ( strncmp( argv[0], "-C", 2 ) == 0 ) {
+			argv++; argc--;
+			addCond( argv[0] );
+		} else if ( strncmp( argv[0], "-v", 2 ) == 0 ) {
+			verbose = 1;
+		} else if ( strncmp( argv[0], "-d", 2 ) == 0 ) {
+			argv++; argc--;
+			*dirList++ = argv[0];
+		} else if ( strncmp( argv[0], "-width", 2 ) == 0 ) {
+			argv++; argc--;
+			listWidth = lineWidth = atoi(argv[0]);
+			if (lineWidth < 10) {
+				fprintf( stderr, "Invalid linewidth %s\n", argv[0] );
+				exit(1);
+			}
+		} else if ( strncmp( argv[0], "-mt", 3 ) == 0 ) {
+			argv++; argc--;
+			MarginTop = atof( *argv );
+		} else if ( strncmp( argv[0], "-mb", 3 ) == 0 ) {
+			argv++; argc--;
+			MarginBottom = atof( *argv );
+		} else if ( strncmp( argv[0], "-mr", 3 ) == 0 ) {
+			argv++; argc--;
+			MarginRight = atof( *argv );
+		} else if ( strncmp( argv[0], "-ml", 3 ) == 0 ) {
+			argv++; argc--;
+			MarginLeft = atof( *argv );
+		} else if ( strncmp( argv[0], "-mg", 3 ) == 0 ) {
+			argv++; argc--;
+			MarginGutter = atof( *argv );
+		} else if ( strncmp( argv[0], "-toc", 4 ) == 0 ) {
+			toc++;
+		} else {
+			fprintf( stderr, "unrecognized option: %s\n", argv[0] );
+			exit( 1 );
+		}
+		argv++;argc--;
+	}
+
+	if (curMode == NULL) {
+		fprintf( stderr, "Must spec either -mswhelp or -xv\n" );
+		exit(1);
+	}
+	if ( argc != 2 ) {
+		fprintf( stderr, "Usage: prochelp [-mswhelp|-xv] <INF> <OUTF>\n" );
+		exit( 1 );
+	}
+
+	curMode->start( argv[0], argv[1] );
+	process( ifile );
+	fclose( ifile );
+	curMode->finish();
+		
+	exit(0);
+}