fileprinter.cpp

// fileprinter.cpp
// Revision 9-jan-2005

#include "file.h"

#include "blassic.h"
#include "error.h"
#include "sysvar.h"
#include "showerror.h"

#include "trace.h"

// para strerror (errno)
//#include <string.h>
//#include <errno.h>

#include <iostream>
using std::cerr;
using std::endl;

#include <memory>
using std::auto_ptr;

#include <cassert>
#define ASSERT assert

#ifdef BLASSIC_USE_WINDOWS

#include <windows.h>
#undef min
#undef max

#else

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#endif

//***********************************************
//		Auxiliary functions
//***********************************************

namespace {

#ifdef BLASSIC_USE_WINDOWS

class GuardCharp {
public:
	GuardCharp (char * pc) :
		pc (pc)
	{ }
	~GuardCharp ()
	{
		delete [] pc;
	}
private:
	char * pc;
};

class GuardHMODULE {
public:
	GuardHMODULE (HMODULE h) :
		h (h)
	{ }
	~GuardHMODULE ()
	{
		FreeLibrary (h);
	}
private:
	HMODULE h;
};

class GuardHPRINTER {
public:
	GuardHPRINTER (HANDLE h) :
		h (h)
	{ }
	~GuardHPRINTER ()
	{
		ClosePrinter (h);
	}
private:
	HANDLE h;
};

std::string getdefaultprinter ()
{
	// This routine is based in several founded on the web,
	// correcting several errors and adapted to C++.
	OSVERSIONINFO osv;
	osv.dwOSVersionInfoSize= sizeof (OSVERSIONINFO);
	GetVersionEx (& osv);
	switch (osv.dwPlatformId)
	{
	case VER_PLATFORM_WIN32_WINDOWS:
		// Windows 95 or 98, use EnumPrinters
		{
			SetLastError (0);
			DWORD dwNeeded= 0, dwReturned= 0;
			EnumPrinters (PRINTER_ENUM_DEFAULT, NULL, 2,
				NULL, 0, & dwNeeded, & dwReturned);
			if (GetLastError () != ERROR_INSUFFICIENT_BUFFER ||
				dwNeeded == 0)
			{
				if (showdebuginfo () )
				{
					cerr << "EnumPrinters get buffer "
						"failed" <<
						endl;
					showlasterror ();
				}
				throw ErrBlassicInternal; // Provisional
			}
			char * aux= new char [dwNeeded];
			GuardCharp guardcharp (aux);
			PRINTER_INFO_2 * ppi2=
				reinterpret_cast <PRINTER_INFO_2 *> (aux);
			if (! EnumPrinters (PRINTER_ENUM_DEFAULT, NULL, 2,
				(LPBYTE) ppi2, dwNeeded,
				&dwNeeded, & dwReturned) )
			{
				if (showdebuginfo () )
				{
					cerr << "EnumPrinters failed" << endl;
					showlasterror ();
				}
				throw ErrBlassicInternal; // Provisional
			}
			return ppi2->pPrinterName;
		}
	case VER_PLATFORM_WIN32_NT:
		if (osv.dwMajorVersion >= 5) // Windows 2000 or later
		{
			HMODULE hWinSpool= LoadLibrary ("winspool.drv");
			if (! hWinSpool)
			{
				if (showdebuginfo () )
				{
					cerr << "LoadLibrary failed" << endl;
					showlasterror ();
				}
				throw ErrBlassicInternal;
			}
			GuardHMODULE guardh (hWinSpool);
			#ifdef UNICODE
			static const TCHAR GETDEFAULTPRINTER []=
				"GetDefaultPrinterW";
			#else
			static const TCHAR GETDEFAULTPRINTER []=
				"GetDefaultPrinterA";
			#endif
			PROC fnGetDefaultPrinter= GetProcAddress (hWinSpool,
				GETDEFAULTPRINTER);
			if (! fnGetDefaultPrinter)
			{
				if (showdebuginfo () )
				{
					cerr << "GetProcAddress failed" <<
						endl;
					showlasterror ();
				}
				throw ErrBlassicInternal;
			}
			typedef BOOL (* GetDefaultPrinter_t) (LPTSTR, LPDWORD);
			GetDefaultPrinter_t callGetDefaultPrinter=
				(GetDefaultPrinter_t) fnGetDefaultPrinter;
			DWORD dwBufferLength= 0;
			SetLastError (0);
			callGetDefaultPrinter (NULL, & dwBufferLength);
			if (GetLastError () != ERROR_INSUFFICIENT_BUFFER)
			{
				if (showdebuginfo () )
				{
					cerr << "GetDefaultPrinter get buffer "
						"failed" << endl;
					showlasterror ();
				}
				throw ErrBlassicInternal;
			}
			char * buffer= new char [dwBufferLength];
			GuardCharp guardcharp (buffer);
			if (! callGetDefaultPrinter
				(buffer, & dwBufferLength) )
			{
				if (showdebuginfo () )
				{
					cerr << "GetDefaultPrinter failed" <<
						endl;
					showlasterror ();
				}
				throw ErrBlassicInternal;
			}
			return std::string (buffer);
		}
		else // NT 4.0 or earlier
		{
			const DWORD MAXBUFFERSIZE= 250;
			TCHAR cBuffer [MAXBUFFERSIZE];
			if (GetProfileString ("windows", "device", ",,,",
				cBuffer, MAXBUFFERSIZE) <= 0)
			{
				if (showdebuginfo () )
					cerr << "GetProfileString failed" <<
						endl;
				throw ErrBlassicInternal;
			}
			strtok (cBuffer, ",");
			return std::string (cBuffer);
		}
	default:
		ASSERT (false);
		return std::string (); // Make the compiler happy.
	}
}

#else

class GuardHandle {
public:
	GuardHandle (int handle) :
		handle (handle)
	{
		TRACEFUNC (tr, "GuardHandle::GuardHandle");

		if (handle == -1)
		{
			if (showdebuginfo () )
				cerr << "GuardHandle with invalid handle" <<
					endl;
			throw ErrBlassicInternal;
		}
	}
	~GuardHandle ()
	{
		do_close (true);
	}
	void close ()
	{
		do_close (false);
	}
private:
	void do_close (bool destructing)
	{
		TRACEFUNC (tr, "GuardHandle::do_close");

		if (handle != CLOSED)
		{
			int aux= handle;
			handle= CLOSED;
			if (::close (aux) != 0)
			{
				// Problem: this message can be lost because
				// stdeerr may be redirected to null when
				// using this.

				#if 0
				const char * message= strerror (errno);
				TRMESSAGE (tr, message);
				if (showdebuginfo () )
					cerr << "Error closing handle: " <<
						message << endl;
				#else

				showlasterror ("Error closing handle");

				#endif

				if (! destructing)
					throw ErrBlassicInternal;
			}
		}
	}

	static const int CLOSED= -1;
	int handle;
};

class Dup2Save {
	// Checks are not done because the functions can fail
	// if Blassic is running in detached mode.
	// More work required to make checks that works in
	// all cases.
public:
	Dup2Save (int newhandle, int oldhandle) :
		oldhandle (oldhandle)
	{
		savedhandle= dup (oldhandle);
		dup2 (newhandle, oldhandle);
	}
	~Dup2Save ()
	{
		release ();
	}
	void release ()
	{
		if (savedhandle != RELEASED)
		{
			dup2 (savedhandle, oldhandle);
			close (savedhandle);
			savedhandle= RELEASED;
		}
	}
private:
	static const int RELEASED= -1;
	int oldhandle;
	int savedhandle;
};

#endif

} // namespace

namespace blassic {

namespace file {

class BlFilePrinter : public BlFile {
public:
	BlFilePrinter ();
	~BlFilePrinter ();
	bool isfile () const { return false; }
	void flush ();
	size_t getwidth () const;
	void tab ();
	void tab (size_t n);
	void endline ();
	void setwidth (size_t w);
	void setmargin (size_t m);
private:
	void outstring (const std::string & str);
	void outchar (char c);

	class Internal;
	Internal * pin;
};

//***********************************************
//              BlFilePrinter::Internal
//***********************************************

class BlFilePrinter::Internal {
public:
	Internal () :
		pos (0),
		width (80),
		margin (0)
	{ }
	~Internal ();
	void close ();
	size_t getwidth () const { return width; }
	void checkmargin ();
	void tab ();
	void tab (size_t n);
	void endline ();
	void outstring (std::string str);
	void outchar (char c);
	void setwidth (size_t w)
	{ width= w; }
	void setmargin (size_t m)
	{ margin= m - 1; }
private:
	void do_printing (const char * printcommand);

	std::string text;
	size_t pos;
	size_t width;
	size_t margin;
};

BlFilePrinter::Internal::~Internal ()
{
	TRACEFUNC (tr, "BlFilePrinter::Internal::~Internal");

	try
	{
		close ();
	}
	catch (...)
	{
		if (showdebuginfo () )
			cerr << "Error closing printer buffer" << endl;
	}
}

void BlFilePrinter::Internal::close ()
{
	TRACEFUNC (tr, "BlFilePrinter::Internal::close");

	static const char blassic_print_command []= "BLASSIC_PRINT_COMMAND";

	// Print only if there is somethnig to print.
	if (text.empty () )
	{
		TRMESSAGE (tr, "Nothing to print.");
		return;
	}
	TRMESSAGE (tr, "Begin printing");

	const char * printcommand= getenv (blassic_print_command);
	do_printing (printcommand);
}



#ifdef BLASSIC_USE_WINDOWS

void BlFilePrinter::Internal::do_printing (const char * printcommand)
{
	TRACEFUNC (tr, "BlFilePrinter::Internal::do_printing");

	if (printcommand != NULL)
	{
		TRMESSAGE (tr, std::string ("Popening to ") + printcommand);
		//BlFilePopen bfp (printcommand, Output);
		//bfp << text;
		auto_ptr <BlFile> pbfp (newBlFilePopen (printcommand, Output) );
		* pbfp << text;
		return;
	}

	std::string printername= getdefaultprinter ();
	TRMESSAGE (tr, std::string ("Printer is ") + printername);

	HANDLE hPrinter;
	if (! OpenPrinter ( (char *) printername.c_str (), & hPrinter, NULL) )
	{
		if (showdebuginfo () )
		{
			cerr << "OpenPrinter failed" << endl;
			showlasterror ();
		}
		throw ErrBlassicInternal;
	}
	GuardHPRINTER guardhprinter (hPrinter);
	DOC_INFO_1 doc_info;
	doc_info.pDocName= (char *) "Blassic printing output";
	doc_info.pOutputFile= NULL;
	doc_info.pDatatype= NULL;
	DWORD jobid= StartDocPrinter (hPrinter, 1, (LPBYTE) & doc_info);
	if (jobid == 0)
	{
		if (showdebuginfo () )
		{
			cerr << "StartDocPrinter failed" << endl;
			showlasterror ();
		}
		throw ErrBlassicInternal;
	}
	DWORD written= 0;
	WritePrinter (hPrinter, (void *) text.data (), text.size (),
		& written);
	if (written != text.size () )
	{
		if (showdebuginfo () )
		{
			cerr << "WritePrinter failed" << endl;
			showlasterror ();
		}
		throw ErrBlassicInternal;
	}
	EndDocPrinter (hPrinter);
	// ClosePrinter is done by the guard.
}

#else

void BlFilePrinter::Internal::do_printing (const char * printcommand)
{
	TRACEFUNC (tr, "BlFilePrinter::Internal::do_printing");

	if (printcommand == NULL)
		printcommand= "lp";

	FILE * f;

	// Block opened to automatically restore
	// saved handles when closing it.
	{
		// Redirect standard handles not used to /dev/null
		int newstd= open ("/dev/null", O_RDWR);
		if (newstd == -1)
		{
			#if 0
			if (showdebuginfo () )
				cerr << "open /dev/null failed: " <<
					strerror (errno) << endl;
			#else

			showlasterror ("open /dev/null failed");

			#endif

			throw ErrFunctionCall;
		}

		// Save standard handles not used
		#if 0
		int savestdout= dup (STDOUT_FILENO);
		int savestderr= dup (STDERR_FILENO);

		dup2 (newstd, STDOUT_FILENO);
		dup2 (newstd, STDERR_FILENO);
		::close (newstd);
		#else
		GuardHandle guardnew (newstd);
		Dup2Save saveout (newstd, STDOUT_FILENO);
		Dup2Save saveerr (newstd, STDERR_FILENO);
		guardnew.close ();
		#endif

		f= popen (printcommand, "w");

		#if 0
		// Restore saved standard handles
		dup2 (savestdout, STDOUT_FILENO);
		dup2 (savestderr, STDERR_FILENO);
		::close (savestdout);
		::close (savestderr);
		#endif
	}

	if (f == NULL)
	{
		if (showdebuginfo () )
			cerr << "Error in popen print command" << endl;
		throw ErrBlassicInternal;
	}
	size_t size= text.size ();
	size_t written= write (fileno (f), text.data (), size);
	if (written != size)
		showlasterror ("Error writing to print command");
	pclose (f);
}

#endif

void BlFilePrinter::Internal::checkmargin ()
{
	if (pos == 0)
		text+= std::string (margin, ' ');
}

void BlFilePrinter::Internal::tab ()
{
	size_t zone= sysvar::get16 (sysvar::Zone);
	if (zone == 0)
	{
		outchar ('\t');
		return;
	}
	if (width > 0 && pos >= (width / zone) * zone)
		endline ();
	else
	{
		do
		{
			outchar (' ');
		} while (pos % zone);
	}
}

void BlFilePrinter::Internal::tab (size_t n)
{
	if (pos > n)
		endline ();
	size_t maxpos= std::min (width, n);
	while (pos < maxpos)
		outchar (' ');
}

void BlFilePrinter::Internal::endline ()
{
	switch (sysvar::get (sysvar::PrinterLine) )
	{
	case 0:
		text+= '\n'; break;
	case 1:
		text+= "\r\n"; break;
	case 2:
		text+= '\r'; break;
	}
	pos= 0;
}

void BlFilePrinter::Internal::outstring (std::string str)
{
	if (width > 0)
	{
		size_t l= str.size ();
		while (pos + l > width)
		{
			checkmargin ();
			text+= str.substr (0, width - pos);
			str.erase (0, width - pos);
			endline ();
			l= str.size ();
		}
	}
	checkmargin ();
	text+= str;
	pos+= str.size ();
}

void BlFilePrinter::Internal::outchar (char c)
{
	if (width > 0 && pos>= width)
		endline ();
	checkmargin ();
	text+= c;
	++pos;
}

//***********************************************
//              BlFilePrinter
//***********************************************

BlFile * newBlFilePrinter ()
{
	return new BlFilePrinter;
}

BlFilePrinter::BlFilePrinter () :
	BlFile (Output),
	pin (new Internal)
{ }

BlFilePrinter::~BlFilePrinter ()
{
	delete pin;
}

void BlFilePrinter::flush ()
{
}

size_t BlFilePrinter::getwidth () const
{
	return pin->getwidth ();
}

void BlFilePrinter::tab ()
{
	pin->tab ();
}

void BlFilePrinter::tab (size_t n)
{
	pin->tab (n);
}

void BlFilePrinter::endline ()
{
	pin->endline ();
}

void BlFilePrinter::outstring (const std::string & str)
{
	pin->outstring (str);
}

void BlFilePrinter::outchar (char c)
{
	pin->outchar (c);
}

void BlFilePrinter::setwidth (size_t w)
{
	pin->setwidth (w);
}

void BlFilePrinter::setmargin (size_t m)
{
	pin->setmargin (m);
}

} // namespace file

} // namespace blassic

// End of fileprinter.cpp