/*
   MAKFNT - Font editor
   A Christopher Hall fecit
*/
#include <bdscio.h>
#include <hardware.h>

#define DEBUG	0		/* Debug assembly switches */
#define DEBUG1	0

/* Command invocations: */
#define	XRIGHT	4	/* Cursor right */
#define	XLEFT	19	/* Cursor left */
#define	XUP	5	/* Cursor up */
#define	XDOWN	24	/* Cursor down */
#define	XTAB	9	/* Tab */
#define	XBTAB	21	/* Back-tab */
#define	XUPTAB	15	/* Up-tab */
#define	XDNTAB	16	/* Down-tab */
#define	XBLINE	'4'	/* Move to start of line */
#define	XELINE	'6'	/* Move to end of line */
#define	XHOME	'1'	/* Move cursor home */
#define	XRETRN	13	/* Carriage return */
#define	XRUB	127	/* Rub out blot before cursor */
#define	XEEOL	10	/* Erase to end of line */
#define	XREWRT	'5'	/* Re-write the screen */
#define	XSAVEC	'0'	/* Save defined character */
#define	XRCALL	'.'	/* Recall saved character */
#define	XKILL	11	/* Kill (delete) saved character */
#define	XINROW	'9'	/* Insert row */
#define	XDLROW	'-'	/* Delete row */
#define	XINCOL	'7'	/* Insert column */
#define	XDLCOL	'8'	/* Delete column */
#define	XERASE	','	/* Erase current character */
#define	XSTHGT	'3'	/* Set new height */
#define	XFREAD	18	/* Read font file */
#define	XFWRIT	6	/* Write font file */
#define	XFAPP	1	/* Append font file */
#define	XSTINC	'2'	/* Set new direction increment */
#define	XFLIPV	22	/* Flip character vertically */
#define	XFLIPH	2	/* Flip character horizontally */
#define	XEXIT	3	/* Exit editor */

/* Screen manipulation sequences: */
#define	CLEAR	"\033[H\033[J"	/* Clear the screen and move home */
#define	CUP	"\033[A"	/* Move cursor up */
#define	CDOWN	"\033[B"	/* Move cursor down */
#define	CRIGHT	"\033[C"	/* Move cursor right */
#define	CLEFT	"\010"		/* Move cursor left */
#define	CEOL	"\033[K"	/* Clear from cursor to end of line */

/* Program parameters: */
#define	EOF	0		/* End-of-file return value */
#define	CHEIGHT	24		/* Maximum height a character will be */
#define	CWIDTH	53		/* Ditto, width */
#define	TOTCHR	100		/* Number of characters which can be defined */
#define	MSGMGN	55		/* Column to start outputting messages */

int	i,j;			/* Scratch counters */
int	row,col;		/* Current row, column position */
int	hr,hc;			/* Home row, column, for CRLF's */
char	charac[CHEIGHT+1][CWIDTH+1]; /* Character array */
int	height;			/* Height of current character */
char	cmd;			/* Command the user typed */
char	chr;			/* Single character */
char	*ptr;			/* General-purpose pointer */
int	right;			/* Farthest right the user has made a mark */
char	inspac;			/* Number of spaces to put between chars */
char	inlins;			/* Number of lines to put between lines */
char	incdir;			/* Direction of increment after type-in */

int	cmask[6];		/* 2**(n+1), given n */
char	string[400];		/* String of terminal type-in */

char	filspc[20];		/* Name of input file */
int	iobuf[BUFSIZ];		/* Buffer area for file I/O */

int	finx;			/* Index of latest character to save */
char	*fptr;			/* Pointer to freespace */
char	frenam[TOTCHR];		/* Names of characters saved in freespace */
char	*freptr[TOTCHR];	/* Pointers ditto */
char	frelen[TOTCHR];		/* Lengths ditto */
char	frespc[10000];		/* Space to save finished characters */
char	clfflg;			/* Flag: clear freespace when reading font */

main(argc,argv)
 char **argv;   {

	initw(cmask,"1,2,4,8,16,32,64");
	clrfre();		/* Clear out and init freespace */
	right = 0;		/* Init rightmost high water mark */
	height = 12;		/* Set a good default height */
	drawfnc();		/* Draw the default fence; init row,col */
	poshom();		/* Home the cursor */
	incdir = 4;		/* Set typein increment to "right" */
	hc = 1;			/* Set CRLF's column to be left margin */

	while(1) {
	  switch(cmd = readchr()) { /* Read a command and dispatch */
	    case XEXIT:		/* Quit */
		typstg(CLEAR);
		exit();
	    case XUP:		/* Cursor up */
		if (--row < 1) poscur((row=height),col);
		else typstg(CUP);	/* Else just move up */
		break;
	    case XRETRN:	/* Carriage return */
		if (hr) {
			row = hr;
			if (++col > CWIDTH) col = 1;
		}
		else {
			col = hc;
			if (++row > height) row = 1;
		}
		poscur(row,col);
		break;
	    case XDOWN:		/* Cursor down */
		if (++row > height) poscur((row=1),col);
		else typstg(CDOWN);	/* Else just move down */
		break;
	    case XRIGHT:	/* Cursor right */
		if (++col > CWIDTH) poscur(row,(col=1));
		else typstg(CRIGHT);
		break;
	    case XLEFT:		/* Cursor left */
		if (--col < 1) poscur(row,(col=right+1));
		else typstg(CLEFT);
		break;
	    case XEEOL:		/* Erase to end of line */
		for (i=col; i<=right; i++) charac[row][i] = 0;
		typstg(CEOL);
		break;
	    case XFREAD:	/* Read a font file */
		clfflg = 1;	/* Tell readfnt to clear freespace; fall */
	    case XFAPP:		/* Append font to current one */
		readfnt();
		drawfnc();	/* Re-draw the screen */
		rewrite();
		break;
	    case XFWRIT:	/* Write file */
		wrtfil();
		drawfnc();	/* Re-draw the screen */
		rewrite();
		break;
	    case XKILL:		/* Delete saved letter */
		dellet();
		rewrite();
		break;
	    case XBLINE:	/* Move to beginning of line */
		poscur(row,col=1);
		break;
	    case XTAB:		/* Goto next mark/blank change (or vva) */
		chr = charac[row][col++]; /* Get what's at the cursor */
		i = col;		/* Save starting column position */
		for (; col<CWIDTH; col++)
			if (charac[row][col] != chr) break;
		if (col == CWIDTH)	/* If none move to tab stop or start */
			if ((col = 9 + (i & ~7)) >= CWIDTH) col = 1;
		poscur(row,col);
		break;
	    case XBTAB:		/* Move to previous mark change */
		chr = charac[row][--col]; /* Get what's at cursor */
		for (; col>1; col--)
			if (charac[row][col] != chr) break;
		if (col++ <= 1) col = 1;
		poscur(row,col);
		break;
	    case XDNTAB:	/* Down-tab */
		chr = charac[row++][col]; /* Get what's at the cursor */
		i = row;		/* Save starting row position */
		for (; row<=height; row++)
			if (charac[row][col] != chr) break;
		if (row > height)	/* If none move to top */
			if ((row = 5 + (i & ~3)) > height) row = 1;
		poscur(row,col);
		break;
	    case XUPTAB:	/* Up-tab */
		chr = charac[--row][col]; /* Get what's at cursor */
		for (; row>1; row--)
			if (charac[row][col] != chr) break;
		if (row++ <= 1) row = 1;
		poscur(row,col);
		break;
	    case XELINE:	/* Move to last mark on line */
		for (col=CWIDTH; col>1; col--)
			if (charac[row][col]) break;
		poscur(row,++col);
		break;
	    case XHOME:		/* Move cursor home */
		poscur((row=1),(col=1));
		break;
	    case XERASE:	/* Erase complete character */
		if (!verify(0)) { /* Verify answer; if not, */
			poscur(row,col); /* Put the cursor back */
			break;		/* And forget the command */
		}
		clrchr();	/* Erase the character array */
		rewrite();	/* Remove character from screen */
		poshom();	/* Move the cursor home */
		break;
	    case XREWRT:	/* Re-write screen */
		drawfnc();
		rewrite();
		break;
	    case XSTINC:	/* Set direction of increment */
		query("Type new direction");
		switch (chr = readchr()) {
		  case XRIGHT:		/* Right, left */
		  case XLEFT:
			incdir = chr;
			hr = 0; hc = col;
			break;
		  case XUP:		/* Up, down */
		  case XDOWN:
			incdir = chr;
			hr = row; hc = 0;
			break;
		  case XRETRN:		/* CR == right the default way */
			incdir = 4;
			hr = 0; hc = 1;
			break;
		  default:		/* Anything else is an error */
			typchr('\007');
		}
		query(CEOL);	/* Clear the query line */
		poscur(row,col); /* Put the cursor back in the text */
		break;
	    case XSTHGT:	/* Set height of character */
		query("Type new height: ");
		i = getnum(); /* Get the new height and re-draw */
		if (!verify(0)) { /* Verify answer; if not, */
			query(CEOL);	/* Clear the query line */
			poscur(row,col); /* Put the cursor back */
			break;		/* And forget the command */
		}
		height = i;	/* Else make the change permanent */
		clrchr();
		drawfnc();
		rewrite();
		poshom();	/* Move the cursor home */
		break;
	    case XRUB:		/* Erase character before cursor */
		if (col > 1) {
			charac[row][--col] = 0;
			typstg("\010 \010");
		}
		break;
	    case XSAVEC:	/* Encode and save character */
		encode();	/* Find what to save it as and do so */
		rewrite();	/* Rewrite the screen */
		break;
	    case XRCALL:	/* Decode a saved character */
		decode();	/* Ask for and decode the character */
		rewrite();	/* Display it */
		break;
	    case XINCOL:	/* Insert a blank column at cursor */
		for (i=1; i<=height; i++)
		  for (j=right+1; j>col; j--)
			charac[i][j] = charac[i][j-1];
		for (i=1; i<=height; i++) charac[i][col] = 0;
		right++;	/* Bump rightmost high-water mark */
		rewrite();
		break;
	    case XDLCOL:	/* Delete the column at the cursor */
		for (i=1; i<=height; i++)
		  for (j=col; j<=right; j++)
			charac[i][j] = charac[i][j+1];
		rewrite();
		break;
	    case XINROW:	/* Insert a blank row at cursor */
		for (i=height; i>row; i--)
		  for (j=1; j<=right; j++)
			charac[i][j] = charac[i-1][j];
		for (j=1; j<=right; j++) charac[row][j] = 0;
		rewrite();
		break;
	    case XDLROW:	/* Delete the row at the cursor */
		for (i=row; i<height; i++)
		   for (j=1; j<=right; j++)
			charac[i][j] = charac[i+1][j];
		for (j=1; j<=right; j++) charac[height][j] = 0;
		rewrite();
		break;
	    case XFLIPV:	/* Flip character vertically */
		i = 1; j = right;
		do {
		    for (row=1; row<=height; row++) {
			chr = charac[row][i];
			charac[row][i] = charac[row][j];
			charac[row][j] = chr;
		    }
		} while (++i < --j);
		row = col = 1;
		rewrite();
		break;
	    case XFLIPH:	/* Flip character horizontally */
		i = 1; j = height;
		do {
		    for (col=1; col<=right; col++) {
			chr = charac[i][col];
			charac[i][col] = charac[j][col];
			charac[j][col] = chr;
		    }
		} while (++i < --j);
		row = col = 1;
		rewrite();
		break;
	    case ' ':		/* Erase mark at cursor location */
		charac[row][col++] = 0;
		typchr(' ');	/* Erase it on the screen, too */
		if (incdir != 4) adjpos(); /* Adjust if inc is not "right" */
		break;
	    default:			/* Anything else: */
		if (cmd > ' ') {	/* If printing, make mark */
		  charac[row][col++] = 1; /* At cursor location */
		  typchr('X');		/* And on screen */
		  if (incdir != 4) adjpos(); /* Adjust if inc is not "right" */
		}
		else typchr('\007');	/* Else beep for unknown command */
	  }				/* End switching */
	  if ((i = col-1) >= right) {	/* If moved to a new right position */
					/* Save new high water mark */
		if (charac[row-1][col] || charac[row+1][col]) right = col;
		else if (charac[row][i]) right = i;
		typwid();		/* Display the width */
		poscur(row,col);	/* Position back in the character */
	  }
	} /* End while (1) */
}
/*
   ADJPOS - Here if incdir is not 4. If it is, the cursor, after typein or
   erase, should be positioned to the right of the character typed. If not,
   the cursor should be above, below, or to the left of the character.
*/
adjpos() {
	col--;			/* Move column back */
	if (incdir == 5) row--;	/* Position above */
	else if (incdir == 19) col--; /* To the left */
	else if (incdir == 24) row++; /* Below */
	poscur(row,col);	/* Position in the right direction */
}
/*
   QUERY - Position the the query line and output the given text
*/
query(stg)
  char *stg; {
	poscur(3,MSGMGN);
	typstg(stg);
}
/*
   TYPWID - Display the width of the character
*/
typwid() {
	poscur(2,MSGMGN);
	sprintf(string,"Width: %d  ",right);
	typstg(string);
}
/*
   REWRITE - Rewrite the entire screen
*/
rewrite() {
	int rrow,rcol;

	for (rrow=1; rrow<=height; rrow++) {
	    poscur(rrow,1);
	    typstg(CEOL);	/* Clear to end of line */
	    for (rcol=1; rcol<=right; rcol++)
		typchr((charac[rrow][rcol]) ? 'X' : ' ');
	}
	if (*filspc) {
		poscur(1,MSGMGN); /* Display the filespec */
		typstg(filspc);	  /* If there is one */
	}
	typwid();	/* Display the character's width */
	tydchrs();	/* Say which characters have been defined */
	poscur(row,col); /* Put the cursor back */
}
/*
   CLRCHR - Erase the charac[][] character definition array
*/
clrchr() {
	int i,j;

	for (i=0; i<=height; i++)
	  for (j=0; j<=right; j++)
	    charac[i][j] = 0;
	right = 0;	/* Clear rightmost high-water mark */

}
/*
   DELLET - Delete saved character
*/
dellet() {
	int f;

	query("Delete: ");
	chr = readche();	/* Get the answer */
	if (!verify(chr)) return; /* Get, verify answer; return if not v'ed */

	for (f=0; f<finx; f++) if (frenam[f] == chr) break;
	if (f == finx) {
		typchr('\007');	/* If not there, beep */
		return;		/* And do nothing */
	}
	frenam[f] = 0;		/* Else clear the name */
}
/*
   ENCODE - Encode the character in charac[][] and save in freespace
*/
encode() {
	int f,i,j,k;		/* Scratch counters */
	int width;		/* Width of character */
	char chr;		/* Character being formed */

	query("Save as: ");
	if ((chr = readche()) < ' ') {
		if (chr != 13) return; /* Ignore c-chars, except scratch */
		chr = 0;	/* If scratch, set up index */
	}
	if (!verify(chr)) return; /* Get, verify answer; return if not v'ed */

	if (!chr) f = TOTCHR - 1; /* If scratch save in highest location */
	else {
		for (f=0; f<finx; f++) if (frenam[f] == chr) break;
		if (f == finx) finx++;	/* See if character already there */
	}
	width=1;
	for (i=1; i<=height; i++) /* Find how wide the character is */
	  for (j=width; j<=right; j++)
		if (charac[i][j]) width = j;
	frelen[f] = width;		/* Save width of this character */
	frenam[f] = chr;		/* Save the character name */
#if DEBUG
	printf("\nCharacter %c is %d wide\n",frenam[f],width);
#endif
	freptr[f] = fptr;		/* Save pointer to start of string */
	for (k=1; k<height; k+=6) {	/* For each encoded row */
	  for (j=1; j<=width; j++) {	/* For each column */
	    chr = '?';			/* Start with a 0 character */
	    for (i=0; i<6; i++) {	/* For each row of encoding */
		if (charac[i+k][j]) chr += cmask[i];
	    }				/* Make the character from its bits */
#if DEBUG
	printf("char=%3o %c\n",chr,chr);
#endif
	    *fptr++ = chr;	/* Save encoded character */
	  }
	  *fptr++ = ',';	/* End row with a comma */
	}
	*(fptr-1) = 0;		/* Overwrite last comma with a null */
#if DEBUG
	printf("String: %s\n",freptr[f]);
	bios(3);
#endif
	tydchrs();		/* Output which characters have been defined */
}
/*
   VERIFY - Reflect chr to the user and ask if it's right. Y, y, or CR mean
   yes (return 1); anything else means no (return 0).
*/
char verify(chr)
  char chr;	 {
	char vch;

	poscur(5,MSGMGN);	/* Position to verify */
	sprintf(string,"Verify: %c (y,n): ",chr);
	typstg(string);
	if ((vch = toupper(readche())) == 'Y') return(1);
	return(vch == '\015');	/* Return 1 if == CR, else 0 */
}
/*
   TYDCHRS - Output which characters have been defined
*/
tydchrs() {
	int i,row,col;
	char j;

	poscur(15,MSGMGN);
	typstg("Defined characters:");
	poscur((row=16),(col=MSGMGN));
	j = 5;
	for (i=0; i<finx; i++) {
		typchr(frenam[i]);
		if (--j == 0) {		/* Put only 10 on a line */
			typchr(' ');	/* Space over in case one deleted */
			if (row == 23) { row=15; col +=6; }
			poscur(++row,col);
			j = 5;
		}
	}
	typchr(' ');			/* End last line with a space */
}
/*
   DECODE - Decode the character named dchr into charac[][]
   Gives an error message and does nothing harmful if character not found
*/
decode() {
	char dchr;
	int i,j,k,index;
	char *cpt;
	char chr;

	query("Which character: ");
	if ((dchr = readche()) < ' ') {
		if (dchr != 13) return; /* Ignore control chars, except CR */
		index = TOTCHR - 1;
	}
	else {
		for (index=0; index<finx; index++)
			if (frenam[index] == dchr) break;
		if (index == finx) {	/* If not found, beep and return */
			typchr('\007');
			return;
		}
	}
	clrchr();			/* Wipe the character array */
	right = frelen[index];		/* Get character width */
	cpt = freptr[index];		/* Point to definition string */
	
	for (k=1; k<height; k+=6) {	/* For each encoded row */
	  for (j=1; j<=right; j++) {	/* For each column */
	    chr = (*cpt++) - '?';	/* Get next encoded character */
	    for (i=0; i<6; i++) {	/* For each row of encoding */
		if (chr & cmask[i]) charac[i+k][j] = 1;
#if DEBUG
	poscur(1,-2);
	printf("Chr=%3o =%c cmsk=%d and=%d",chr,*(cpt-1),cmask[i],
		(chr & cmask[i]));
	bios(3);
#endif
	    }
	  }
	  *cpt++;		/* Skip comma between rows */
	}
}
/*
   READFNT - Read a font file and store the characters
*/
readfnt() {
	int length,h,f;
	char ch1;

	query("Read what font file: ");
	if (!getfile()) return;	/* Read the filespec; return if not verified */
	if (fopen(string+200,iobuf) == ERROR) {
		sprintf(string+100,"\007Can't find %s",string+200);
		typerr(string+100);
		return;		/* But we can still be friends */
	}
	if (clfflg) {
		clrfre();	/* If caller wants, clear freespace */
		clfflg = 0;	/* Reset clear-it flag */
	}
#if DEBUG
	printf("%s",CLEAR);
#endif
	getfnl();		/* Read a line from the file */
#if DEBUG
	printf("Got the height line\n");
#endif
	if (0 == (h = atoi(string))) {
		typerr("\007No height in font");
		fclose(iobuf);	/* Close the file */
		return;		/* And proceed */
	}
	height = h * 6;
#if DEBUG
	printf("Height=%d\n",height);
#endif
	getfnl();		/* Read the i-c space line and skip it */
#if DEBUG
	printf("Got the intra-space line\n");
#endif
	if (0 == (inspac = atoi(string))) {
		typerr("\007No char spacing in font");
		fclose(iobuf);	/* Close the file */
		return;		/* And proceed */
	}
#if DEBUG
	printf("Inspac=%d\n",inspac);
#endif
	getfnl();		/* Read a line from the file */
#if DEBUG
	printf("Got the intra-line line\n");
#endif
	if (0 == (inlins = atoi(string))) {
		typerr("\007No line spacing in font");
		fclose(iobuf);	/* Close the file */
		return;		/* And proceed */
	}
#if DEBUG
	printf("Inlins=%d\n",inlins);
#endif
	while (EOF != getfnl()) {	/* Get a character definition line */
#if DEBUG
	printf("Char: %c  string: %s",chr,ptr);
#endif
		for (f=0; f<finx; f++) if (frenam[f] == chr) break;
		if (f == finx) finx++;
		frenam[f] = chr;	/* Save its name */
		ptr++;			/* Skip to the length - skip name */
		while (*ptr++ != ',');	/* Plus any other chars before "," */
#if DEBUG
	printf("Rest of string: %s",ptr);
#endif
		if (0 == (length = atoi(ptr))) {
			sprintf(string+100,"\007Bad length for %c",frenam[f]);
			typerr(string+100);
			fclose(iobuf);	/* Close the file */
			return;		/* And proceed */
		}
		frelen[f] = length;	/* Save the length */
#if DEBUG
	printf("Length=%d\n",length);
#endif
		while (*ptr++ != ',');	/* Skip to the flags */
#if DEBUG
	if (*ptr != ',')
		printf("This letter has flags: %c\n",frenam[f]);
#endif
		while (*ptr++ != ',');	/* Skip to the definitions strings */
#if DEBUG
	printf("Rest of string: %s",ptr);
#endif
		freptr[f] = fptr;	/* Store pointer to string */
		for (i=0; i<h; i++) {	/* Copy a row of def'n */
			if (*ptr == '\n') {	/* If line ends early, */
				getfnl();	/* Read continuation line */
				if (chr == ' ') while(*++ptr == ' ');
			}
			if (*ptr == ',') for (j=0; j<length; j++) *fptr++ ='?';
			else for (j=0; j<length; j++) *fptr++ = *ptr++;
					/* Comma better follow the row */
			if ((chr = *ptr++) != ',') {
			  if (chr != '\n') {
			    sprintf(string+100,
				"\007Bad length for %c",frenam[f]);
			    typerr(string+100);
			    fclose(iobuf); /* Close the file */
			    return;	/* And proceed */
			  }
			}
			else *fptr++ = chr; /* Else store the comma */
		}
		if (*--fptr != ',') fptr++;
		*fptr++ = 0;		/* End the string with a null */
#if DEBUG
	printf("String: %s\n",freptr[f]);
	printf("Done with a character\n");
#endif
	}		/* End processing for this character definition */
	fclose(iobuf);	/* Close the file; done */
}
/*
   GETFILE - Get a font filespec. Appends ".fnt" to the string the user types.
   Returns 1 if user verifies the filespec, else 0.
*/
char getfile() {
	poscur(4,MSGMGN+2);
	getline(string+200,20);	/* Read the response */
	if (!*(string+200)) {	/* If just a CRLF use default filespec */
		strcpy(string+200,filspc);
		poscur(4,MSGMGN+2); /* Tell user what it is */
		typstg(filspc);
	}
	else {
		strcat(string+200,".FNT"); /* Else append the file type */
		strcpy(filspc,string+200); /* And save the new string */
	}
	return(verify(0));	/* Return 1 if verified, else 0 */
}
/*
   GETFNL - Read a line from the file. Skip comments (line starts with ";;")
   Returns EOF if end of file found. Also, chr is set to the first character
   of the line and ptr is set to point to the start of the line.
*/
int getfnl() {
	while (1) {
		if (EOF == (ptr = fgets(string,iobuf))) return(EOF);
#if DEBUG
	printf("Read: %s",string);
#endif
		if ((chr = *ptr) == '\n') continue; /* Skip blank lines */
		if (chr != ';') break;	/* Approve all but ";;" lines */
		if (*(ptr+1) != ';') break;
	}
	return(!EOF);		/* Say it's not EOF yet */
}
/*
   WRTFIL - Save collected definitions in font file
*/
wrtfil() {
	char ch1,och,flg;
	int cix,h;
	char *sptr,*optr;

	if (!finx) {		/* If nothing defined, error and forget it */
		typerr("\007No font is defined");
		return;
	}
	query("Write what font file: ");
	if (!getfile()) return;	/* Read the filespec; return if not verified */
	if (fcreat(string+200,iobuf) == ERROR) {
		sprintf(string+100,"\007Can't create file %s",string+200);
		typerr(string+100);
		return;		/* But we can still be friends */
	}
	fprintf(iobuf,";;Height\n%d\n",(h=height/6)); /* Output the height */
	if (!inspac) {
		typstg("Type number of spaces to put between characters: ");
		inspac = getnum();
	}
	fprintf(iobuf,";;Intra-character spacing\n%d\n",inspac);

	if (!inlins) {
		typstg("Type number of lines to put between lines: ");
		inlins = getnum();
	}
	fprintf(iobuf,";;Intra-line spacing\n%d\n",inlins);
	inlins = inspac = 0;

	if (frenam[0] != ' ') {	/* If no space is defined (first) */
		typstg("How long is a word space: ");
		cix = getnum();
		fprintf(iobuf," ,%d,",cix); /* Output it */
		for (i=0; i<=h; i++) putc(',',iobuf);
		fputs("\n",iobuf);
	}

	och = 0;		/* Clear previous character holder */
	do {
		chr = cix = 255;
		for (i=0; i<finx; i++) { /* Output for each character */
		    ch1 = frenam[i];
		    if ((ch1 != 0) & (ch1 < chr)) {
			chr = ch1;
			cix = i;
#if DEBUG
	printf("  %d Saving cix=%d chr=%c %3o\n",i,cix,chr,chr);
#endif
			if (chr == och) break;
		    }
#if DEBUG
	else
	printf("  %d Rejecting ch1=%c %3o chr=%c %3o\n",i,ch1,ch1,chr,chr);
#endif
		}
#if DEBUG
	printf("Outputting cix=%d chr=%c %3o\n",cix,chr,chr);
#endif
		if (cix != 255) {
		    och = chr+1; /* Save character output + 1 */
		    fprintf(iobuf,"%c,%d,,",frenam[cix],frelen[cix]);

		    ptr = freptr[cix];	/* Point to start of definition */
		    sptr = string;	/* Point to start of string area */
		    do {
			optr = sptr;	/* Save ptr to start of this string */
			flg = 0;	/* Clear found-non-'?' flag */
			while ((*sptr++ = chr = *ptr++) != ',' && chr != 0)
			    if (chr != '?') flg = 1;
			if (!flg) {
			    sptr = optr; /* If only '?'s don't output them */
			    *sptr++ = ',';
#if DEBUG
	*sptr = 0;
	printf("Erasing row of '?'s: %s\n",string);
#endif
			}
		    } while (chr);
		    *sptr = 0;		/* End string with a null */
#if DEBUG
	printf("String: %s\n",string);
#endif
		    if ((sptr-string) <= 72) fprintf(iobuf,"%s\n",string);
		    else {
#if DEBUG
	printf("Outputting in multi-lines\n");
#endif
			ptr = string;
			while (chr = *ptr++) {
			    putc(chr,iobuf);
			    if (chr == ',') 
				if (*ptr) fputs("\n ",iobuf);
			}
			fputs("\n",iobuf);
		    }
		    frenam[cix] = 0;
		}
	} while (cix != 255);
	putc(CPMEOF,iobuf);	/* End the file */
	fclose(iobuf);		/* Make the file real */
	clrfre();		/* Clear out free space */
}
/*
   CLRFRE - Clear out freespace
*/
clrfre() {
	finx = 0;		/* Say no characters are saved */
	fptr = frespc;		/* Point to start of freespace */
}
/*
   DRAWFNC - Draw the fence on the line below the height of the character
*/
drawfnc() {
	typstg(CLEAR);		/* Clear screen */
	if (height < CHEIGHT) {	/* Output the fence, if there's room */
		poscur(height+1,1); /* Position to start of fence line */
		for (i=0; i<CWIDTH; i++) typchr('_');
	}
	for (i=1; i<=height; i++) { /* Output line numbers */
		poscur(i,-2);
		sprintf(string,"%2d",i);
		typstg(string);
	}
}
/*
   TYPERR - Output an error message, wait a while, then erase it
*/
typerr(erstg)
  char *erstg; {
	poscur(7,MSGMGN);	/* Position to the error line */
	typstg(erstg);		/* Output the error message */
	sleep(20);		/* Wait a while */
	poscur(7,MSGMGN);	/* Erase the message */
	typstg(CEOL);
}
/*
   POSHOM - Move the cursor and the current position home
*/
poshom() {
	poscur((row=1),(col=1));
}
/*
   POSCUR - Position the cursor to (row,col)
*/
poscur(row,col) {
	sprintf(string,"\033[%d;%dH",row,col+3);
	typstg(string);		/* Output specially so no type-in is lost */
}
/*
   GETNUM - Read a number from the terminal
*/
int getnum() {
	char chr;
	char *spt;

	spt = string;		/* Read user's type-in into string */
	while ((chr = bios(3)) != '\015') {
		*spt++ = chr;
		typchr(chr);	/* Echo the character */
	}
	typstg("\015\012");	/* End with a CRLF */
	*spt = 0;		/* End string with a null */
	return(atoi(string));
}
/*
   READCHR - Read a character from the terminal (without echo)
*/
char readchr() {
	return(bios(3));
}
/*
   READCHE - Read a character from the terminal (with echo)
*/
char readche() {
	char chr;

	chr = bios(3);		/* Read the character */
	bios(4,chr);		/* Echo it */
	return(chr);		/* Return it to caller */
}
/*
   TYPCHR - Output a character to the terminal
*/
typchr(chr)
  char chr; {
	bios(4,chr);
}
/*
   TYPSTG - Output the given string to the terminal
   (The string terminates with a null).
*/
typstg(stg)
  char *stg; {
	char chr;

	while (chr = *stg++) bios(4,chr);
}