/*
 *		Installierung der Druckeranpassungstabelle PRINTER.DOT
*/

#include  <osbind.h>
#include  <gemdefs.h>
#include  <define.h>

#define	byte	unsigned char

byte	*buffer;			/* Puffer fuer die Eingabe	*/
long	buf_size = 8000;	/* Puffergroesse			*/
char	path[64];			/* Name der Eingabedatei	*/
int		file;				/* Eingabedatei - handle	*/
long	file_size;			/* Laenge der Eingabedatei	*/

main ()
{
	appl_init ();
	if (file_select (path, "*.TAB"))
		tab_set();
	appl_exit ();
}


/*****   Quelldatei einlesen   *****/

int		eof;		/* Flag fuer Dateiende */

read_char ()
{
	static byte  *s;
	static long  n;				/* Pufferinhalt */

	if (n <= 0) {						/* Puffer leer ? */
		if (file_size <= 0) {
			eof = TRUE;
			return (-1);
		}
		n = file_size < buf_size ? file_size : buf_size;
		file_size -= n;
		Fread (file, n, s = buffer);
	}
	n--;
	return (*s++);
}


/*****   Lies naechstes Quelltextzeichen   *****/

byte	line[160];			/* Eingabezeile		*/
int		ch;					/* Zeichen			*/
int		line_len;			/* Zeilenlaenge		*/
int		line_number;		/* akt. Zeile		*/
int		column;				/* akt. Spalte		*/
int		new_char;			/* ch ist aktuell	*/

get_char ()
{
	new_char = TRUE;

	if (column >= line_len)
		if (!get_line())
			return (ch = -1);				/* Dateiende */

	while ((ch = line[column++]) == '\r');

	return (ch);
}


/*****   Lies naechste Quelltextzeile   *****/

get_line ()
{
	register byte  *l = line;
	register int   i, c;

	if (eof)
		return (FALSE);

	for (i = 0; i < 160;) {
		if ((c = read_char()) < 0)
			break;
		if (c == '\t') {			/* Tabulator */
			do
				*l++ = ' ';
			while (++i & 0x7);		/* Tab size = 8 */
			continue;
		}
		i++;
		if ((*l++ = c) == '\n')		/* Zeilentrenner */
			break;
	}
	line_number++;
	column = 0;
	return (line_len = i);   
}


/*****   Lies naechstes Symbol -> symbol   *****/

int		symbol;
byte	value;

#define	EOF		0
#define	RETURN	1
#define	NUMBER	2
#define	COMMA	3

new_sym ()
{
	return (symbol = get_symbol());
}

get_symbol ()
{
	register int	comment = FALSE;	/* Flag fuer Kommentar */
	register int	c;					/* Quelltextzeichen */
	register long	n;

	c = new_char ? ch : get_char();

	while (TRUE) {
		if (c < 0)						/* Dateiende */
			return (EOF);
		if (c == '\\') {				/* Fortsetzungszeile */
			if (get_char() == '\n')
				goto next;
			if (!comment)
				error ("'\\n' expected");
			continue;
		}
		if (c == '\n') {				/* Zeilenende */
			new_char = FALSE;
			return (RETURN);
		}
		if (c == '*')					/* Kommentaranfang */
			comment = TRUE;
		if (comment)
			goto next;
		if (c == ' ')
			goto next;
		if (c == ',') {
			new_char = FALSE;
			return (COMMA);
		}
		if ((n = hex(c)) >= 0) {
			while ((c = hex(get_char())) >= 0) {
				n <<= 4;
				n += c;
			}
			value = n;
			return (NUMBER);
		}

		error ("lexical error");

next:	c = get_char();

	}
}


/*****   Fehlerbehandlung   *****/

error (message)
char  message[];
{
	static int	last_line;
	char  position[4];

	if (!last_line)
		if (form_alert (1, "[1][Error detected][ Print | Cancel]") == 2)
			Pterm (1);
	if (line_number != last_line) {
		out ("\r\n");
		Fwrite (3, (long) line_len, line);
	}
	last_line = line_number;
	out ("\tcolumn  ");
	itoa (column, position);
	out (position);
	out ("\t");
	out (message);
	out ("\r\n");
}

out (s)
register char  *s;
{
	while (*s)
		Cprnout (*s++);
}


/*****   Konvertierungstabelle aufbauen   *****/

tab_set ()
{
	register int	*convert;		/* Zeichentabelle -> Code */
	register byte	*code;			/* enthaelt die Ersetzungszeichen */
	register int	fh, n;
	register int	offset = 0;
	register int	old;

	if ((file = Fopen (path, 0)) < 0) {
		form_alert (1, "[3][Can't open input file ... ][ Cancel ]");
		return;
	}
	file_size = Fseek (0L, file, 2);
	Fseek (0L, file, 0);

	convert = (int*) Malloc (768L);
	buffer = (byte*) Malloc (buf_size);
	if (!(convert  &&  buffer)) {
		form_alert (1, "[3][not enough memory available ... ][ Cancel ]");
		return;
	}
	code = (byte*) (convert += 256);
	for (n = 256; n > 0; n--)
		*--convert = -1;

	fh = Fcreate ("printer.dot", 0);
	Fwrite (fh, 512L, convert);			/* reserviere 512 bytes */

	new_sym();				/* lies erstes Symbol */

	while (TRUE) {
		if (symbol == NUMBER) {
			old = value;					/* altes Zeichen */
			n = 1;
			while (TRUE) {
				if (new_sym() == COMMA)		/* optional */
					if (new_sym() != NUMBER)
						error ("NUMBER expected");
				if (symbol != NUMBER)
					break;
				code[n++] = value;			/* Ersetzungszeichen */
			}
			if (symbol == RETURN) {
				code[0] = (byte) n;
				Fwrite (fh, (long) n, code);
				convert[old] = offset;
				offset += n;
				new_sym();
			} else 
				error ("missing 'RETURN'");
		}
		else if (symbol == EOF)
			break;
		else {
			if (symbol != RETURN)
				error ("Symbol ignored");
			new_sym();
		}
	}
	Fseek (0L, fh, 0);
	Fwrite (fh, 512L, convert);
	Fclose (fh);
	Fclose (file);

}


/*****   Hexadezimalzahl ?   *****/

hex (c)
register int  c;
{
	if (c > 0x60)
		c -= 0x20;			/*  -> Grossbuchstabe  */
	if (c > '9') {
		c -= 'A';
		if (c < 0 || c > 5)
			return (-1);
		return (c + 10);
	}
	return (c - '0');
}