#include <mintbind.h>
#include <signal.h>
#include <atarierr.h>

#ifdef __GNUC__
#include <fcntl.h>
#include <ioctl.h>
#include <osbind.h>
#endif

#ifdef __TURBOC__
#include <filesys.h>
#endif

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

#include <treiber.h>

#define FALSE 0
#define TRUE 1

#define _SHOW_PRT_	/* Fortgang anzeigen */

/********************************************************************/
/* Externe routinen in Assembler (FAST_DVI.S) */
extern long	prn_byte( char *ptr, long byte );
extern void	exstall( void );

extern volatile long	anzahl, old_vec;
extern volatile char	*ptr;
/* 22.1.93 */

/********************************************************************/

/* Pufferspeicher */
static char	*puffer, *druck_puffer;
static long	puffer_laenge = 0L;

/* Shared Memory */
char				*shm_name;
static int	shm;
static char	*memory;

/* Name des tempor„ren Files */
char 				tmp_file[256];

#ifdef _SHOW_PRT_
char	disp_status[4]="\033Hp";
#endif

/********************************************************************/
/* Einige Routinen zum Druck */


void	disp_wait( void )
{
	while( old_vec  )
	{
		Fselect( 500, 0L, 0L, 0L );
#ifdef _SHOW_PRT_
		disp_status[2] ^= 1;
		Cconws( disp_status );
#endif
	}
}


	/* Gibt Puffer aus (SCHNELL!!) */
void	flush_block( void )
{
	Psignal( SIGINT, SIG_DFL );
	Psignal( SIGTERM, SIG_DFL );
	if(  puffer_laenge>0  )
	{
		disp_wait();
		memcpy( druck_puffer, puffer, puffer_laenge );
		prn_byte( druck_puffer, puffer_laenge );
	}
	puffer_laenge = 0;
	disp_wait();
}
/* 23.1.93 */



	/* Gibt an Spooler aus (SCHNELL!!) */
void	print_block( long laenge, char *blk )
{
	if(  laenge+puffer_laenge>8192L  )
	{
		disp_wait();
		if(  puffer_laenge>0  )
		{
			memcpy( druck_puffer, puffer, puffer_laenge );
			prn_byte( druck_puffer, puffer_laenge );
		}
		puffer_laenge = 0;
	}

		/* Zu lang... */
	if(  laenge>8192  )
	{
		prn_byte( blk, laenge );
		disp_wait();
	}
	else
	{
		memcpy( puffer+puffer_laenge, blk, laenge );
		puffer_laenge += laenge;
	}
}
/* 22.1.93 */



/* Versucht Drucker zu ™ffnen und zu Verriegeln! */ 
int	open_printer( void )
{
	int devh;

	puffer = Mxalloc( 8192L, 3 );	/* Speicher holen */
	druck_puffer = Mxalloc( 8192L, 3 );
	if(  druck_puffer<=0  ||  puffer<=0  )
		return -1;

		/* Druckersemaphore bekommen! (Wird bei Beendigung automatisch frei) */
	devh = (int)Psemaphore( 0, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );
	if(  devh!=0  )
		Psemaphore( 2, 0x50524E3AL /*PRN:*/, -1 /*Kein Timeout*/ );

#ifdef _SHOW_PRT_
	disp_status[2] = '*';
	Cconws( disp_status );
#endif

	while(  (devh=(int)Fopen( "U:\\dev\\prn", O_WRONLY ))==EACCDN  )
		Fselect( 100, 0L, 0L, 0L );
	Psignal( SIGINT, (long)exstall );
	Psignal( SIGTERM, (long)exstall );

	return devh;
}
/* 6.2.93 */



int		get_tempfile( char *drucker_ext )
{
	char	*p;
	long	lz;
	int		th;

	if(  tmp_file[0]==0  )
	{
		/* In tempor„re Datei drucken! */
		if(  (p=getenv("TMPDIR"))!=0L  )
		{
			strcat( tmp_file, p );
			if(  p[strlen(p-1)]!='\\'  )
				strcat( tmp_file, "\\" );
		}
		strcat( tmp_file, "print00." );
		lz = strlen(tmp_file)-2;
		strcat( tmp_file, drucker_ext );
		while(  (th=(int)Fopen(tmp_file,O_RDWR))>0  )
		{
			Fclose( th );
			if(  (++(tmp_file[lz]))=='9'  )
			{
				++(tmp_file[lz-1]);
				tmp_file[lz] = '0';
			}
		}
		th = (int)Fcreate( tmp_file, 0 );
	}
	else
		th = (int)Fopen( tmp_file, O_WRONLY|O_APPEND|O_CREAT );
#ifdef _SHOW_PRT_
	if(  th>=0  )
		Cconws( disp_status );
#endif
	return th;
}
/* 6.2.93 */



/********************************************************************/
/* Routinen f�r Optimierung */


/* Ist diese Zeile Leerzeile? */
int	ist_leerzeile( char *ptr, long offset )
{
	long	i;
	for(  i=0;  i<offset;  i++  )
		if(  *ptr++!=0  )
			return FALSE;
	return TRUE;
}
/* 16.1.93 */



/* Sind in den n„chsten #next Zeilen Zeichen? */
int	ist_next_leer( char *ptr, long offset, long next )
{
	while(  next>0  )
	{
		if(  *ptr!=0  )
			return FALSE;
		next--;
		ptr += offset;
	}
	return TRUE;
}
/* 16.1.93 */



/********************************************************************/
/* Hauptprogramm */


int	main( int argc, const char *argv[] )
{
	long	i;
	int		th, devh;

	if(  argc<6  )
	{
		Cconws( "Zuwenig Argumente!\xD\xA" );
		Cconws( "Richtig: shared_mem_file weite hoehe hdpi vdpi (file)\xD\xA" );
		return 0;
	}

 	/* Starte Ausdruck */
	ptr = 0L;

		/* Diese Routine mit Parameter versehen! */
		/* Es wird mit Shared Memory gearbeitet */
	shm_name = (char *)argv[1];
	shm = (int)Fopen( shm_name, O_RDONLY );
	if(  shm<0  )
		return -1;
	memory = (char *)Fcntl( shm, 0L, SHMGETBLK );
	if(  memory<=0  )
		return 0;
 	tmp_file[0] = 0;
	if(  argv[6]>0L  )
		strcpy( tmp_file, argv[6] );

	th = drucke( memory, atol(argv[2]), atol(argv[3]), atol(argv[4]), atol(argv[5]) );
	Mfree( memory );	/* so kann der Speicher wieder freigegeben werden */
	Fclose( shm );
	shm = 0;
	Cconws( "\033H " );

	if(  th<=0	&&  argv[6]>(char*)0	) /* || nach && umgewandelt 6.5.93 MH */
	{	/* Hier bei Fehler oder Funktion gibt selber aus! */
		if(  th<0  )
			Fdelete( tmp_file );
		return th;
	}

	/* Nur Datei erzeugen? */
	if(  argv[6]>0L  )
		return Fclose( th );

		/* Ab hier wird es ernst */
	if(  th<=1  ||  (devh=open_printer())<0  )
		return 0;
	Fseek( 0L, th, 0 );
	i = 8192L;
	do
	{
		disp_wait();
		i = Fread( th, i, druck_puffer );
		if(  i>0  )
			prn_byte( druck_puffer, i );
	}
	while(  i>0  );

	Fclose( th );
	if(  tmp_file[0]>0  )
		Fdelete( tmp_file );
	while( anzahl>0  )
	{
		Talarm( 1 );
		Pause();
	}
	Fclose( devh );
	flush_block();
	Cconws( "\033H " );
	return 1;
}
/* 17.1.93 */