Initial commit

61 files changed, 6132 insertions, 0 deletions

diff --git a/unix/gdev/README b/unix/gdev/README
new file mode 100644
index 00000000..235194cb
--- /dev/null
+++ b/unix/gdev/README
@@ -0,0 +1,126 @@
+ZFIOGD -- FIO device driver for binary graphics devices.
+	  Note: this code is part of library LIBSYS.
+
+The purpose of this driver is to provide a low level i/o interface to the
+interactive binary graphics devices supported on a particular system.  This
+includes devices such as image displays and bit mapped vector graphics devices
+(e.g., the Versatec plotters).  The ZFIOGD driver is not intended for graphics
+devices with a text interface, e.g., the Tektronix compatible graphics
+terminals.  A third interface, i.e., the ZFIOPL driver, is used for devices
+accessed via the NCAR system plot package.
+
+By using a ZFIO level driver to talk to the binary graphics devices we can
+isolate the system dependencies of the interface to a small amount of code.
+We gain the ability to access the device over the network, since the kernel
+server can be used once the i/o interface to the device is part of the kernel.
+
+The ZFIOGD driver is implemented in LIBSYS rather than LIBOS since the
+interface code, while system dependent, is generally written at least partially
+in SPP to access header files shared with the GIO graphics kernel for the
+device, as well as to gain access to the LIBSYS library functions for ease
+of coding.  ZFIOGD is used only by the graphics kernels hence is not needed
+to bootstrap the system; it is added to LIBSYS after the system is up and
+running.
+
+The code is made as follows:
+
+    [1]	In a bootstrap, the commands in the mkpkg.csh file are executed by
+	the root mkpkg.csh file in host$.
+
+    [2] In a sysgen, the mkpkg file in this directory is called by an entry
+	in sys$mkpkg to to update the libsys.a library.
+
+
+ARCHITECTURE
+
+    The single FIO device driver ZFIOGD is used to access all binary graphics
+devices.  This simplifies the KI and VOS interfaces and maximally isolates
+knowledge of the devices supported on a particular system.  New devices can
+be added to ZFIOGD without any changes to the kernel interface or the VOS.
+When a device is opened via the ZFIOGD driver the name of the device is
+specified as follows:
+	
+	node!device:hostdevname
+e.g.,
+	lyra!iis,/dev/iis
+	vela!iis,iia0
+
+where
+	device		identifies the bottom level driver to be used
+
+	hostdevname	is the host system name for the particular
+			    device to be accessed (there may be
+			    multiple copies of a device on a single
+			    system)
+
+The task of ZOPNGD is to look up device name in an internal table and call
+the appropriate lower level device open procedure to physically open the
+device.  If the device resides on a remote node the kernel interface will
+have have spawned a remote kernel server which will call ZOPNGD on the host
+which actually owns the device.
+
+
+                                 ZFIOGD
+                                                                   
+                                                                   
+               iism7X   deanza    peritek   versatec    (etc.)
+
+
+The ZFIOGD interface is a data driven interface, i.e., all control and status
+readback functions are performed by ZARDGD and ZAWRGD calls to read and write
+binary packets of data.  This is ideal for a device such as the IIS which is
+also data driven, but is less convenient for devices which have a control
+type interface (in a control type interface, a subroutine is called to do
+something to the device, rather than writing to the device).  Even when the
+device is control driven at the host system level, a data driven interface is
+desirable to isolate the system dependence of the OS device driver, as well
+as to provide network access.
+
+
+PROTOCOLS
+
+    When building a ZFIOGD sub-driver for a control driven device, it is
+suggested that a control packet be defined for the device which is capable
+of encoding all control functions.  The high level code (GIO graphics device
+driver) will encode control functions in this packet (which should have a
+machine independent external representation), and send it along via ZAWRGD
+to the sub-kernel, which will decode the packet and poke the host system device
+driver as necessary to perform the indicated function.
+
+There is no predefined protocol for encoding control packets for binary
+graphics devices.  Conceivably such an interface could be defined, but our
+goal with the ZFIOGD interface is to isolate the host system dependence of
+the interface and provide network access capabilities; we are NOT trying to
+address the problems of device independence in this interface.  That is the
+function of the GIO device driver, which should be machine independent and
+portable, but addresses the problems of providing a device independent
+interface.
+
+A control packet and communications protocol should therefore be defined
+separately for each device.  One possibility is to use the OFFSET argument
+in the ZAWRGD call as a function code, rather than placing the function code
+in a generic packet header.  This is possible since the OFFSET argument is not
+used for streaming devices.  The only disadvantage to using the OFFSET field
+in this way is that doing so would prevent use of FIO to buffer i/o to the
+device, since FIO always sets OFFSET to zero when calling ZAWRGD for a
+streaming device.  The alternative is the generic packet approach, wherein
+each i/o or control operation is preceded by a packet defining the operation
+to be performed (this can simplify the interface, since a single set of
+subroutines can be used to encode/transmit and receive/decode packet headers).
+Yet another possibilty is to combine the two approaches, using a generic
+packet header for most operations, but a special "offset" or function code
+for special operations such as master clear or device reset (as well as to
+reset the communications protocol).  
+
+See the send/receive procedures in the KI (kernel interface) for an example
+of how to encode packets in a machine independent form for transmission over
+the network.
+
+
+ADDING NEW DEVICES
+
+    To add a new device to ZFIOGD, create a subdirectory with the name of the
+device and implement the six driver subroutines therein.  Add an entry to the
+mkpkg to compile the new subdirectory.  Add a new entry to the device table
+and to each switch-case statement in zfiogd.x.  Relink all affected graphics
+executables, and relink the kernel server executable.
diff --git a/unix/gdev/iism70/README b/unix/gdev/iism70/README
new file mode 100644
index 00000000..8023068b
--- /dev/null
+++ b/unix/gdev/iism70/README
@@ -0,0 +1,18 @@
+UNIX IRAF/FIO device driver for the IIS Model 70
+(will probably also work for the model 75).  11/85 dct
+----------------------------------------------------------------------
+
+This directory contains the IRAF/FIO driver subroutines for the IIS Model 70
+image display on UNIX.  On a UNIX system the ZIFOBF (binary file) driver is
+used to access the display, hence the subroutines herein merely map the calls
+into the corresponding BF procedures.
+
+
+Driver Procedures:
+
+	zopm70	-- open + allocate
+	zclm70	-- close + deallocate
+	zrdm70	-- asynchronous binary read
+	zwrm70	-- asynchronous binary write
+	zwtm70	-- wait for i/o completion, return status
+	zstm70	-- get device status
diff --git a/unix/gdev/iism70/m70.h b/unix/gdev/iism70/m70.h
new file mode 100644
index 00000000..6a1a7d28
--- /dev/null
+++ b/unix/gdev/iism70/m70.h
@@ -0,0 +1,27 @@
+# Definitions for the VMS/IIS device driver.
+
+define	IIS_READ	1		# read function code
+define	IIS_WRITE	0		# write function code
+define	IIS_INACTIVE	-1		# no i/o in progress
+
+define	EFN		EFN2		# EFN to use for i/o
+define	EFN1W		0		# efn #1, wait for completion
+define	EFN2		1		# efn #2, no wait for completion
+define	EFN3		2		# efn #3, no wait for completion
+
+# Function control block structure for IIS.  The first part of the structure
+# is filled in by VMS at open time; all we need to know is the offset of the
+# device name.  We use the latter part of the buffer
+
+define	LEN_FCB		30
+define	FCB_U_NAME	(P2S($1)+16+($2)-1)
+define	FCB_STATUS	Memi[$1+20]	# channel status (r, w, err)
+define	FCB_NBYTES	Memi[$1+21]	# nbytes last transfer
+define	FCB_EFN		Memi[$1+22]	# event flag used for transfer
+
+# IIS device status words.
+
+define	IIS_FILSIZE		(512 * 512 * SZB_CHAR)
+define	IIS_BLKSIZE		1024
+define	IIS_OPTBUFSIZE		(512 * SZB_CHAR)
+define	IIS_MAXBUFSIZE		32768
diff --git a/unix/gdev/iism70/mkpkg b/unix/gdev/iism70/mkpkg
new file mode 100644
index 00000000..57b920c5
--- /dev/null
+++ b/unix/gdev/iism70/mkpkg
@@ -0,0 +1,15 @@
+# Make the UNIX version of the IIS driver.
+
+$checkout libsys.a lib$
+$update   libsys.a
+$checkin  libsys.a lib$
+$exit
+
+libsys.a:
+	zclm70.x
+	zopm70.x
+	zrdm70.x
+	zstm70.x	m70.h <fio.h> <mach.h>
+	zwrm70.x
+	zwtm70.x
+	;
diff --git a/unix/gdev/iism70/zclm70.x b/unix/gdev/iism70/zclm70.x
new file mode 100644
index 00000000..719bc727
--- /dev/null
+++ b/unix/gdev/iism70/zclm70.x
@@ -0,0 +1,12 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+# ZCLM70 -- Close and deallocate the IIS.
+
+procedure zclm70 (chan, status)
+
+int	chan
+int	status
+
+begin
+	call zclsbf (chan, status)
+end
diff --git a/unix/gdev/iism70/zopm70.x b/unix/gdev/iism70/zopm70.x
new file mode 100644
index 00000000..5c49d506
--- /dev/null
+++ b/unix/gdev/iism70/zopm70.x
@@ -0,0 +1,14 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+# ZOPM70 -- Open the IIS for binary file i/o.  The device will be automatically
+# allocated if necessary.
+
+procedure zopm70 (device, mode, chan)
+
+char	device[ARB]		# packed UNIX device name
+int	mode			# access mode
+int	chan			# receives device channel
+
+begin
+	call zopnbf (device, mode, chan)
+end
diff --git a/unix/gdev/iism70/zrdm70.x b/unix/gdev/iism70/zrdm70.x
new file mode 100644
index 00000000..f3ef3f2a
--- /dev/null
+++ b/unix/gdev/iism70/zrdm70.x
@@ -0,0 +1,14 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+# ZRDM70 -- Initiate an asynchronous read from the IIS.
+
+procedure zrdm70 (chan, buf, nbytes, offset)
+
+int	chan			# FCB pointer for device
+char	buf[ARB]		# output buffer
+int	nbytes			# number of  bytes to read
+long	offset			# not used for this device
+
+begin
+	call zardbf (chan, buf, nbytes, offset)
+end
diff --git a/unix/gdev/iism70/zstm70.x b/unix/gdev/iism70/zstm70.x
new file mode 100644
index 00000000..2b790dfa
--- /dev/null
+++ b/unix/gdev/iism70/zstm70.x
@@ -0,0 +1,28 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<fio.h>
+include	"m70.h"
+
+# ZSTM70 -- Return device status for the IIS.
+
+procedure zstm70 (chan, what, lvalue)
+
+int	chan			# FCB pointer for device
+int	what			# status parameter
+long	lvalue
+
+begin
+	switch (what) {
+	case FSTT_FILSIZE:
+	    lvalue = IIS_FILSIZE
+	case FSTT_BLKSIZE:
+	    lvalue = IIS_BLKSIZE
+	case FSTT_OPTBUFSIZE:
+	    lvalue = IIS_OPTBUFSIZE
+	case FSTT_MAXBUFSIZE:
+	    lvalue = IIS_MAXBUFSIZE
+	default:
+	    lvalue = ERR
+	}
+end
diff --git a/unix/gdev/iism70/zwrm70.x b/unix/gdev/iism70/zwrm70.x
new file mode 100644
index 00000000..10545f99
--- /dev/null
+++ b/unix/gdev/iism70/zwrm70.x
@@ -0,0 +1,14 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+# ZWRM70 -- Initiate an asynchronous write to the IIS.
+
+procedure zwrm70 (chan, buf, nbytes, offset)
+
+int	chan			# FCB pointer for device
+char	buf[ARB]		# input buffer
+int	nbytes			# number of  bytes to write
+long	offset			# not used for this device
+
+begin
+	call zawrbf (chan, buf, nbytes, offset)
+end
diff --git a/unix/gdev/iism70/zwtm70.x b/unix/gdev/iism70/zwtm70.x
new file mode 100644
index 00000000..b2523c31
--- /dev/null
+++ b/unix/gdev/iism70/zwtm70.x
@@ -0,0 +1,13 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+# ZWTM70 -- Wait for i/o completion and return the number of bytes read or
+# written or ERR.  Repetitive calls return the same value.
+
+procedure zwtm70 (chan, status)
+
+int	chan			# FCB pointer for device
+int	status			# nbytes transferred or ERR
+
+begin
+	call zawtbf (chan, status)
+end
diff --git a/unix/gdev/iism75/README b/unix/gdev/iism75/README
new file mode 100644
index 00000000..60433d4d
--- /dev/null
+++ b/unix/gdev/iism75/README
@@ -0,0 +1,24 @@
+UNIX IRAF/FIO device driver for the IIS Model 75
+2 Feb 1896 Dct.; ported to UNIX from VMS 10 Mar 1987 SRo.
+----------------------------------------------------------------------
+
+This directory contains the IRAF/FIO driver subroutines for the IIS Model 75
+image display.  This directory is self contained.
+
+The model 75 interface is implemented as a transformation on the data stream
+for the model 70.  The high level code thinks that it is talking to a model
+70; we translate the headers as necessary for the model 75 before passing
+them on to the device.  This approach does not provide full access to the
+capabilities of the model 75, however the existing high level code is all
+written for the model 70 and we are not at present interested in the advanced
+features of either display.
+
+
+Driver Procedures:
+
+	zopm75	-- open + allocate
+	zclm75	-- close + deallocate
+	zrdm75	-- asynchronous binary read
+	zwrm75	-- asynchronous binary write
+	zwtm75	-- wait for i/o completion, return status
+	zstm75	-- get device status
diff --git a/unix/gdev/iism75/iis.h b/unix/gdev/iism75/iis.h
new file mode 100644
index 00000000..515c0def
--- /dev/null
+++ b/unix/gdev/iism75/iis.h
@@ -0,0 +1,106 @@
+# IIS.H -- Hardware definitions for the IIS models 70 and 75.
+
+# Define header
+define	LEN_IISHDR	8		# Length of IIS header
+
+define	XFERID		$1[1]		# transfer id
+define	THINGCT		$1[2]		# thing count
+define	SUBUNIT		$1[3]		# subuint select
+define	CHECKSUM	$1[4]		# check sum
+define	XREG		$1[5]		# x register
+define	YREG		$1[6]		# y register
+define	ZREG		$1[7]		# z register
+define	TREG		$1[8]		# t register
+
+# Transfer ID definitions
+define	BYTEORDER	      20B
+define	PMA		      40B
+define	ACCELERATE	     100B
+define	REPEAT		     200B
+define	IREAD		  100000B
+define	IWRITE		  000000B
+define	PACKED		   40000B
+define	BYPASSIFM	   20000B
+define	PAGEMODE	   10000B
+define	ADDWRITE	    4000B
+define	ACCUM		    2000B
+define	BLOCKXFER	    1000B
+define	VRETRACE	     400B
+
+define	M70_BYTE	   10000B
+define	M70_MUX32	     200B
+
+# Subunits
+define	REFRESH			1
+define	LUT			2
+define	OFM			3
+define	IFM			4
+define	FEEDBACK		5
+define	SCROLLZOOM		6
+define	VIDEOM			7
+define	SUMPROC			8
+define	GRAPHICS		9
+define	CURSOR		       10
+define	ALU		       11
+
+define	M70_SCROLL		6
+define	M70_ZOOM	       12
+
+# Command definitions
+define	COMMAND		  100000B
+define	ERASE		  100000B		# Erase
+
+define	SCROLL		       1B
+define	ZOOM		   10000B
+define	WRAP		    1000B
+
+define	M70_ADVXONTC	  100000B		# Advance x on thing count
+define	M70_ADVXONYOV	   40000B		# Advance x on y overflow
+define	M70_ADVYONXOV	  100000B		# Advance y on x overflow
+define	M70_ADVYONTC	   40000B		# Advance y on thing count
+
+define	M75_ADVXONTC	     400B		# Advance x on thing count
+define	M75_ADVXONYOV	     200B		# Advance x on y overflow
+define	M75_ADVYONXOV	    2000B		# Advance y on x overflow
+define	M75_ADVYONTC	    4000B		# Advance y on thing count
+
+# 4 - Button Trackball
+define	PUSH		   40000B
+define	BUTTONA		     400B
+define	BUTTONB		    1000B
+define	BUTTONC		    2000B
+define	BUTTOND		    4000B
+
+# Display channels
+define	CHAN1		       1B
+define	CHAN2		       2B
+define	CHAN3		       4B
+define	CHAN4		      10B
+define	GRCHAN		  100000B
+
+define	LEN_IISFRAMES		4
+define	IISFRAMES		CHAN1, CHAN2, CHAN3, CHAN4
+
+# Colors
+define	BLUE		       1B
+define	GREEN		       2B
+define	RED		       4B
+define	MONO		       7B
+
+# Bit plane selections
+define	BITPL0		       1B
+define	BITPL1		       2B
+define	BITPL2		       4B
+define	BITPL3		      10B
+define	BITPL4		      20B
+define	BITPL5		      40B
+define	BITPL6		     100B
+define	BITPL7		     200B
+define	ALLBITPL	     377B
+
+# IIS Sizes
+define	MCXSCALE      	       64	# Metacode x scale
+define	MCYSCALE      	       64	# Metacode y scale
+define	IIS_XDIM	      512
+define	IIS_YDIM	      512
+define	SZB_IISHDR	       16	# Size of IIS header in bytes
diff --git a/unix/gdev/iism75/m75.h b/unix/gdev/iism75/m75.h
new file mode 100644
index 00000000..832aa423
--- /dev/null
+++ b/unix/gdev/iism75/m75.h
@@ -0,0 +1,28 @@
+# Definitions for the Model 75 UNIX/IIS device driver.
+
+define	IIS_READ	1		# read function code
+define	IIS_WRITE	0		# write function code
+define	IIS_INACTIVE	2		# no i/o in progress
+
+# Function control block structure containing only our own internal variables.
+
+define	LEN_FCB		20
+define	FCB_CHAN	Memi[($1)]		# os channel
+define	FCB_STATUS	Mems[P2S(($1)+1)]	# channel status (r, w, err)
+define	FCB_NBYTES	Mems[P2S(($1)+2)]	# nbytes last transfer
+define	FCB_STATE	Mems[P2S(($1)+3)]	# instruction processing state
+define	FCB_IISHDR	Mems[P2S(($1)+4)]	# m70 header of current instr.
+			# (extra space)
+
+# Instruction processing states
+
+define	READY		0		# ready for new instruction
+define	DATA_READ	1		# read data to complete instruction
+define	DATA_WRITE	2		# write data to complete instruction
+
+# IIS device status words.
+
+define	IIS_FILSIZE		(512 * 512 * SZB_CHAR)
+define	IIS_BLKSIZE		1024
+define	IIS_OPTBUFSIZE		(512 * SZB_CHAR)
+define	IIS_MAXBUFSIZE		16384
diff --git a/unix/gdev/iism75/m75put.x b/unix/gdev/iism75/m75put.x
new file mode 100644
index 00000000..01ca6511
--- /dev/null
+++ b/unix/gdev/iism75/m75put.x
@@ -0,0 +1,160 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include <mach.h>
+include "m75.h"
+include "iis.h"
+
+# M75PUT -- Translate an M70 instruction+data into an M75 instruction+data and
+# output it to the display device.  We are called after both the instruction
+# header and the data (if any) have been received.  The M70 header has been
+# saved in the the channel descriptor and the data, if any, is in BUF.
+
+procedure m75put (fcb, buf, nbytes_buf, offset)
+
+pointer	fcb			# pointer to channel descriptor
+short	buf[ARB]		# data array
+int	nbytes_buf		# nbytes of data in buffer
+long	offset			# not used
+
+int	ifcb
+bool	use_altbuf
+short	altbuf[128]
+short	m70[LEN_IISHDR]
+short	m75[LEN_IISHDR]
+int	nbytes, status, sum, i
+int	xferid, subunit, xreg, yreg
+int	and(), or(), not()
+
+begin
+	ifcb = fcb
+	use_altbuf = false
+
+	# Retrieve the M70 header from the channel descriptor.
+	call amovs (FCB_IISHDR(fcb), m70, LEN_IISHDR)
+	
+	xferid  = XFERID(m70)
+	subunit = SUBUNIT(m70)
+	xreg	= XREG(m70)
+	yreg	= YREG(m70)
+
+	if (THINGCT(m70) == 0)
+	    nbytes = 0
+	else
+	    nbytes = nbytes_buf
+
+	# Start with a copy of the header for the M75, but turn off those bits
+	# in the transfer id which the M70 knows nothing about and hence could
+	# not have set.
+
+	call amovs (m70, m75, LEN_IISHDR)
+	XFERID(m75) = and (xferid,
+	    not (BYTEORDER+PMA+ACCELERATE+REPEAT+PAGEMODE))
+
+	# Translate the remaining fields of the header as necessary for each
+	# subunit.
+
+	switch (and (subunit, 77B)) {
+	case REFRESH:
+	    if (and (xreg, M70_ADVXONTC) != 0)
+		subunit = or (subunit, M75_ADVXONTC)
+	    if (and (xreg, M70_ADVXONYOV) != 0)
+		subunit = or (subunit, M75_ADVXONYOV)
+	    if (and (yreg, M70_ADVYONTC) != 0)
+		subunit = or (subunit, M75_ADVYONTC)
+	    if (and (yreg, M70_ADVYONXOV) != 0)
+		subunit = or (subunit, M75_ADVYONXOV)
+
+	    SUBUNIT(m75) = subunit
+	    XREG(m75) = and (xreg, IIS_XDIM-1)
+	    YREG(m75) = and (yreg, IIS_YDIM-1)
+
+	case LUT:
+	    XREG(m75) = and (xreg, 1777B)
+	    YREG(m75) = 0
+
+	case OFM:
+	    XREG(m75) = and (xreg, 1777B)
+	    YREG(m75) = 0
+
+	    # The M70 feeds a 10 bit output DAC while the M75 DAC is 8 bits.
+	    do i = 1, nbytes_buf / (SZB_CHAR * SZ_SHORT)
+		buf[i] = buf[i] / 4
+
+	case FEEDBACK:
+	    subunit = COMMAND + FEEDBACK
+	    SUBUNIT(m75) = subunit
+	    XREG(m75) = 0
+	    YREG(m75) = 0
+
+	case GRAPHICS:
+	    XREG(m75) = and (xreg, 777B)
+
+	    # In a command mode transfer, the status register value is passed
+	    # as data for the M70, but in the T register for the M75.
+
+	    if (and (subunit, COMMAND) != 0) {
+		TREG(m75) = buf[1]
+		THINGCT(m75) = 0
+		nbytes = 0
+	    }
+
+	case CURSOR:
+	    XREG(m75) = and (xreg, 7777B)
+	    YREG(m75) = 0
+
+	case M70_SCROLL:
+	    SUBUNIT(m75) = SCROLLZOOM
+	    XREG(m75) = and (xreg, 3B)
+	    YREG(m75) = 0
+	    ZREG(m75) = ALLBITPL
+	    TREG(m75) = SCROLL + WRAP
+
+	case M70_ZOOM:
+	    SUBUNIT(m75) = SCROLLZOOM
+	    THINGCT(m75) = 2
+	    XREG(m75) = and (xreg, 3B)
+	    YREG(m75) = 0
+	    ZREG(m75) = ALLBITPL
+	    TREG(m75) = ZOOM + SCROLL + WRAP
+
+	    # There are up to 3 words of data for the M70: zoom factor,
+	    # x center, y center.  For the M75 the zoom is specified
+	    # separately for each axis in the high bits of the word which
+	    # contains the axis center.  For simplicity we require that
+	    # all 3 words always be given.
+
+	    altbuf[1] = buf[1] * 10000B + buf[2]
+	    altbuf[2] = buf[1] * 10000B + buf[3]
+	    use_altbuf = true
+	    nbytes = 2 * (SZ_SHORT * SZB_CHAR)
+	}
+
+	# Compute the checksum for the new header.
+
+	CHECKSUM(m75) = 1
+	if (THINGCT(m75) > 0)
+	    THINGCT(m75) = -THINGCT(m75)
+
+	sum = 0
+	do i = 1, LEN_IISHDR
+	    sum = sum + m75[i]
+	
+	CHECKSUM(m75) = -sum
+
+	# Output the header.
+
+	call zzwrii (fcb, m75, SZB_IISHDR, offset)
+	call zwtm75 (ifcb, status)
+	if (status == ERR) {
+	    FCB_STATUS(fcb) = ERR
+	    return
+	}
+
+	# Output the data block, if any.
+
+	if (nbytes > 0)
+	    if (use_altbuf)
+		call zzwrii (fcb, altbuf, nbytes, offset)
+	    else
+		call zzwrii (fcb,    buf, nbytes, offset)
+end
diff --git a/unix/gdev/iism75/mkpkg b/unix/gdev/iism75/mkpkg
new file mode 100644
index 00000000..97387aec
--- /dev/null
+++ b/unix/gdev/iism75/mkpkg
@@ -0,0 +1,18 @@
+# Mkpkg for the UNIX version of the IIS driver.
+
+$checkout libsys.a lib$
+$update	  libsys.a
+$checkin  libsys.a lib$
+$exit
+
+libsys.a:
+	m75put.x	iis.h m75.h <mach.h>
+	zclm75.x	m75.h <mach.h>
+	zopm75.x	m75.h <mach.h>
+	zrdm75.x	iis.h m75.h <mach.h>
+	zstm75.x	m75.h <fio.h> <mach.h>
+	zwrm75.x	iis.h m75.h <mach.h>
+	zwtm75.x	m75.h <mach.h>
+	zzrdii.x	m75.h <mach.h>
+	zzwrii.x	m75.h <mach.h>
+	; 
diff --git a/unix/gdev/iism75/zclm75.x b/unix/gdev/iism75/zclm75.x
new file mode 100644
index 00000000..989358d9
--- /dev/null
+++ b/unix/gdev/iism75/zclm75.x
@@ -0,0 +1,19 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+
+# ZCLM75 -- Close and deallocate the IIS.
+
+procedure zclm75 (ifcb, status)
+
+int	ifcb			# pointer to channel descriptor passed as int
+int	status
+pointer	fcb
+
+begin
+	fcb = ifcb
+	call zclsbf (FCB_CHAN(fcb), status)
+
+	call mfree (fcb, TY_STRUCT)
+end
diff --git a/unix/gdev/iism75/zopm75.x b/unix/gdev/iism75/zopm75.x
new file mode 100644
index 00000000..33a9acf8
--- /dev/null
+++ b/unix/gdev/iism75/zopm75.x
@@ -0,0 +1,32 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+
+# ZOPM75 -- Open the IIS for binary file i/o.
+
+procedure zopm75 (device, mode, ifcb)
+
+char	device[ARB]		# packed UNIX device name
+int	mode			# access mode
+int	ifcb			# pointer to channel descriptor passed as int
+
+pointer	fcb
+int	chan
+
+begin
+	call calloc (fcb, LEN_FCB, TY_STRUCT)
+	ifcb = fcb
+
+	FCB_STATUS(fcb)   = IIS_INACTIVE
+	FCB_NBYTES(fcb)   = 0
+	FCB_STATE(fcb)    = READY
+
+	call zopnbf (device, mode, chan)
+
+	if (chan < 0) {
+	    call mfree (fcb, TY_STRUCT)
+	    ifcb = ERR
+	} else
+	    FCB_CHAN(fcb) = chan
+end
diff --git a/unix/gdev/iism75/zrdm75.x b/unix/gdev/iism75/zrdm75.x
new file mode 100644
index 00000000..9cc2498d
--- /dev/null
+++ b/unix/gdev/iism75/zrdm75.x
@@ -0,0 +1,163 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+include	"iis.h"
+
+# ZRDM75 -- Initiate an asynchronous read of data from the IIS.  Note that
+# the zwrm75 procedure is called to write the header for data reads, as well
+# as writes.  Hence we should be called only after the header has been saved
+# in the channel descriptor by ZWRM75, leaving the channel in state DATA_READ.
+# Our task is to translate and output the header, read the M75 data block, and
+# return the data block to the user after performing any transformations
+# necessary to make it look like M70fdata.
+
+procedure zrdm75 (ifcb, buf, nbytes_buf, offset)
+
+int	ifcb			# pointer to channel descriptor passed as int
+short	buf[ARB]		# data array
+int	nbytes_buf		# nbytes of data in buffer
+long	offset			# not used
+
+pointer	fcb
+short	m70[LEN_IISHDR]
+short	m75[LEN_IISHDR]
+int	nbytes, status, sum, i
+int	xferid, subunit, xreg, yreg
+int	and(), or(), not()
+
+begin
+	fcb = ifcb
+	nbytes = nbytes_buf
+
+	if (FCB_STATE(fcb) != DATA_READ) {
+	    FCB_STATUS(fcb) = ERR
+	    return
+	}
+
+	# Retrieve the M70 header from the channel descriptor.
+	call amovs (FCB_IISHDR(fcb), m70, LEN_IISHDR)
+	
+	xferid  = XFERID(m70)
+	subunit = SUBUNIT(m70)
+	xreg	= XREG(m70)
+	yreg	= YREG(m70)
+
+	# Start with a copy of the header for the M75, but turn off those bits
+	# in the transfer id which the M70 knows nothing about and hence could
+	# not have set.
+
+	call amovs (m70, m75, LEN_IISHDR)
+	XFERID(m75) = and (xferid,
+	    not (BYTEORDER+PMA+ACCELERATE+REPEAT+PAGEMODE))
+
+	# Translate the remaining fields of the header as necessary for each
+	# subunit.
+
+	switch (and (subunit, 77B)) {
+	case REFRESH:
+	    if (and (xreg, M70_ADVXONTC) != 0)
+		subunit = or (subunit, M75_ADVXONTC)
+	    if (and (xreg, M70_ADVXONYOV) != 0)
+		subunit = or (subunit, M75_ADVXONYOV)
+	    if (and (yreg, M70_ADVYONTC) != 0)
+		subunit = or (subunit, M75_ADVYONTC)
+	    if (and (yreg, M70_ADVYONXOV) != 0)
+		subunit = or (subunit, M75_ADVYONXOV)
+
+	    SUBUNIT(m75) = subunit
+	    XREG(m75) = and (xreg, IIS_XDIM-1)
+	    YREG(m75) = and (yreg, IIS_YDIM-1)
+
+	case LUT:
+	    XREG(m75) = and (xreg, 1777B)
+	    YREG(m75) = 0
+
+	case OFM:
+	    XREG(m75) = and (xreg, 1777B)
+	    YREG(m75) = 0
+
+	    # The M70 OFM lookup table is 10 bits deep, whereas the M75 table
+	    # is only 8 bits deep, so scale the 8 bit M75 values up to 10 bits.
+
+	    do i = 1, nbytes_buf / (SZB_CHAR * SZ_SHORT)
+		buf[i] = buf[i] * 4
+
+	case FEEDBACK:
+	    subunit = COMMAND + FEEDBACK
+	    SUBUNIT(m75) = subunit
+	    XREG(m75) = 0
+	    YREG(m75) = 0
+
+	case GRAPHICS:
+	    XREG(m75) = and (xreg, 777B)
+	    TREG(m75) = 0			# ??
+
+	case CURSOR:
+	    XREG(m75) = and (xreg, 7777B)
+	    YREG(m75) = 0
+
+	case M70_SCROLL:
+	    SUBUNIT(m75) = SCROLLZOOM
+	    XREG(m75) = and (xreg, 3B)
+	    YREG(m75) = 0
+	    ZREG(m75) = ALLBITPL
+	    TREG(m75) = SCROLL + WRAP
+
+	case M70_ZOOM:
+	    SUBUNIT(m75) = SCROLLZOOM
+	    THINGCT(m75) = 2
+	    nbytes = 2 * (SZ_SHORT * SZB_CHAR)
+	    XREG(m75) = and (xreg, 3B)
+	    YREG(m75) = 0
+	    ZREG(m75) = ALLBITPL
+	    TREG(m75) = ZOOM
+	}
+
+	# Compute the checksum for the new header.
+
+	CHECKSUM(m75) = 1
+	if (THINGCT(m75) > 0)
+	    THINGCT(m75) = -THINGCT(m75)
+
+	sum = 0
+	do i = 1, LEN_IISHDR
+	    sum = sum + m75[i]
+	
+	CHECKSUM(m75) = -sum
+
+	# Output the header.
+
+	call zzwrii (fcb, m75, SZB_IISHDR, offset)
+	call zwtm75 (ifcb, status)
+	if (status == ERR) {
+	    FCB_STATUS(fcb) = ERR
+	    return
+	}
+
+	# Read the data block.
+
+	if (nbytes > 0) {
+	    call zzrdii (fcb, buf, nbytes, offset)
+	    call zwtm75 (ifcb, status)
+	    if (status <= 0) {
+		FCB_STATUS(fcb) = ERR
+		return
+	    }
+	}
+
+	# Perform any transformations on the data just read necessary to
+	# convert it into M70 format.  If the number of bytes read is
+	# different than that expected by the M70, be sure to set the
+	# expected count in the channel descriptor for the next ZWTM75.
+
+	if (and (subunit, 77B) == ZOOM) {
+	    FCB_NBYTES(fcb) = 3 * (SZ_SHORT * SZB_CHAR)
+	    FCB_STATUS(fcb) = IIS_INACTIVE
+	    buf[3] = mod (int(buf[2]), 10000B) 
+	    buf[2] = mod (int(buf[1]), 10000B) 
+	    buf[1] = buf[1] / 10000B
+	}
+
+	FCB_STATE(fcb) = READY
+end
diff --git a/unix/gdev/iism75/zstm75.x b/unix/gdev/iism75/zstm75.x
new file mode 100644
index 00000000..b1e9923c
--- /dev/null
+++ b/unix/gdev/iism75/zstm75.x
@@ -0,0 +1,28 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<fio.h>
+include	"m75.h"
+
+# ZSTM75 -- Return device status for the IIS.
+
+procedure zstm75 (ifcb, what, lvalue)
+
+int	ifcb			# pointer to channel descriptor passed as int
+int	what			# status parameter
+long	lvalue
+
+begin
+	switch (what) {
+	case FSTT_FILSIZE:
+	    lvalue = IIS_FILSIZE
+	case FSTT_BLKSIZE:
+	    lvalue = IIS_BLKSIZE
+	case FSTT_OPTBUFSIZE:
+	    lvalue = IIS_OPTBUFSIZE
+	case FSTT_MAXBUFSIZE:
+	    lvalue = IIS_MAXBUFSIZE
+	default:
+	    lvalue = ERR
+	}
+end
diff --git a/unix/gdev/iism75/zwrm75.x b/unix/gdev/iism75/zwrm75.x
new file mode 100644
index 00000000..38bb0f3c
--- /dev/null
+++ b/unix/gdev/iism75/zwrm75.x
@@ -0,0 +1,76 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+include	"iis.h"
+
+# ZWRM75 -- Initiate an asynchronous write to the IIS.  We are called to
+# output the header of all instructions sent to the IIS.  There are 3 types
+# of instructions; those which consist only of a header write, those which
+# consist of a header write followed by a data write, and those which
+# consist of a header write followed by a data read.  Translation of an M70
+# instruction into an M75 instruction may involve moving information between
+# the header and data block, hence we must save the headers of the read and
+# write instructions until the data has been read or written.  The STATE
+# variable in the channel descriptor is used to keep track of the instruction
+# processing state.
+
+procedure zwrm75 (ifcb, buf, nbytes, offset)
+
+int	ifcb			# pointer to channel descriptor passed as int
+char	buf[ARB]		# input buffer
+int	nbytes			# number of  bytes to write
+long	offset			# not used for this device
+
+pointer	fcb
+int	xferid, and()
+
+begin
+	fcb = ifcb
+
+	if (FCB_STATE(fcb) == READY) {
+	    # Start a new instruction.
+
+	    if (nbytes != SZB_IISHDR) {
+		FCB_STATUS(fcb) = ERR
+		return
+	    }
+
+	    # Save the M70 header in the descriptor.
+	    call amovs (buf, FCB_IISHDR(fcb), LEN_IISHDR)
+	    xferid = XFERID(buf)
+
+	    # Determine the state for the new instruction.
+
+	    if (THINGCT(buf) == 0)
+		FCB_STATE(fcb) = READY
+	    else if (and (xferid, IREAD) != 0)
+		FCB_STATE(fcb) = DATA_READ
+	    else
+		FCB_STATE(fcb) = DATA_WRITE
+
+	    # If the new state is READY, no data read or write is needed,
+	    # so just translate and output the header.
+
+	    if (FCB_STATE(fcb) == READY)
+		call m75put (fcb, buf, nbytes, offset)
+	    else {
+		# Set up a channel status as if we had just written the new
+		# header, so that the next ZWTM75 will not return an error.
+
+		FCB_STATUS(fcb) = IIS_INACTIVE
+		FCB_NBYTES(fcb) = SZB_IISHDR
+	    }
+	    
+	} else if (FCB_STATE(fcb) == DATA_WRITE) {
+	    # This is the second zwrm75 call for a hdr+data output
+	    # instruction.
+
+	    call m75put (fcb, buf, nbytes, offset)
+	    FCB_STATE(fcb) = READY
+
+	} else {
+	    # ZRDM75 should have been called, set error on the channel.
+	    FCB_STATUS(fcb) = ERR
+	}
+end
diff --git a/unix/gdev/iism75/zwtm75.x b/unix/gdev/iism75/zwtm75.x
new file mode 100644
index 00000000..491b0f50
--- /dev/null
+++ b/unix/gdev/iism75/zwtm75.x
@@ -0,0 +1,29 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+
+# ZWTM75 -- Wait for i/o completion and return the number of bytes read or
+# written or ERR.  Repetitive calls return the same value.
+
+procedure zwtm75 (ifcb, status)
+
+int	ifcb			# pointer to channel descriptor passed as int
+int	status			# nbytes transferred or ERR
+
+pointer	fcb
+
+begin
+	fcb = ifcb
+
+	switch (FCB_STATUS(fcb)) {
+	case ERR:
+	    status = ERR
+	case IIS_INACTIVE:
+	    status = FCB_NBYTES(fcb)
+
+	default:
+	    call zawtbf (FCB_CHAN(fcb), status)
+	    FCB_STATUS(fcb) = IIS_INACTIVE
+	}
+end
diff --git a/unix/gdev/iism75/zzrdii.x b/unix/gdev/iism75/zzrdii.x
new file mode 100644
index 00000000..f72058c3
--- /dev/null
+++ b/unix/gdev/iism75/zzrdii.x
@@ -0,0 +1,17 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+
+# ZZRDII -- Initiate an asynchronous read from the IIS.
+
+procedure zzrdii (fcb, buf, nbytes, offset)
+
+pointer	fcb			# pointer to channel descriptor
+char	buf[ARB]		# output buffer
+int	nbytes			# number of  bytes to read
+long	offset			# not used for this device
+
+begin
+	call zardbf (FCB_CHAN(fcb), buf, nbytes, offset)
+end
diff --git a/unix/gdev/iism75/zzwrii.x b/unix/gdev/iism75/zzwrii.x
new file mode 100644
index 00000000..8515cc64
--- /dev/null
+++ b/unix/gdev/iism75/zzwrii.x
@@ -0,0 +1,17 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	"m75.h"
+
+# ZZWRII -- Initiate an asynchronous write to the IIS.
+
+procedure zzwrii (fcb, buf, nbytes, offset)
+
+pointer	fcb			# pointer to channel descriptor
+char	buf[ARB]		# input buffer
+int	nbytes			# number of  bytes to write
+long	offset			# not used for this device
+
+begin
+	call zawrbf (FCB_CHAN(fcb), buf, nbytes, offset)
+end
diff --git a/unix/gdev/m70vms/README b/unix/gdev/m70vms/README
new file mode 100644
index 00000000..23a06824
--- /dev/null
+++ b/unix/gdev/m70vms/README
@@ -0,0 +1,68 @@
+VMS IRAF/FIO device driver for the IIS Model 70
+(will probably also work for the model 75).  11/85 dct
+----------------------------------------------------------------------
+
+This directory contains the IRAF/FIO driver subroutines for the IIS Model 70
+image display on VMS.  This directory is self contained; no external code is
+required other than the VMS/IIS device driver itself.  The code should be
+portable to any VMS system.
+
+
+Driver Procedures:
+
+	zopm70	-- open + allocate
+	zclm70	-- close + deallocate
+	zrdm70	-- asynchronous binary read
+	zwrm70	-- asynchronous binary write
+	zwtm70	-- wait for i/o completion, return status
+	zstm70	-- get device status
+
+
+On a UNIX system the ordinary binary file driver (ZFIOBF) may be used for these
+functions.  This might work on VMS too, but the IRAF/VMS binary file driver is
+complicated and uses RMS, so I did not bother to try.  This driver uses a
+modified version local KPNO IIS library, which I suppose came originally from
+IIS corp.  The interface procedures are written in VMS Fortran and make direct
+calls to the VMS system services.  The original library has been modified to
+convert all the names to the prefix "m70", and to remove all Fortran i/o.
+
+
+VMS/IIS Interface Procedures:
+
+	m70get (fcb, error)		# open+allocate+mclear
+	m70rel (fcb)			# close+deallocate
+	m70opn (fcb, error)		# open
+	m70cls (fcb)			# close
+	m70mcl (fcb, error)		# master clear
+
+	m70io  (fcb, data, count, read, opcd, iosb, error)
+	m70wt  (fcb, bfnum, bfcnt, iosb, error)
+	m70wti (fcb, func, time, button, x, y)
+
+
+M70IO: I/O between M70 and a VAX.
+
+        fcb      function communications block.
+        data     input/output buffer.
+        count    number of words to read/write.
+        read     0 -> write, 1 -> read.
+        opcd     :: 0 -> qio with efn = 1 and wait for completion
+                    1 -> qio with efn = 2
+                    2 -> qio with efn = 3
+	iosb 	 I/O status quadword
+	error    :: -1 => display not available
+		     0 => success
+	             1 => time/out
+	             2 => invalid or non-responding device
+	           1000 > machine dependent error code
+
+
+M70WT: Wait for i/o.
+
+        fcb      function communication block.
+        bfnum    used to determine event flag to wait for
+        bfcnt    number of words in buffer.  should be -1 indicating
+                 i/o pending.  reset to zero when i/o completed.
+        iosb     i/o status block
+        error    0 success, -1 not acquired, 1 timeout,
+                 2 invalid device, 1000+n system dep. error
diff --git a/unix/gdev/m70vms/fcbu.inc b/unix/gdev/m70vms/fcbu.inc
new file mode 100644
index 00000000..54f23244
--- /dev/null
+++ b/unix/gdev/m70vms/fcbu.inc
@@ -0,0 +1,6 @@
+c
+c	vax offsets for display.for and termio.for
+c
+	parameter	fcb_u_spool = 21
+	parameter	fcb_u_m70_chan = 19
+	parameter	fcb_u_m70_name = 17
diff --git a/unix/gdev/m70vms/m70.h b/unix/gdev/m70vms/m70.h
new file mode 100644
index 00000000..16b4c938
--- /dev/null
+++ b/unix/gdev/m70vms/m70.h
@@ -0,0 +1,30 @@
+# Definitions for the VMS/IIS device driver.
+
+define	IIS_READ	1		# read function code
+define	IIS_WRITE	0		# write function code
+define	IIS_INACTIVE	2		# no i/o in progress
+
+define	EFN		EFN2		# EFN to use for i/o
+define	EFN1W		0		# efn #1, wait for completion
+define	EFN2		1		# efn #2, no wait for completion
+define	EFN3		2		# efn #3, no wait for completion
+
+# Function control block structure for IIS.  The first part of the structure
+# is filled in by VMS at open time; all we need to know is the offset of the
+# device name.  We use the latter part of the buffer for our own internal
+# variables.
+
+define	LEN_FCB		28
+define	FCB_U_NAME	Mems[($1)+16+($2)-1]
+define	FCB_IOSB	Mems[($1)+20+($2)-1]
+define	FCB_KCHAN	Mems[($1)+24]	# NULL if on local node, else remote
+define	FCB_STATUS	Mems[($1)+25]	# channel status (r, w, err)
+define	FCB_NBYTES	Mems[($1)+26]	# nbytes last transfer
+define	FCB_EFN		Mems[($1)+27]	# event flag used for transfer
+
+# IIS device status words.
+
+define	IIS_FILSIZE		(512 * 512 * SZB_CHAR)
+define	IIS_BLKSIZE		1024
+define	IIS_OPTBUFSIZE		(512 * SZB_CHAR)
+define	IIS_MAXBUFSIZE		32768
diff --git a/unix/gdev/m70vms/m70cls.f b/unix/gdev/m70vms/m70cls.f
new file mode 100644
index 00000000..9eb2fcd3
--- /dev/null
+++ b/unix/gdev/m70vms/m70cls.f
@@ -0,0 +1,26 @@
+	subroutine m70cls (fcb)
+c
+c  Routine to close model 70 display
+c
+	integer fcb(*)
+	include 'fcbu.inc'
+c
+	integer*4 sys$dassgn, chan, junk
+	integer*2 chan2(2)
+	equivalence (chan, chan2)
+c
+c	call wtexec (fcb)
+c
+	chan2(1) = fcb(fcb_u_m70_chan)
+	chan2(2) = fcb(fcb_u_m70_chan+1)
+c
+c	if (chan.ne.0) call lib$signal (%val(sys$dassgn (%val(chan))))
+	if (chan.ne.0) then
+	    junk = sys$dassgn (%val(chan))
+	endif
+c
+	fcb(fcb_u_m70_chan) = 0
+	fcb(fcb_u_m70_chan+1) = 0
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70get.f b/unix/gdev/m70vms/m70get.f
new file mode 100644
index 00000000..c9d0b1c2
--- /dev/null
+++ b/unix/gdev/m70vms/m70get.f
@@ -0,0 +1,43 @@
+	subroutine m70get (fcb, error)
+c
+c  Routine to get (allocate) the model 70
+c
+c     arguments:
+c
+c        fcb      function communications block
+c
+c        error    -2 => device already allocated
+c                 -1 => m70 not acquired
+c                  0 => success
+c                  1 => timeout
+c                  2 => invalid device or powerfail
+c                  >=1000 machine dependent error number
+c
+	integer fcb(*), error
+c
+	include 'fcbu.inc'
+	external ss$_normal, ss$_devalloc
+	integer*4 len,status, sys$alloc
+	integer*2 nam2(2), stat
+	byte nam(4)
+	character name*4, result*8
+	equivalence (nam2, nam), (name, nam), (status, stat)
+c
+	nam2(1) = fcb(fcb_u_m70_name)
+	nam2(2) = fcb(fcb_u_m70_name+1)
+c
+	status = sys$alloc (name, len, result,)
+	if (status.ne.%loc(ss$_normal)) then
+            if (status .eq. %loc(ss$_devalloc)) then
+               error = -2
+            else
+	       error = 1000 + stat
+            endif
+	else
+	  call m70opn (fcb, error)
+          if (error .ne. 0) return
+	  call m70mcl (fcb, error)
+	endif
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70io.f b/unix/gdev/m70vms/m70io.f
new file mode 100644
index 00000000..cbe0418e
--- /dev/null
+++ b/unix/gdev/m70vms/m70io.f
@@ -0,0 +1,75 @@
+	subroutine m70io (fcb, data, count, read, opcd, iosb, error)
+c
+c     Routine does io between M70 and a VAX
+c
+c     Parameters:
+c
+c        fcb      function communications block.
+c
+c        data     input/output buffer.
+c
+c        count    number of words to read/write.
+c
+c        read     0 -> write, 1 -> read.
+c
+c        opcd     0 -> qio with efn = 1 and wait for completion
+c                 1 -> qio with efn = 2
+c                 2 -> qio with efn = 3
+c                 
+c	iosb	I/O status quadword
+c
+c	error    -1 => display not available
+c		  0 => success
+c	          1 => time/out
+c	          2 => invalid or non-responding device
+c	          1000 > machine dependent error code
+c
+	integer fcb(*), data(1), count, read, opcd, error
+	integer*4 iosb(2)
+c
+	include 'fcbu.inc'
+	external io$_writevblk, io$_readvblk, ss$_timeout, ss$_powerfail
+	integer*4 chan, sys$qio, sys$waitfr, func, status, l_iosb(2)
+	integer*2 chan2(2), stat(2)
+	equivalence (chan, chan2), (status, stat(1))
+c
+	chan2(1) = fcb(fcb_u_m70_chan)
+	chan2(2) = fcb(fcb_u_m70_chan+1)
+c
+	if (read.eq.1) then
+	  func = %loc(io$_readvblk)
+	else
+	  func = %loc(io$_writevblk)
+	endif
+c
+	if (opcd.eq.0) then
+	  status = sys$qio (%val(opcd+1), %val(chan), %val(func),
+	1		l_iosb,,, data, %val(2*count),,,,)
+	  if (status) then
+	     status = sys$waitfr (%val(1))
+	     if (l_iosb(1)) then
+	        error = 0
+	     else
+	        stat(1) = lib$match_cond 
+	1               (iosb, ss$_timeout, ss$_powerfail)
+	        if (stat(1) .eq. 0) then
+	           error = 1000 + iosb(1)
+	        else
+	           error = stat(1)
+	        endif
+	     endif
+	  else
+	     error = 1000 + stat(1)
+	  endif
+	else
+	  status = sys$qio (%val(opcd+1), %val(chan), %val(func),
+	1		iosb,,, data, %val(2*count),,,,)
+	  if (status) then
+	     error = 0
+	  else
+	     error = 1000 + stat(1)
+	  endif
+	endif
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70mcl.f b/unix/gdev/m70vms/m70mcl.f
new file mode 100644
index 00000000..c9fb5c98
--- /dev/null
+++ b/unix/gdev/m70vms/m70mcl.f
@@ -0,0 +1,35 @@
+	subroutine m70mcl (fcb, error)
+c
+c     master clear model 70
+c
+	integer fcb(*), error
+c
+	include 'fcbu.inc'
+	external io$_rewind, ss$_normal
+	integer*4 status, iosb(2), chan, sys$qiow
+	integer*2 chan2(2), iostat, stat
+	equivalence (chan, chan2), (iosb, iostat)
+        equivalence (status, stat)
+        external ss$_timeout, ss$_powerfail
+c
+	chan2(1) = fcb(fcb_u_m70_chan)
+	chan2(2) = fcb(fcb_u_m70_chan+1)
+c
+	status = sys$qiow (, %val(chan), io$_rewind, iosb,,,,,,,,)
+	if (status) then
+           if (iosb(1)) then
+              error = 0
+           else
+              status = lib$match_cond (iosb, ss$_timeout, ss$_powerfail)
+              if (status .eq. 0) then
+                 error = 1000 + iostat
+              else
+                 error = status
+              endif
+           endif
+        else
+           error = 1000 + stat
+        endif
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70opn.f b/unix/gdev/m70vms/m70opn.f
new file mode 100644
index 00000000..4bb91b3a
--- /dev/null
+++ b/unix/gdev/m70vms/m70opn.f
@@ -0,0 +1,41 @@
+	subroutine m70opn (FCB, error)
+C
+c  Routine to open model 70
+c
+c	Error is returned as:
+c	   -1 = display open 
+c	    0 = OK
+c	    1 = timeout
+c	    2 = invalid or non-responding device 
+c	    >= 1000 : machine dependent error number
+c
+	integer fcb(*), error
+	include 'fcbu.inc'
+C
+	integer*4 sys$assign, chan, status
+	integer*2 chan2(2), name2(2), stat(2)
+	byte name1(4)
+	character*4 m70
+	equivalence (chan, chan2), (status, stat(1))
+	equivalence (name1, name2), (name1, m70)
+C
+	name2(1) = fcb(fcb_u_m70_name)
+	name2(2) = fcb(fcb_u_m70_name+1)
+	chan2(1) = fcb(fcb_u_m70_chan)
+	chan2(2) = fcb(fcb_u_m70_chan+1)
+c
+	if (chan.eq.0) then
+	  status = sys$assign ('_'//m70//':', chan,,)
+	  if (status) then
+	    fcb(fcb_u_m70_chan) = chan2(1)
+	    fcb(fcb_u_m70_chan+1) = chan2(2)
+	    error = 0
+	  else
+	    error = 1000 + stat(1)
+	  endif
+	else
+	  error = -1
+	endif
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70rel.f b/unix/gdev/m70vms/m70rel.f
new file mode 100644
index 00000000..7b686d10
--- /dev/null
+++ b/unix/gdev/m70vms/m70rel.f
@@ -0,0 +1,19 @@
+	subroutine m70rel (fcb)
+c
+c     routine to release(DEALLOCATE) the model 70
+c
+	integer fcb(*)
+c
+	include 'fcbu.inc'
+	integer*2 dev2(2)
+	byte dev(4)
+	character*4 m70
+	equivalence (dev2,dev), (m70,dev)
+c
+	call m70cls (fcb)
+	dev2(1) = fcb(fcb_u_m70_name)
+	dev2(2) = fcb(fcb_u_m70_name+1)
+	call sys$dalloc ('_'//m70//':',)
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70wt.f b/unix/gdev/m70vms/m70wt.f
new file mode 100644
index 00000000..715a1c68
--- /dev/null
+++ b/unix/gdev/m70vms/m70wt.f
@@ -0,0 +1,44 @@
+	subroutine m70wt (fcb, bfnum, bfcnt, iosb, error)
+c
+c     routine to wait for completion of buffer write on pdp-11's
+c
+c        fcb      function communication block.
+c        bfnum    used to determine event flag to wait for
+c        bfcnt    number of words in buffer.  should be -1 indicating
+c                 i/o pending.  reset to zero when i/o completed.
+c        iosb     i/o status block
+c        error    0 success, -1 not acquired, 1 timeout,
+c                 2 invalid device, 1000+n system dep. error
+c
+	integer fcb(*)
+	integer bfnum, bfcnt, error
+	integer*4 iosb(2), status
+	integer*2 stat(2)
+c
+	integer*4 sys$waitfr
+	equivalence (status, stat(1))
+	external ss$_timeout, ss$_powerfail
+c
+c     is this wait required?
+c
+	error = 0
+	if (bfcnt .ge. 0) return
+c
+	status = sys$waitfr (%val(bfnum+1))
+	if (status) then
+	   bfcnt = 0
+	   if (.not. iosb(1)) then
+	      stat(1) = lib$match_cond 
+	1               (iosb, ss$_timeout, ss$_powerfail)
+	      if (stat(1) .eq. 0) then
+	         error = 1000 + iosb(1)
+	      else
+	         error = stat(1)
+	      endif
+	   endif
+	else
+	   error = 1000 + stat(1)
+	endif
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/m70wti.f b/unix/gdev/m70vms/m70wti.f
new file mode 100644
index 00000000..0aabd1fd
--- /dev/null
+++ b/unix/gdev/m70vms/m70wti.f
@@ -0,0 +1,46 @@
+	subroutine m70wti (fcb, func, time, button, x, y)
+c
+c     This routine waits for the appropriate interupt from the  
+c     Unibus M70 interface card, then returns button and cursor
+c     information.
+c
+c
+c     parameter descriptions:
+c
+c        fcb   is a system info. array.
+c
+c        func  is interpreted:
+c                 0 ==> wait for button push.
+c                 1 ==> wait for cursor move.
+c                 2 ==> wait for button push or cursor move.
+c
+	integer fcb(*), func, time, button, x, y
+c
+	include 'fcbu.inc'
+	external io$_rewindoff
+	integer*4 sys$qiow, mask, chan, iosb(2)
+	integer*2 chan2(2)
+	equivalence (chan, chan2)
+c
+	chan2(1) = fcb(fcb_u_m70_chan)	! get M70 channel
+	chan2(2) = fcb(fcb_u_m70_chan+1)
+c
+	if (func.eq.0) then
+	  mask = '0400'x		! wait for button
+	elseif (func.eq.1) then
+	  mask = '0800'x		! wait for trackball
+	elseif (func.eq.2) then
+	  mask = '0C00'x		! wait for button or trackball
+	else
+	  mask = '0C00'x
+	endif
+c
+	status = sys$qiow (, %val(chan), io$_rewindoff,
+	1		iosb,,,%val(mask),,,,,)
+c
+c  Get button word and X-Y position of cursor
+c
+	call rbutn (fcb, button, x, y)
+c
+	return
+	end
diff --git a/unix/gdev/m70vms/mkpkg b/unix/gdev/m70vms/mkpkg
new file mode 100644
index 00000000..976cc1e4
--- /dev/null
+++ b/unix/gdev/m70vms/mkpkg
@@ -0,0 +1,29 @@
+# Makelib for the VMS version of the IIS driver.
+
+$checkout libpkg.a ../
+$update	  libpkg.a
+$checkin  libpkg.a ../
+$exit
+
+libpkg.a:
+	@(i2)
+	zclm70.x	m70.h <mach.h> <knet.h>
+	zopm70.x	m70.h <mach.h> <knet.h>
+	zrdm70.x	m70.h <mach.h> <knet.h>
+	zstm70.x	m70.h <mach.h> <fio.h>
+	zwrm70.x	m70.h <mach.h> <knet.h>
+	zwtm70.x	m70.h <mach.h> <knet.h>
+	; 
+
+i2:	# Compile the VMS/Fortran IIS i/o routines with the VMS /NOI4 option.
+	$set	XFLAGS = "-c -O -i2"
+
+	m70cls.f	fcbu.inc
+	m70get.f	fcbu.inc
+	m70io.f		fcbu.inc
+	m70mcl.f	fcbu.inc
+	m70opn.f	fcbu.inc
+	m70rel.f	fcbu.inc
+	m70wt.f
+	m70wti.f	fcbu.inc
+	;
diff --git a/unix/gdev/m70vms/zclm70.x b/unix/gdev/m70vms/zclm70.x
new file mode 100644
index 00000000..a7ebb8f7
--- /dev/null
+++ b/unix/gdev/m70vms/zclm70.x
@@ -0,0 +1,24 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<knet.h>
+include	"m70.h"
+
+# ZCLM70 -- Close and deallocate the IIS.
+
+procedure zclm70 (chan, status)
+
+int	chan			# FCB pointer for device
+int	status
+pointer	fcb
+
+begin
+	fcb = chan
+	if (FCB_KCHAN(fcb) == NULL) {
+	    call zwtm70 (chan, status)
+	    call m70rel (Mems[fcb])
+	} else
+	    call zclsbf (FCB_KCHAN(fcb), status)
+
+	call mfree (fcb, TY_SHORT)
+end
diff --git a/unix/gdev/m70vms/zopm70.x b/unix/gdev/m70vms/zopm70.x
new file mode 100644
index 00000000..f338dbe7
--- /dev/null
+++ b/unix/gdev/m70vms/zopm70.x
@@ -0,0 +1,59 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<knet.h>
+include	"m70.h"
+
+# ZOPM70 -- Open the IIS for binary file i/o.  The device will be automatically
+# allocated if necessary.
+
+procedure zopm70 (device, mode, chan)
+
+char	device[ARB]		# packed VMS device name
+int	mode			# access mode
+int	chan			# receives device channel
+
+pointer	fcb
+int	kchan
+char	upkdev[SZ_FNAME]
+int	ki_connect()
+
+short	ier
+%	character m70*4
+%	integer*2 namw(2)
+%	equivalence (m70, namw)
+
+begin
+	call calloc (fcb, LEN_FCB, TY_SHORT)
+
+	# Use the binary file driver if the device resides on a remote node.
+	# This precludes remote access to a VMS hosted IIS at present.
+
+	if (ki_connect (device) != NULL) {
+	    call zopnbf (device, mode, kchan)
+	    if (kchan != ERR)
+		FCB_KCHAN(fcb) = kchan
+	} else {
+	    # Load string descriptor for device name into FCB.
+	    call strupk (device, upkdev, SZ_FNAME)
+%	    call f77pak (upkdev, m70, 4)
+
+	    FCB_U_NAME(fcb,1) = namw[1]
+	    FCB_U_NAME(fcb,2) = namw[2]
+	    FCB_KCHAN(fcb)    = NULL
+	    FCB_STATUS(fcb)   = IIS_INACTIVE
+	    FCB_NBYTES(fcb)   = 0
+
+	    # Allocate and open the device.
+	    call m70get (Mems[fcb], ier)
+	    kchan = ier
+	    if (kchan != 0)
+		kchan = ERR
+	}
+
+	if (kchan < 0) {
+	    call mfree (fcb, TY_SHORT)
+	    chan = ERR
+	} else
+	    chan = fcb
+end
diff --git a/unix/gdev/m70vms/zrdm70.x b/unix/gdev/m70vms/zrdm70.x
new file mode 100644
index 00000000..2bf726ab
--- /dev/null
+++ b/unix/gdev/m70vms/zrdm70.x
@@ -0,0 +1,36 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<knet.h>
+include	"m70.h"
+
+# ZRDM70 -- Initiate an asynchronous read from the IIS.
+
+procedure zrdm70 (chan, buf, nbytes, offset)
+
+int	chan			# FCB pointer for device
+char	buf[ARB]		# output buffer
+int	nbytes			# number of  bytes to read
+long	offset			# not used for this device
+
+pointer	fcb
+short	rwflag, opcd, nwords, ier
+data	rwflag /IIS_READ/, opcd /EFN/
+
+begin
+	fcb = chan
+	if (FCB_KCHAN(fcb) == NULL) {
+	    nwords = nbytes / (SZ_SHORT * SZB_CHAR)
+	    call m70io (Mems[fcb], buf, nwords, rwflag, opcd, FCB_IOSB(fcb,1),
+		ier)
+
+	    FCB_NBYTES(fcb) = nbytes
+	    FCB_EFN(fcb)    = opcd
+
+	    if (ier != 0)
+		FCB_STATUS(fcb) = ERR
+	    else
+		FCB_STATUS(fcb) = IIS_READ
+	} else
+	    call zardbf (FCB_KCHAN(fcb), buf, nbytes, offset)
+end
diff --git a/unix/gdev/m70vms/zstm70.x b/unix/gdev/m70vms/zstm70.x
new file mode 100644
index 00000000..2b790dfa
--- /dev/null
+++ b/unix/gdev/m70vms/zstm70.x
@@ -0,0 +1,28 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<fio.h>
+include	"m70.h"
+
+# ZSTM70 -- Return device status for the IIS.
+
+procedure zstm70 (chan, what, lvalue)
+
+int	chan			# FCB pointer for device
+int	what			# status parameter
+long	lvalue
+
+begin
+	switch (what) {
+	case FSTT_FILSIZE:
+	    lvalue = IIS_FILSIZE
+	case FSTT_BLKSIZE:
+	    lvalue = IIS_BLKSIZE
+	case FSTT_OPTBUFSIZE:
+	    lvalue = IIS_OPTBUFSIZE
+	case FSTT_MAXBUFSIZE:
+	    lvalue = IIS_MAXBUFSIZE
+	default:
+	    lvalue = ERR
+	}
+end
diff --git a/unix/gdev/m70vms/zwrm70.x b/unix/gdev/m70vms/zwrm70.x
new file mode 100644
index 00000000..7cc1ef8a
--- /dev/null
+++ b/unix/gdev/m70vms/zwrm70.x
@@ -0,0 +1,36 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<knet.h>
+include	"m70.h"
+
+# ZWRM70 -- Initiate an asynchronous write to the IIS.
+
+procedure zwrm70 (chan, buf, nbytes, offset)
+
+int	chan			# FCB pointer for device
+char	buf[ARB]		# input buffer
+int	nbytes			# number of  bytes to write
+long	offset			# not used for this device
+
+pointer	fcb
+short	rwflag, opcd, nwords, ier
+data	rwflag /IIS_WRITE/, opcd /EFN/
+
+begin
+	fcb = chan
+	if (FCB_KCHAN(fcb) == NULL) {
+	    nwords = nbytes / (SZ_SHORT * SZB_CHAR)
+	    call m70io (Mems[fcb], buf, nwords, rwflag, opcd, FCB_IOSB(fcb,1),
+		ier)
+
+	    FCB_NBYTES(fcb) = nbytes
+	    FCB_EFN(fcb)    = opcd
+
+	    if (ier != 0)
+		FCB_STATUS(fcb) = ERR
+	    else
+		FCB_STATUS(fcb) = IIS_WRITE
+	} else
+	    call zawrbf (FCB_KCHAN(fcb), buf, nbytes, offset)
+end
diff --git a/unix/gdev/m70vms/zwtm70.x b/unix/gdev/m70vms/zwtm70.x
new file mode 100644
index 00000000..69ab39da
--- /dev/null
+++ b/unix/gdev/m70vms/zwtm70.x
@@ -0,0 +1,44 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<mach.h>
+include	<knet.h>
+include	"m70.h"
+
+# ZWTM70 -- Wait for i/o completion and return the number of bytes read or
+# written or ERR.  Repetitive calls return the same value.
+
+procedure zwtm70 (chan, status)
+
+int	chan			# FCB pointer for device
+int	status			# nbytes transferred or ERR
+
+pointer	fcb
+short	bfnum, bufcnt, ier
+
+begin
+	fcb = chan
+
+	if (FCB_KCHAN(fcb) == NULL) {
+	    switch (FCB_STATUS(fcb)) {
+	    case ERR:
+		status = ERR
+	    case IIS_INACTIVE:
+		status = FCB_NBYTES(fcb)
+
+	    default:
+		bfcnt = -1		# m70wt is a nop if we don't do this
+		bfnum = FCB_EFN(fcb)
+
+		call m70wt (Mems[fcb], bfnum, bfcnt, FCB_IOSB(fcb,1), ier)
+
+		if (ier != 0)
+		    status = ERR
+		else
+		    status = FCB_NBYTES(fcb)
+
+		FCB_STATUS(fcb) = IIS_INACTIVE
+	    }
+
+	} else
+	    call zawtbf (FCB_KCHAN(fcb), status)
+end
diff --git a/unix/gdev/mkpkg b/unix/gdev/mkpkg
new file mode 100644
index 00000000..800c7e9c
--- /dev/null
+++ b/unix/gdev/mkpkg
@@ -0,0 +1,12 @@
+# Make the ZFIOGD (binary graphics) device driver and install it in libsys.
+
+$checkout libsys.a lib$
+$update   libsys.a
+$checkin  libsys.a lib$
+$exit
+
+libsys.a:
+	zfiogd.x	<fio.h> <mach.h>
+	@iism70
+	@iism75
+	;
diff --git a/unix/gdev/mkpkg.sh b/unix/gdev/mkpkg.sh
new file mode 100644
index 00000000..3984d71f
--- /dev/null
+++ b/unix/gdev/mkpkg.sh
@@ -0,0 +1,3 @@
+# GDEV -- Host dependent graphics device drivers.
+
+(cd sgidev;  sh -x mkpkg.sh)
diff --git a/unix/gdev/sgidev/README b/unix/gdev/sgidev/README
new file mode 100644
index 00000000..363b490f
--- /dev/null
+++ b/unix/gdev/sgidev/README
@@ -0,0 +1,24 @@
+SGIDEV -- This directory contains the UNIX dependent sources for the metacode
+or bitmap translation programs for all devices supported by the SGI graphics
+kernel.  See gio$sgikern or `help sgikern' for further information on SGI.
+
+To add a new SGI device:
+
+	[1] Add source file for translator to this directory.
+	[2] Add references to mkpkg.csh and mkpkg.
+	[3] Run `mkpkg update' in this directory to install new translator.
+
+	[4] Add entry to graphcap file, including DD command string
+		containing host command to dispose of the output.
+
+	[5] Test new device interface.
+
+Alternatively, you might wish to install the source for the translator in
+local somewhere, to avoid a merge operation when a new version of the VMS
+host system interface is installed.
+                       
+Note that some example graphcap entries for SGI devices might require non-
+standard tasks residing outside of IRAF, for example the `impress300'
+command to ship Impress output from a UNIX node to a VMS node running
+Eunice in order to execute the VMS IMPRINT command.  These are considered
+so unusual that support is not included in the standard system.
diff --git a/unix/gdev/sgidev/README.gif b/unix/gdev/sgidev/README.gif
new file mode 100644
index 00000000..85833d3f
--- /dev/null
+++ b/unix/gdev/sgidev/README.gif
@@ -0,0 +1,438 @@
+
+Announcement for adass.iraf.system:
+
+	An SGI translator which converts IRAF graphics directly to GIF
+images is now available from our anonymous ftp archive as
+
+	ftp://iraf.noao.edu/pub/sgi2gif.c
+	ftp://iraf.noao.edu/pub/sgi2gif.readme
+
+The associated readme file describes how to install the translator and
+configure a variety of graphcap entries for it.  
+	SGI translators are used to convert IRAF graphics to some other
+format, usually Postscript, for disposal to a printer or some other
+hardcopy device.  The SGI2GIF translator now allows users to generate
+GIF images (suitable for web page presentation) directly from IRAF using
+the familiar ":.snap" command or non-interactively.  See the readme file
+for a full discussion of the capabilities and configuration options, or
+contact site support (iraf@noao.edu) with questions or problems. 
+
+--------------------------------------------------------------------------------
+
+README:
+
+1. Introduction
+---------------
+
+	IRAF hardcopy graphics are generated by converting the graphics
+metacode through the SGI (Simple Graphics Interface) kernel which
+translates the numerous graphics commands to a minimal set of move/draw
+instructions or a bitmap raster of the plot.  In the case of
+hardcopy/output graphics (i.e. the SGI kernel), the dev$graphcap file
+defines parameters for this conversion which include the plot size, SGI
+kernel options, and most especially a "device dispose" (DD) string which
+specifies the SGI translator to be used and what to do with the resulting
+translator output.  The SGI kernel is not a full graphics kernel so
+information such as line color and fill areas are lost, below we will
+discuss how to retain this when producing a GIF images using other
+translators and graphcap file trickery.
+
+	For most printer devices the "sgi2uapl" Postscript translator is
+used to convert the SGI kernel metacode from a series of move/draw
+instructions to equivalent postscript commands, other translators are
+available to convert to other printer languages.  The SGI kernel can also
+be used, with the proper graphcap entries, to generate a bitmap raster of
+the plot which can be easily converted to various image formats.  The SGI2GIF
+translator takes advantage of this latter feature to produce GIF images
+directly from the IRAF graphics metacode.
+
+	The translator has options for specifying the image size,
+foreground and background colors, GIF transparency, and can be used to
+convert multiple input bitmap files or a single file containing multiple
+graphics frames.  It allows users to easily generate images suitable for
+presentation on the web, either manually or automatically.
+
+
+2. Installation
+---------------
+
+	The SGI translator is distributed in source form and to be used
+must be compiled and installed in the system hbin$ directory.  To install
+the new SGI translator follow these steps while logged in through the iraf
+user account:
+
+     [1]  Download the translator from the IRAF anonymous FTP archive or
+	  one of it's mirror sites using:
+
+	       % ftp iraf.noao.edu (140.252.1.1)
+	        login: anonymous
+	        password: [your email address]
+	        ftp> cd /pub
+	        ftp> mget sgi2gif.c
+	        ftp> quit
+
+     [2]  Compile the source using
+
+	     % cc -o sgi2gif.e sgi2gif.c	# compile the source
+	     % mv sgi2gif.e $hbin		# move to the $hbin
+
+	  "$hbin" is defined in the iraf environment to be something like
+	  $iraf/unix/bin.<arch>, where <arch> would be 'ssol' for Solaris,
+	  'sparc' for SunOS and so on.
+
+     [3]  Optionally place the source in the directory $iraf/unix/gdev/sgidev.
+
+     [4]  Edit the dev$graphcap file and add the following default entries
+	  for the device near the top of the file:
+
+	    g-gif|UNIX generic interface to multi-frame GIF file generator:\
+	        :DD=ugif,tmp$sgk,!{ sgidispatch sgi2gif -w $(PX) -h $(PY) \
+	        -bg 0 0 0 -fg 255 255 255 -root sgigif $F.[1-8] ; \
+		rm $F.[1-8]; }&:MF#8:NF:tc=sgi_image_format:
+
+	    sgi_image_format|Generic raster file format specification:\
+	        :kf=bin$x_sgikern.e:tn=sgikern:ar#.75:\
+	        :xr#640:yr#480 :PX#640:PY#480 :XW#640:YW#480:\
+	        :BI:MF#1:YF:NB#8:LO#1:LS#0:XO#0:YO#0:
+
+	The 'g-gif' entry takes one or more graphics file input and converts
+	each input frame to a redirected file on output called 'sgigifXXX.gif'
+	where the 'XXX' is frame number.  See below for details one
+	configuring other graphcap entries.
+
+
+2. Translator Options
+---------------------
+    The SGI2GIF translator allows the following options:
+
+        -w N         Set the width of input bitmap and output image.  The
+		     argument must be derived from the graphcap value since
+		     that is what the SGI kernel will use when generating the
+		     bitmap, e.g.  "-w $(PX)" instead of "-w 640".
+
+        -h N         Set the height of input bitmap and output image. The
+		     argument must be derived from the graphcap value since
+		     that is what the SGI kernel will use when generating the
+		     bitmap, e.g.  "-h $(PY)" instead of "-h 640".
+
+        -i           Invert the bitmap before conversion.  By default the
+		     graphics are drawn using the foreground color, this
+		     option inverts the bitmap before conversion meaning the
+		     graphics are drawn using the background color.
+
+        -t           Set background color as transparent.  If enabled the
+		     translator will produce a GIF89 format image with the
+		     background color set as "transparent".  When this image
+		     is used with an HTML document the background color is
+		     the HTML page color.
+
+        -root        Set the root rame for output file.  If defined this
+		     root name will be combined with the frame number and
+		     a ".gif" extension to form the output name.  If not 
+		     defined and only one input image is present the default
+		     action is to send the output to STDOUT.
+
+        -fg R G B    Specify foreground color (default 'black').  Set the
+		     foreground color as a triplet of RGB values in the
+		     range 0-255.  The -fg flag must have three arguments.
+
+        -bg R G B    Specify background color (default 'white').  Set the
+		     foreground color as a triplet of RGB values in the
+		     range 0-255.  The -bg flag must have three arguments.
+
+
+3. Configuring Alternate Graphcap Entries
+-----------------------------------------
+
+	Most of the work in a graphcap entry is done by the 'device
+dispose' (i.e. "DD") string.  This string is composed of three comma
+delimited parts:  a node/device name (which is normally ignored), a
+temporary filename, and a host dispose command.  To configure a new entry
+it is only this last field that normally needs to be modified, perhaps in
+conjunction with another graphcap parameter.  As an example let's look at
+the DD string used in the example graphcap above:
+
+   :DD=ugif,tmp$sgk,!{ sgidispatch sgi2gif -w $(PX) -h $(PY) \
+   -bg 0 0 0 -fg 255 255 255 -root sgigif $F.[1-8] ; rm $F.[1-8]; }&:
+
+where 'ugif' is the unused node/device name, 'tmp$sgk' is the temporary
+filename, and the remainder is a host dispose command.  The 'sgidispatch'
+command is an iraf binary that launches the specified translator
+('sgi2gif' here) with any required arguments.  Note that everything within
+the "!{...}&" curly braces is executed (as a background Bourne shell
+command) so any string of valid unix command separate by a semicolon will
+be executed.  In this case the sgidispatch command launches the sgi2gif
+translator with all of it's arguments, it then deletes the input metacode
+file symbolized by the "$F".
+	You may notice that some arguments are specified as e.g. "-w
+$(PX)".  When the DD string is executed any macro values beginning with a
+'$' such as '$(PX)' are replaced with values from the rest of the graphcap
+entry.  In this case '$(PX)' is replaced by the value contained in the
+graphcap :PX (physical X size) field, the "$F.[1-8]" is expanded to
+include the unique root filename along with any extension 1 thru 8 which may
+be generated because of multiple plots in the input.   In
+most cases all you may need to change in the DD string itself is the
+output file, or e.g. whether it gets piped to some other command.
+
+
+3.1 Changing Image Size
+-----------------------
+
+	Changing the image size is simply a matter of changing the graphcap
+parameters
+
+	    :xr#640:yr#480:		sets X,Y device resolution
+	    :PX#640:PY#480:		sets X,Y physical size of bitmap
+	    :XW#640:YW#480: 		sets X,Y width of plotting window
+
+These are defined in the 'sgi_image_format' entry given above.  Graphics
+are drawn using Normalized Device Coordinates ('NDC', values in the range
+0.0 to 1.0) and will be scaled appropriately for any specified output
+dimensions allowing users to configure graphcap entries for images which are
+larger/smaller than the default, or have square or elongated aspect ratios.
+
+3.2 Preserving Color Information
+--------------------------------
+
+	Colors such as those used for the axis labels and frame, and colors
+used in the plot itself for different line/marker types cannot be preserved
+by the SGI kernel directly.  To do this you must use a full graphics kernel
+such as the PSIKERN postscript kernel found in STSDAS.  The V2.11
+distribution contains graphcap entries suitable for this kernel but assumes
+you have STSDAS available.  See the online help for more information about
+this kernel.
+	Using the '-fg' and '-bg' flags will allow you to specify foreground
+and background colors to be used for the plot as a whole.  Note that these
+flags require three arguments to specify the RGB color components.  The '-t'
+flag may be used to mark the background color as 'transparent' so only the
+foreground color is shown when the image is used in an HTML document.
+
+3.3 Generating Other Image Formats
+----------------------------------
+
+	GIF may be used as an intermediate format which can be converted to
+something else as part of the graphcap DD string.  For example, to use the
+ImageMagick CONVERT task to produce a JPEG image the graphcap DD string
+could be written as
+
+	g-jpeg|UNIX generic interface to JPEG file generator:\
+	    :DD=ugif,tmp$sgk,!{ sgidispatch sgi2gif -w $(PX) -h $(PY) \
+	    -bg 0 0 0 -fg 255 255 255 -root sgi $F | \
+	    convert sgi$$.gif sgi$$.jpg ; rm $F; }&: \
+	    :MF#1:NF:tc=sgi_image_format:
+
+The DD string first uses the SGI2GIF translator to produce a 'sgi.gif'
+image, then calls the convert task (which is assumed to be in the user's
+path) to convert this to JPEG as a separate step.   The :MF field is
+set to one meaning each frame will generate a new file.  The '$$' used in
+the filenames (e.g. 'sgi$$.gif') is the process id created for the shell
+running the DD command meaning multiple filenames of the form 'sgi12345.gif'
+will be created, each with a unique id number so the images aren't over-
+written.  In the past this form of DD string could be used with the standard
+sgi2uapl postscript translator and a host task such as 'gs' to convert 
+postscript to some other format.
+
+4. Interfacing to Web CGI Scripts
+----------------------------------
+
+	It would be impossible to give complete details about interfacing
+IRAF programs to CGI scripts due to the variety of languages and tasks
+that may be used.   To begin lets look at how to execute a task from the
+host level, which is essentially what we'll be doing from within a CGI 
+script.
+	In principle this can be done in one of two ways:  Either invoke
+the executable directly with the correct command line arguments, or run
+the CL with the input redirected to execute the task.  In the first case
+you must know in which executable the task resides, core IRAF system tasks
+(e.g.  things in the PLOT and IMAGES packages) have their executables in
+the main $iraf/bin.<arch> directory, NOAO package tasks have the
+executables in the $iraf/noao/bin.<arch> directory.  There is usually a
+separate executable for each package and you can probably figure out which
+one goes for each package otherwise just look at the package cl file to
+find out, for example the PLOT package defines the task in the
+$iraf/pkg/plot/plot.cl file, if you look in their you'll see that is
+defines the tasks as (part of the file reads)
+
+task    contour,
+	surface, hafton, velvect         = "plot$x_ncar.e"
+
+which means that the CONTOUR, SURFACE, etc tasks are in the "x_ncar.e"
+executable.
+	Once you find the correct binary, you need to create a file with
+the task parameters:  usually it's easiest to set the parameters and then
+dump the parameter file with 'dpar', e.g.
+
+	cl> dpar listpix > listpix.par
+
+It's likely that CGI scripts will need to set certain parameters itself so
+thought must be given to how to edit this list of default parameters with
+values given in the CGI script.
+
+To run the task you would then do something like:
+
+	% $iraf/bin.sparc/x_images.e listpix @listpix.par
+
+In this case you must be careful that ALL of the task parameters are
+defined, this is done by 'dpar' but empty string parameters will always
+be prompted for.  On a host command line simply respond to the parameter
+prompts by hitting the return key, from with a CGI script these must
+be supplied automatically in some way (e.g. via redirection).
+	In the second case you create a command file and input it to the
+cl, for example
+
+	% cl < cl.input >& some_logfile
+
+where cl.input contains CL commands such as
+
+	wfits.scale=no               # set a parameter wfits image*.imh
+	mta            		     # call a task 
+	logout                       # logout of the CL
+
+You must be careful about making sure you are in the right directory and
+that parameters are given explicitly if they're like to change, but with
+this approach you can call any iraf task.
+
+4.1  Graphics Tasks
+-------------------
+
+	Regardless of the method chosen, you need to be careful about
+redirecting any required input or text/graphics output.  Graphics output
+can be redirected either by setting the "device" parameter to e.g. 'vdm'
+to create a file called 'vdm' in the uparm directory, or using the '>G' CL
+syntax as in
+
+	cl> surface dev$pix >G surf.plot     # redirect metacode to a file
+	cl> surface dev$pix dev="vdm"        # save metacode to uparm dir
+	cl> surface dev$pix dev="stdplot"    # to print it out 
+	cl> gflush			     # flush graphics buffer
+
+Which of these approaches works best for depends depends on the tasks you
+need and the method of execution chosen above.  Note that the ">G" syntax
+will only work for tasks executed within the CL, setting a device
+parameter to something that creates a file will work with either method.
+	For non-interactive tasks like SURFACE or CONTOUR this file is
+created automatically, interactive tasks however may need to create
+metacode files explicitly or else the CGI script must take care to extract
+only those plots of interest from the metacode file (e.g. with a separate
+call to GKIEXTRACT).
+	Interactive tasks must also satisfy requests for cursor commands,
+including the usual 'q' keystroke needed to exit the task.  Since cursor
+commands are in reality queries to the CL any binary run as a host task
+will generate a cursor prompt on the standard output the same as for any
+other parameter query.  The response to a cursor query however is usually
+of the form
+		x y wcs key strval
+
+where 'x' and 'y' are the cursor position, 'wcs' is the WCS of those coords
+(usually not important), 'key' is the keystroke you would normally enter,
+and if 'key' is a color the 'strval' is the remainder of that color command.
+See section 3.7 of the "help cursors" help page for more details on alternate
+graphics input.  Note however, that your CGI script must know in advance the
+order in which the prompts will occur to be able to satisfy them correctly,
+e.g. any parameter prompts generated by empty string values should be met
+with a newline, and cursor prompts with something as above.  Since the tasks
+will be very narrowly defined as to how they are run this usually isn't
+difficult to set up.
+
+4.2 Example
+-----------
+
+	As an example let create a CGI script to execute the PCOL task
+from a web interface.  All that we need to do this is the PLOT package
+binary to execute the task, a 'graphcap' file, and the SGIKERN binary in
+order to convert our graphics metacode to a GIF format using the specified
+graphcap entries and the newly installed SGI2GIF translator.  In the
+following we detail the steps involved in creating this script on a system
+with IRAF installed, your application may vary somewhat.   We use a
+C-shell script here but the same principles apply to all scripting
+languages, users should contact site support with questions.
+
+-----------------------------------------------------------------------------
+
+#!/bin/csh -f
+#
+# Sample CGI script demonstrating the using the PCOL graphics task to 
+# produce an 'sgigif.gif' file of the resulting plot which can be shown
+# as an image of the output web page.  The script does not show how to
+# parse arguments or format the resulting HTML page.  All that is required
+# for IRAF execution is the binary for the task to be run, the SGIKERN
+# binary, and a graphcap file to produce the GIF (given below).  The CGI
+# script can define the task parameters itself or use a predefined 'dpar'
+# dump to set defaults as we do below.
+
+# The REMOTE_ADDR variable is defined in the environment of the CGI
+# script automatically, we specify it here for demonstration purposes.
+set REMOTE_ADDR  = 140.252.30.95
+
+# This would be defined as the graphcap file installed for the local web
+# server.
+
+# The only graphcap entries needed to output graphics to a GIF file using
+# the SGI translator is as follows:
+#
+#     vdm|stdvdm|Virtual Device Metafile:\
+#         :co#80:li#35:xr#1024:yr#1024:zr#256:ar#.77:ch#.0294:cw#.0125:\
+#         :X1#0:X2#1023:Y1#0:Y2#1023:
+# 
+#     g-gif|UNIX generic interface to multi-frame GIF file generator:\
+#         :DD=ugif,tmp$sgk,!{ /<path>/sgi2gif.e -w $(PX) -h $(PY) \
+#         -bg 0 0 0 -fg 255 255 255 -root sgigif $F.[1-8] ; \
+#         rm $F.[1-8]; }&:MF#8:NF:tc=sgi_image_format:
+# 
+#     sgi_image_format|Generic raster file format specification:\
+#         :kf=bin$x_sgikern.e:tn=sgikern:ar#.75:\
+#         :xr#640:yr#480:PX#640:PY#480:XW#640:YW#480:\
+#         :BI:MF#1:YF:NB#8:LO#1:LS#0:XO#0:YO#0:
+#
+# Note that the path to the sgigif.e binary is specified explicitly, this
+# must be replaced by the path to the actual binary.
+#
+# On the web server this file would normally be installed in the cgi-bin
+# or some other directory, the cgi script itself needs to define this location
+# with the following variable:
+
+set graphcap    = /tmp/graphcap
+
+# A uparm directory needs to be defined for saving the VDM file.  This is
+# defined based on the REMOTE_ADDR so we can have multiple connections 
+# running at the same time without concurrency problems.
+
+set uparm       = /tmp/uparm-$REMOTE_ADDR/
+
+# Create the uparm directory we'll be using...
+mkdir $uparm
+
+# Execute the graphics task desired.  In this example we're running the PCOL
+# task and assume we've saved the parameters to a 'pcol.dpar' file in the
+# current directory.  In practice the parameters can be specified using a
+# dpar file in the cgi-bin dir or explicitly on the command line.  To execute
+# the task we call the binary directly, direct output to /dev/null and
+# redirect input blank lines to respond to params that take no value.  We
+# must set the uparm and graphcap values set above to handle the graphics.
+# The CGI script can insert values such as 'image' based on arguments, the
+# defaults come from a predefined dpar file. 
+
+/iraf/iraf/bin.ssun/x_plot.e >>& /dev/null << EOF
+set uparm = $uparm
+set graphcap = $graphcap
+pcol @pcol.dpar pcol.device="vdm"
+
+EOF
+
+# At this point the GKI metacode is saved in the uparm$vdm file, where
+# 'uparm' is set above and is created by the custom graphcap file we're
+# using.  To convert GKI metacode to the final GIF file we call the SGIKERN
+# directly and specify the device as 'g-gif' which produces an 'sgigif.gif'
+# file in the current directory.  Graphcap entries can be created to name
+# the file anything desired, that filename is then used as a URL for the
+# web page returned.
+
+/iraf/iraf/bin.ssun/x_sgikern.e >>& /dev/null << EOF
+set uparm = $uparm
+set graphcap = $graphcap
+sgikern input=uparm\$vdm device=g-gif generic=yes
+EOF
+
+# Finally, clean up the temp files we've created.
+/bin/rm -rf $uparm
+
diff --git a/unix/gdev/sgidev/mkpkg b/unix/gdev/sgidev/mkpkg
new file mode 100644
index 00000000..e9dac3df
--- /dev/null
+++ b/unix/gdev/sgidev/mkpkg
@@ -0,0 +1,9 @@
+# Make the SGI device host level translation programs [MACHDEP].
+
+$call	update
+$exit
+
+update:
+	! sh -x mkpkg.sh
+	! mv $hlib/sgi*.e $hbin
+	;
diff --git a/unix/gdev/sgidev/mkpkg.sh b/unix/gdev/sgidev/mkpkg.sh
new file mode 100644
index 00000000..85d6c83a
--- /dev/null
+++ b/unix/gdev/sgidev/mkpkg.sh
@@ -0,0 +1,60 @@
+# Make the SGI translators and install them in hlib.
+
+$CC -c $HSI_CF	sgiUtil.c
+
+$CC -c $HSI_CF	sgidispatch.c
+$CC $HSI_LF	sgidispatch.o ../../hlib/libos.a $HSI_LIBS -o sgidispatch.e
+mv -f		sgidispatch.e ../../hlib
+rm		sgidispatch.o
+
+$CC -c $HSI_CF	sgi2uimp.c
+$CC $HSI_LF	sgi2uimp.o sgiUtil.o $HSI_LIBS -o sgi2uimp.e
+mv -f		sgi2uimp.e ../../hlib
+rm		sgi2uimp.o
+
+$CC -c $HSI_CF	sgi2uapl.c
+$CC $HSI_LF	sgi2uapl.o sgiUtil.o $HSI_LIBS -o sgi2uapl.e
+mv -f		sgi2uapl.e ../../hlib
+rm		sgi2uapl.o
+
+$CC -c $HSI_CF	sgi2uqms.c
+$CC $HSI_LF	sgi2uqms.o sgiUtil.o $HSI_LIBS -o sgi2uqms.e
+mv -f		sgi2uqms.e ../../hlib
+rm		sgi2uqms.o
+
+$CC -c $HSI_CF	sgi2uptx.c
+$CC $HSI_LF	sgi2uptx.o sgiUtil.o $HSI_LIBS -o sgi2uptx.e
+mv -f		sgi2uptx.e ../../hlib
+rm		sgi2uptx.o
+
+$CC -c $HSI_CF	sgi2uhplj.c
+$CC $HSI_LF	sgi2uhplj.o sgiUtil.o $HSI_LIBS -o sgi2uhplj.e
+mv -f		sgi2uhplj.e ../../hlib
+rm		sgi2uhplj.o
+
+$CC -c $HSI_CF	sgi2uhpgl.c
+$CC $HSI_LF	sgi2uhpgl.o sgiUtil.o $HSI_LIBS -o sgi2uhpgl.e
+mv -f		sgi2uhpgl.e ../../hlib
+rm		sgi2uhpgl.o
+
+$CC -c $HSI_CF	sgi2ueps.c
+$CC $HSI_LF	sgi2ueps.o sgiUtil.o $HSI_LIBS -o sgi2ueps.e
+mv -f		sgi2ueps.e ../../hlib
+rm		sgi2ueps.o
+
+$CC -c $HSI_CF	sgi2gif.c
+$CC $HSI_LF	sgi2gif.o sgiUtil.o $HSI_LIBS -o sgi2gif.e
+mv -f		sgi2gif.e ../../hlib
+rm		sgi2gif.o
+
+$CC -c $HSI_CF	sgi2xbm.c
+$CC $HSI_LF	sgi2xbm.o sgiUtil.o $HSI_LIBS -o sgi2xbm.e
+mv -f		sgi2xbm.e ../../hlib
+rm		sgi2xbm.o
+
+$CC -c $HSI_CF	sgi2svg.c
+$CC $HSI_LF	sgi2svg.o sgiUtil.o $HSI_LIBS -o sgi2svg.e
+mv -f		sgi2svg.e ../../hlib
+rm		sgi2svg.o
+
+rm		sgiUtil.o
diff --git a/unix/gdev/sgidev/sgi2gif.c b/unix/gdev/sgidev/sgi2gif.c
new file mode 100644
index 00000000..e46d4d28
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2gif.c
@@ -0,0 +1,731 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ *  SGI2GIF.C -- Read an IRAF SGI bitmap file on standard input and convert
+ *  to a GIF format image on standard outout.
+ *
+ *  Usage:
+ *		sgi2gif.e [-params] [ [sgi_bitmap] [sgi_bitmap] ... ]
+ *
+ *	-w N	     width of input bitmap and output image
+ *	-h N	     height of input bitmap and output image
+ *	-i	     invert the bitmap values before conversion
+ *	-t	     set background color as transparent
+ *	-root	     set the root rame for output file (default stdout)
+ *	-fg R G B    specify foreground color
+ *	-bg R G B    specify background color
+ *
+ *  The input file name and the switches may occur in any order.  The
+ *  foreground/background flags require three arguments giving the values
+ *  of the RGB components of the color as a decimal number in the range 0-255.
+ *  Enabling the transparency flag will cause a GIF 89 image to be written,
+ *  otherwise the default will be a GIF 87 format image.  The transparent
+ *  color will always be the backgrund color.  The bitmap may be inverted
+ *  here using the -i flag.
+ *
+ *  Sample graphcaps for this translator might look like:
+ *
+ *      g-gif|UNIX generic interface to multi-frame GIF file generator:\
+ *          :DD=ugif,tmp$sgk,!{ sgidispatch sgi2gif -w $(PX) -h $(PY) \
+ *          -bg 0 0 0 -fg 255 255 255 -root sgigif $F.[1-8] ; \
+ *          rm $F.[1-8]; }&:MF#8:NF:tc=sgi_image_format:
+ *
+ *      sgi_image_format|Generic raster file format specification:\
+ *          :kf=bin$x_sgikern.e:tn=sgikern:ar#.75:\
+ *          :xr#640:yr#480:PX#640:PY#480:XW#640:YW#480:\
+ *          :BI:MF#1:YF:NB#8:LO#1:LS#0:XO#0:YO#0:
+ *
+ *  The 'g-gif' entry takes one or more graphics file input and converts
+ *  each input frame to a redirected file on output called 'sgigifXXX.gif'
+ *  where the 'XXX' is frame number.
+ *
+ *  To change the image size the graphcap :xr, :PX, :XW (X-dimension) and
+ *  :yr, :PY, :XY (Y-dimension) fields all need to be changed.  The -i 
+ *  or -t flags must be specified in the graphcap DD string along with the
+ *  -fg/bg flags and their arguments.
+ */
+
+
+#define	NBITS_CHAR	8		/* number of bits in a char 	*/
+#define DEF_WIDTH	640		/* default image width		*/
+#define DEF_HEIGHT	480		/* default image height		*/
+#define DEF_BG		255		/* default background RGB	*/
+#define DEF_FG		0		/* default foreground RGB	*/
+#define	MAX_INFILES	16		/* max number of input bitmaps	*/
+#define	SZ_FNAME	64		/* size of a filename		*/
+
+typedef int	    	code_int;
+typedef long int	count_int;
+typedef unsigned char	byte;
+
+static byte	*pixels;
+
+static int px = DEF_WIDTH;
+static int py = DEF_HEIGHT;
+static int nrows = DEF_HEIGHT;
+static int ncols = DEF_WIDTH;
+static int transparent = 0;
+static int invert = 0;
+static int red[]   = { DEF_BG, DEF_FG } ;
+static int green[] = { DEF_BG, DEF_FG } ;
+static int blue[]  = { DEF_BG, DEF_FG } ;
+static char *infile[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+static char *s_root = "sgigif_";
+
+static int	GIFNextPixel();
+static void 	BumpPixel(), GIFEncode(), Putword(), compress();
+static void 	output(), cl_block(), cl_hash(), char_init();
+static void 	char_out(), flush_char(), unpack1to8();
+
+
+
+/* MAIN -- Main entry point for the task.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*fdi, *fdo;
+	char	fname[SZ_FNAME];
+	char	*root = s_root;
+	byte	*buffer, *ip;
+	int	i, index, numin=0, len_buf;
+	int	interlace, background, bpp;
+
+
+        /* Process the command line.
+         */
+        for (i=1;  i < argc;  i++) {
+            if (argv[i][0] == '-') {
+		if (strcmp (argv[i], "-w") == 0) {
+		    ncols = px = atoi (argv[++i]);
+		} else if (strcmp (argv[i], "-h") == 0) {
+		    nrows = py = atoi (argv[++i]);
+		} else if (strcmp (argv[i], "-i") == 0) {
+		    invert++;
+		} else if (strcmp (argv[i], "-root") == 0) {
+		    root = argv[++i];
+		} else if (strcmp (argv[i], "-t") == 0) {
+		    transparent++;
+		} else if (strcmp (argv[i], "-bg") == 0) {
+		    if (isdigit(argv[++i][0]))
+		        red[0]   = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		    if (isdigit(argv[++i][0]))
+		        green[0] = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		    if (isdigit(argv[++i][0]))
+		        blue[0]  = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		} else if (strcmp (argv[i], "-fg") == 0) {
+		    if (isdigit(argv[++i][0]))
+		        red[1]   = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		    if (isdigit(argv[++i][0]))
+		        green[1] = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		    if (isdigit(argv[++i][0]))
+		        blue[1]  = atoi (argv[i]);
+		    else
+		        fprintf (stderr,
+			    "sgi2gif: invalid -bg arg '%s'\n", argv[i]);
+		} else {
+		    fprintf (stderr, "sgi2gif: unknown switch '%s'\n", argv[i]);
+		}
+	    } else {
+		/* input sgi-bitmap file specification */
+		if (numin < MAX_INFILES)
+                    infile[numin++] = argv[i];     
+	    }
+	}
+
+	/* Allocate space for the images. */
+	len_buf = px / NBITS_CHAR;
+	buffer = (byte *) malloc (len_buf);
+	ip = pixels = (byte *) malloc (px * (py + 1));
+
+	/* Loop over the input bitmaps, writing the converted output to
+	 * either stdout or a filename.
+	 */
+	for (index = 0; index == 0 || index < numin; index++) {
+
+	    /* Open the input file. */
+            fdi = (infile[index] ? fopen (infile[index], "r") : stdin);
+
+	    /* Open the output file.  For multiple input files force each
+	     * output to a new image, when reading from stdin or only one
+	     * bitmap write to stdout if we didn't set the rootname.
+	     */
+	    if (numin <= 1 && strcmp (root, s_root) == 0) {
+		fdo = stdout;
+	    } else {
+		if (numin > 1)
+		    sprintf (fname, "%s%d.gif", root, index);
+		else
+		    sprintf (fname, "%s.gif", root);
+		fdo = fopen (fname, "w+");
+	    }
+
+	    /* Now unpack this bitmap to the output image as byte data. */
+	    ip = pixels;
+	    while (fread (buffer, len_buf, 1, fdi)) {
+	        /* If we're on a MSB ordered machine wordswap the bitmap so
+		 * it's in the correct order for unpacking to be interpreted
+		 * as an LSB-ordered image.
+	         */
+	        if ( ! isSwapped ())
+		    bswap4 (buffer, buffer, len_buf);
+
+	        unpack1to8 ((ip+=px), buffer, px);
+	    }
+
+	    /* All set, write it out. */
+	    GIFEncode (fdo, px, py, (interlace=0), (background=0), (bpp=1),
+		red, green, blue);
+
+	    fflush (fdi);
+	    fflush (fdo);
+	    if (fdi != stdin)
+	        fclose (fdi);
+	    if (fdo != stdout)
+	        fclose (fdo);
+	}
+
+	/* Clean up. */
+	free (buffer);
+	free (pixels);
+
+	return (0);
+}
+
+
+/* UNPACK1TO8 -- Unpack each bit in the bitmap to a byte on output.
+ */
+
+static void
+unpack1to8 (byte *dest, byte *src, int len)
+{
+        register int i, b;
+        byte 	c = 0;
+
+        for (i = 0, b = 0; i < len; i++) {
+            if (b > 7) {
+                b = 0;
+                c = (invert ? ~(*src++) : (*src++) );
+            }
+            *dest++ = (byte) ((c >> (b++)) & 1);
+        }
+}
+
+
+/* GIF Writing Procedures.
+ *
+ * Based on GIFENCOD by David Rowley <mgardi@watdscu.waterloo.edu>.  A
+ * Lempel-Zim compression based on "compress". Original Copyright 1990, 
+ * David Koblas, heavily modified since then....
+ */
+
+#define	GIFBITS			12
+
+static int	Width, Height;
+static int	curx, cury;
+static long	CountDown;
+static int	Interlace;
+
+
+/* GIFENCODE -- GIF Image compression interface.
+ */
+
+static void
+GIFEncode (fp, GWidth, GHeight, GInterlace, Background, Bpp, Red, Green, Blue)
+FILE	*fp;
+int	GWidth, GHeight;
+int	GInterlace;
+int	Background;
+int	Bpp;
+int	Red[], Green[], Blue[];
+{
+	int	B;
+	int	RWidth, RHeight;
+	int	LeftOfs, TopOfs;
+	int	Resolution;
+	int	ColorMapSize;
+	int	InitCodeSize;
+	int	i;
+
+	Interlace = GInterlace;
+
+	ColorMapSize = 1 << Bpp;
+
+	RWidth = Width = GWidth;
+	RHeight = Height = GHeight;
+	LeftOfs = TopOfs = 0;
+
+	Resolution = Bpp;
+
+	/* Calculate number of bits we are expecting */
+	CountDown = (long)Width * (long)Height;
+
+	/* The initial code size */
+	if (Bpp <= 1)
+	    InitCodeSize = 2;
+	else
+	    InitCodeSize = Bpp;
+
+	/* Set up the current x and y position */
+	curx = cury = 0;
+
+	/* Write the Magic header */
+	fwrite ((transparent ? "GIF89a" : "GIF87a"), 1, 6, fp);
+
+	/* Write out the screen width and height */
+	Putword (RWidth, fp);
+	Putword (RHeight, fp);
+
+	/* Indicate that there is a global colour map */
+	B = 0x80;       /* Yes, there is a color map */
+
+	/* OR in the resolution */
+	B |= (Resolution - 1) << 5;
+
+	/* OR in the Bits per Pixel */
+	B |= (Bpp - 1);
+
+	/* Write it out */
+	fputc (B, fp);
+
+	/* Write out the Background colour */
+	fputc (Background, fp);
+
+	/* Byte of 0's (future expansion) */
+	fputc (0, fp);
+
+	/* Write out the Global Colour Map */
+	for  (i = 0; i < ColorMapSize; ++i) {
+	    fputc (Red[i], fp);
+	    fputc (Green[i], fp);
+	    fputc (Blue[i], fp);
+	}
+
+	/* If doing transparency, write the extension. */
+	if (transparent) {
+            fputc (0x21, fp);		/* graphics extension... */
+            fputc (0xf9, fp);		/* transparency... */
+            fputc (0x4, fp);
+            fputc (0x1, fp);
+            fputc (0x0, fp);
+            fputc (0x0, fp);
+            fputc ((char) 0, fp);	/* background color index */
+            fputc (0x0, fp);
+	}
+
+	/* Write an Image separator */
+	fputc (',', fp);
+
+	/* Write the Image header */
+	Putword (LeftOfs, fp);
+	Putword (TopOfs, fp);
+	Putword (Width, fp);
+	Putword (Height, fp);
+
+	/* Write out whether or not the image is interlaced */
+	if (Interlace)
+	    fputc (0x40, fp);
+	else
+	    fputc (0x00, fp);
+
+	/* Write out the initial code size */
+	fputc (InitCodeSize, fp);
+
+	/* Go and actually compress the data */
+	compress (InitCodeSize + 1, fp);
+
+	/* Write out a Zero-length packet (to end the series) */
+	fputc (0, fp);
+
+	/* Write the GIF file terminator */
+	fputc (';', fp);
+}
+
+
+/* Bump the 'curx' and 'cury' to point to the next pixel
+ */
+static void
+BumpPixel()
+{
+	/* Bump the current X position */
+	++curx;
+
+	/* If at the end of a scan line, set curx back to the beginning. */
+	if (curx == Width) {
+	    curx = 0;
+	    ++cury;
+	}
+}
+
+
+/* Return the next pixel from the image
+ */
+static int	
+GIFNextPixel ()
+{
+	int	r;
+
+	if (CountDown == 0)
+	    return EOF;
+
+	--CountDown;
+	r = (int) pixels[ cury * ncols + curx ] ;
+	BumpPixel();
+	return r;
+}
+
+
+/* Write out a word to the GIF file
+ */
+static void
+Putword (w, fp)
+int	w;
+FILE*fp;
+{
+	unsigned short	val = w;
+
+	fputc (val & 0xff, fp);
+	fputc ((val / 256) & 0xff, fp);
+}
+
+
+/*
+ * GIF Image compression - modified 'compress'
+ *
+ * Based on: compress.c - File compression ala IEEE Computer, June 1984.
+ *
+ * By Authors:   Spencer W. Thomas, Jim McKie, Steve Davies, Ken Turkowski,
+ *		 James A. Woods, Joe Orost
+ *
+ *  Lempel-Ziv compression based on 'compress'.  GIF modifications by
+ *  David Rowley (mgardi@watdcsu.waterloo.edu)
+ */
+
+#define HSIZE  	   5003            		/* 80% occupancy */
+
+static int	n_bits;                    /* number of bits/code */
+static int	maxbits = GIFBITS;         /* user settable max # bits/code */
+static code_int maxcode;                   /* maximum code, given n_bits */
+					   /* should NEVER generate this code */
+static code_int maxmaxcode = (code_int) 1 << GIFBITS; 
+#define MAXCODE(n_bits)        (((code_int) 1 << (n_bits)) - 1)
+
+static count_int 	htab[HSIZE];
+static unsigned short	codetab [HSIZE];
+#define HashTabOf(i)    htab[i]
+#define CodeTabOf(i)    codetab[i]
+
+/* To save much memory, we overlay the table used by compress() with those
+ * used by decompress().  The tab_prefix table is the same size and type
+ * as the codetab.  The tab_suffix table needs 2**GIFBITS characters.  We
+ * get this from the beginning of htab.  The output stack uses the rest
+ * of htab, and contains characters.  There is plenty of room for any
+ * possible stack (stack used to be 8000 characters).
+ */
+
+#define tab_prefixof(i)    CodeTabOf(i)
+#define tab_suffixof(i)    ((unsigned char *)(htab))[i]
+
+static code_int free_ent = 0;           /* first unused entry 		*/
+static code_int hsize = HSIZE;          /* for dynamic table sizing 	*/
+
+
+/* block compression parameters -- after all codes are used up,
+ * and compression rate changes, start over.
+ */
+static int	clear_flg = 0;
+
+/*
+ * compress stdin to stdout
+ *
+ * Algorithm:  use open addressing double hashing (no chaining) on the
+ * prefix code / next character combination.  We do a variant of Knuth's
+ * algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+ * secondary probe.  Here, the modular division first probe is gives way
+ * to a faster exclusive-or manipulation.  Also do block compression with
+ * an adaptive reset, whereby the code table is cleared when the compression
+ * ratio decreases, but after the table fills.  The variable-length output
+ * codes are re-sized at this point, and a special CLEAR code is generated
+ * for the decompressor.  Late addition:  construct the table according to
+ * file size for noticeable speed improvement on small files.  Please direct
+ * questions about this implementation to ames!jaw.
+ */
+
+static FILE	*g_outfile;
+static int	g_init_bits;
+static int	ClearCode;
+static int	EOFCode;
+static int	cur_bits = 0;
+
+static unsigned long	cur_accum = 0;
+static unsigned long	masks[] = { 
+	    			0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
+	    			0x001F, 0x003F, 0x007F, 0x00FF,
+	    			0x01FF, 0x03FF, 0x07FF, 0x0FFF,
+	    			0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF 	};
+
+static int a_count; 	    /* Number of characters so far in this 'packet'  */
+static char accum[256];     /* Define the storage for the packet accumulator */
+
+static void
+compress (init_bits, outfile)
+int	init_bits;
+FILE	*outfile;
+{
+	register long	fcode;
+	register code_int i /* = 0 */;
+	register int	c;
+	register code_int ent;
+	register code_int disp;
+	register code_int hsize_reg;
+	register int	hshift;
+
+	/* Set up the globals:  g_init_bits - initial number of bits
+         *                      g_outfile   - pointer to output file
+         */
+	g_init_bits = init_bits;
+	g_outfile = outfile;
+
+	/* Set up the necessary values */
+	clear_flg = 0;
+	cur_accum = 0;
+	cur_bits = 0;
+	maxbits = GIFBITS;
+	maxcode = MAXCODE(n_bits = g_init_bits);
+
+	ClearCode = (1 << (init_bits - 1));
+	EOFCode = ClearCode + 1;
+	free_ent = ClearCode + 2;
+
+	char_init();
+	for (i=0; i<HSIZE; i++) {
+	    htab[i] = 0;
+	    codetab[i] = 0;
+	}
+
+	ent = GIFNextPixel ();
+
+	hshift = 0;
+	for  (fcode = (long) hsize; fcode < 65536L; fcode *= 2L)
+	    ++hshift;
+	hshift = 8 - hshift;                /* set hash code range bound */
+
+	hsize_reg = hsize;
+	cl_hash ((count_int) hsize_reg);            /* clear hash table */
+
+	output ((code_int)ClearCode);
+
+	while  ((c = GIFNextPixel ()) != EOF) {
+
+	    fcode = (long) (((long) c << maxbits) + ent);
+	    i = (((code_int)c << hshift) ^ ent);    /* xor hashing */
+
+	    if (HashTabOf (i) == fcode) {
+	    	ent = CodeTabOf (i);
+	    	continue;
+	    } else if ((long)HashTabOf (i) < 0)      /* empty slot */
+	    	goto nomatch;
+	    disp = hsize_reg - i;         /* secondary hash (after G. Knott) */
+	    if (i == 0)
+	    	disp = 1;
+probe:
+	    if ((i -= disp) < 0)
+	    	i += hsize_reg;
+
+	    if (HashTabOf (i) == fcode) {
+	    	ent = CodeTabOf (i);
+	    	continue;
+	    }
+	    if ((long)HashTabOf (i) > 0)
+	    	goto probe;
+nomatch:
+	    output  ((code_int) ent);
+	    ent = c;
+	    if (free_ent < maxmaxcode) {	/* } */
+	        CodeTabOf (i) = free_ent++; /* code -> hashtable */
+	        HashTabOf (i) = fcode;
+	    } else
+	        cl_block();
+	}
+
+	/*
+	 * Put out the final code.
+	 */
+	output ((code_int)ent);
+	output ((code_int) EOFCode);
+}
+
+/*
+ * Output the given code.
+ * Inputs:
+ *      code:   A n_bits-bit integer.  If == -1, then EOF.  This assumes
+ *              that n_bits =< (long)wordsize - 1.
+ * Outputs:
+ *      Outputs code to the file.
+ * Assumptions:
+ *      Chars are 8 bits long.
+ * Algorithm:
+ *      Maintain a GIFBITS character long buffer (so that 8 codes will
+ * fit in it exactly).  Use the VAX insv instruction to insert each
+ * code in turn.  When the buffer fills up empty it and start over.
+ */
+
+static void
+output (code)
+code_int  code;
+{
+	cur_accum &= masks[ cur_bits ];
+
+	if (cur_bits > 0)
+	    cur_accum |= ((long)code << cur_bits);
+	else
+	    cur_accum = code;
+
+	cur_bits += n_bits;
+
+	while  (cur_bits >= 8) {
+	    char_out ((unsigned int)(cur_accum & 0xff));
+	    cur_accum >>= 8;
+	    cur_bits -= 8;
+	}
+
+   	/*
+         * If the next entry is going to be too big for the code size,
+         * then increase it, if possible.
+         */
+	if (free_ent > maxcode || clear_flg) {
+
+	    if (clear_flg) {
+	    	maxcode = MAXCODE (n_bits = g_init_bits);
+	    	clear_flg = 0;
+	    } else {
+	        ++n_bits;
+	        if (n_bits == maxbits)
+	    	    maxcode = maxmaxcode;
+	        else
+	    	    maxcode = MAXCODE(n_bits);
+	    }
+	}
+
+	if (code == EOFCode) {
+	    /* At EOF, write the rest of the buffer.  */
+	    while  (cur_bits > 0) {
+	        char_out ((unsigned int)(cur_accum & 0xff));
+	        cur_accum >>= 8;
+	        cur_bits -= 8;
+	    }
+	    flush_char();
+	    fflush (g_outfile);
+	    if (ferror (g_outfile))
+		perror ("error writing output file");
+	}
+}
+
+/*
+ * Clear out the hash table
+ */
+static void
+cl_block ()             /* table clear for block compress */
+{
+
+	cl_hash  ((count_int) hsize);
+	free_ent = ClearCode + 2;
+	clear_flg = 1;
+
+	output ((code_int)ClearCode);
+}
+
+static void
+cl_hash(hsize)          /* reset code table */
+register count_int hsize;
+{
+
+	register count_int *htab_p = htab + hsize;
+
+	register long	i;
+	register long	m1 = -1;
+
+	i = hsize - 16;
+	do {                            /* might use Sys V memset(3) here */
+	    *(htab_p - 16) = m1;
+	    *(htab_p - 15) = m1;
+	    *(htab_p - 14) = m1;
+	    *(htab_p - 13) = m1;
+	    *(htab_p - 12) = m1;
+	    *(htab_p - 11) = m1;
+	    *(htab_p - 10) = m1;
+	    *(htab_p -  9) = m1;
+	    *(htab_p -  8) = m1;
+	    *(htab_p -  7) = m1;
+	    *(htab_p -  6) = m1;
+	    *(htab_p -  5) = m1;
+	    *(htab_p -  4) = m1;
+	    *(htab_p -  3) = m1;
+	    *(htab_p -  2) = m1;
+	    *(htab_p -  1) = m1;
+	    htab_p -= 16;
+	} while ((i -= 16) >= 0);
+
+	for  (i += 16; i > 0; --i)
+	    *--htab_p = m1;
+}
+
+/* Set up the 'byte output' routine
+ */
+static void
+char_init()
+{
+	register int i;
+
+	a_count = 0;
+	for (i=0; i<256; i++)
+	    accum[i] = 0;
+}
+
+/* Add a character to the end of the current packet, and if it is 254
+ * characters, flush the packet to disk.
+ */
+static void
+char_out (c)
+int	c;
+{
+	accum[ a_count++ ] = c;
+	if (a_count >= 254)
+	    flush_char();
+}
+
+/* Flush the packet to disk, and reset the accumulator */
+static void
+flush_char()
+{
+    	if (a_count > 0) {
+    	    fputc (a_count, g_outfile);
+    	    fwrite (accum, 1, a_count, g_outfile);
+    	    a_count = 0;
+    	}
+}
diff --git a/unix/gdev/sgidev/sgi2svg.c b/unix/gdev/sgidev/sgi2svg.c
new file mode 100644
index 00000000..be25a704
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2svg.c
@@ -0,0 +1,245 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+** SGI2SVG.C -- Read IRAF SGI metacode from standard input, translate into
+** Scalable Vector Graphics (SVG) format.
+**
+** Usage
+**	sgi2svg.e [-params] [sgi_metacode] [| lpr -Papple]
+**
+**      -fg <N>   FG color specified as RGB triplet (e.g. 'F00' is red)
+**      -bg <N>   BG color specified as RGB triplet (e.g. '0F0' is green)
+**      -fill <N> fill color specified as RGB triplet (e.g. '00F' is blue)
+**      -w <N>    width of plot, device pixels starting from l
+**      -h <N>    height of plot, device pixels starting from b
+**      -p <N>    pen width
+**
+**  Option values must be separated from their flags by a space; the input 
+**  file name and the switches may occur in any order.
+**
+**  Sample Graphcap:
+**
+**  g-svg|UNIX generic interface to SVG file generator:\
+**          :DD=usvg,tmp$sgk,!{ sgidispatch sgi2svg -w $(PX) -h $(PY) \
+**          -bg FFF -fg 000 -fill FFF $F > sgi$$.svg ; }&:PX#640:PY#480:\
+**          :kf=bin$x_sgikern.e:tn=sgikern:tc=sgi_apl:
+*/
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define GKI_MAXNDC	32767.		/* SGK units			   */
+
+
+/* Device opcodes and parameters.  
+ */
+#define DEF_LEFT        0               /* origin in device pixels in x    */
+#define DEF_BOTTOM      0               /* origin in device pixels in y    */
+#define DEF_WIDTH       640             /* width in x (240d/i, 11" paper)  */
+#define DEF_HEIGHT      480             /* height in y (240d/i, 8.5" paper)*/
+#define DEF_PENWIDTH    1               /* origin in device pixels in x    */
+
+
+/* Commands to setup SVG environment.
+*/
+static char *svg_prolog[] = {
+    "<?xml version=\"1.0\" standalone=\"no\"?>\n",
+    "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+    "    \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+    NULL
+};
+
+/* Opcode instruction.
+*/
+struct sgi_inst {
+    short	opcode;
+    short	x, y;
+};
+
+
+int	pen_width   = DEF_PENWIDTH;	/* initial line width		*/
+int	width 	    = DEF_WIDTH;	/* margins			*/
+int	height 	    = DEF_HEIGHT;
+char 	*bg 	    = "#FFF";		/* BG/FG colors			*/
+char	*fg 	    = "#000";
+char	*fill 	    = "#FFF";		/* vector fill color		*/
+	
+
+static void translate (FILE *in, FILE *out);
+
+	
+
+/*  MAIN -- Main entry point for SGI2UHPGL.  Optional arguments are device
+**  window parameters and name of input file.
+*/
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile = "stdin", *argp;
+	int	argno;
+        register char **lp;
+
+
+	/* Process the command line.
+	*/
+        for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+            if (argp[0] == '-') {
+                /* A window-control or pen width switch.
+                 */
+                switch (argp[1]) {
+                case 'f':
+		    if (argp[2] == 'g')
+		        fg = argv[++argno];
+		    else
+		        fill = argv[++argno];
+                    break;
+                case 'b':
+		    bg = argv[++argno];
+                    break;
+                case 'w': width     = atoi (argv[++argno]); break;
+                case 'h': height    = atoi (argv[++argno]); break;
+                case 'p': pen_width = atoi (argv[++argno]); break;
+                default:
+                    break;
+                }
+
+            } else {
+                /* Input sgi-metacode file specification.
+                 */
+                infile = argp;
+            }
+        }
+
+
+	/* Open the input file. */
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2svg):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+
+	/*  Output the standard prolog.
+	 */
+        for (lp=svg_prolog;  *lp;  lp++)  	
+            fputs (*lp, stdout);
+
+	fprintf (stdout,"<svg width=\"%dpx\" height=\"%dpx\" version=\"1.1\"\n",
+	    width, height);
+	fprintf (stdout,"    xmlns=\"http://www.w3.org/2000/svg\">");
+	fprintf (stdout,
+    	    "<g id=\"g0\" fill=\"#%s\" stroke=\"#%s\" stroke-width=\"1\">\n",
+	    bg, fg);
+	fprintf (stdout,
+    	    "<rect x=\"1\" y=\"1\" width=\"%d\" height=\"%d\"\n",
+	    width, height);
+	fprintf (stdout,
+    	    "    fill=\"#%s\" stroke=\"#%s\" stroke-width=\"1\"/>\n", fill, bg);
+
+
+
+	/*  Process the metacode.
+	*/
+	translate (in, stdout); 		
+
+
+	/*  Clean up.
+	*/
+	fprintf (stdout, "</g></svg>");		/* output the end of file     */
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into device 
+** instructions and write to stdout.
+*/
+static void
+translate (FILE *in, FILE *out)
+{
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+	int	 n, in_stroke=0, swap_bytes = isSwapped();
+	int 	 x, y, gnum=1;
+
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    fprintf (out, "\n");
+		    break;
+
+		case SGK_MOVE:
+		    x = (int) (((float)sgip->x / GKI_MAXNDC) * width);
+		    y = (int) (((float)sgip->y / GKI_MAXNDC) * height);
+		    y = height - y + 1;
+		    if (in_stroke) 			/* end current stroke */
+			fprintf (out, "\"/>");
+
+		    /* Begin a new output stroke.
+		    */
+		    fprintf (out, "<polyline points=\"%d,%d", x, y);
+		    in_stroke = 1;
+		    break;
+
+		case SGK_DRAW:
+		    x = (int) (((float)sgip->x / GKI_MAXNDC) * width);
+		    y = (int) (((float)sgip->y / GKI_MAXNDC) * height);
+		    y = height - y + 1;
+		    fprintf (out, " %d,%d", x, y);
+		    in_stroke = 1;
+		    break;
+
+		case SGK_SETLW:
+		    /* Set pen width.
+		     */
+		    pen_width = sgip->x + 1;
+		    if (in_stroke) 			/* end current stroke */
+			fprintf (out, "\"/></g>");
+		    fprintf (out, "<g id=\"g%d\" stroke-width=\"%d\">",
+			gnum++, pen_width);
+		    in_stroke = 0;
+		    break;
+
+		default:
+		    fprintf (stderr, "sgi2svg: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	fprintf (out, " \"/></g>\n");
+}
diff --git a/unix/gdev/sgidev/sgi2uapl.c b/unix/gdev/sgidev/sgi2uapl.c
new file mode 100644
index 00000000..3c59d284
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uapl.c
@@ -0,0 +1,545 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <time.h>
+#include <pwd.h>
+
+#ifdef SOLARIS
+#include <sys/systeminfo.h>
+#endif
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UAPL.C -- Read IRAF SGI metacode from standard input, translate into
+ * Postscript for the Apple Laserwriter and write to standard output.
+ *
+ * Usage:
+ *
+ *	sgi2uapl.e [-params] [sgi_metacode] [| lpr -Plw]
+ *
+ *	-4	use 4 byte point encoding scheme (default is 7 byte)
+ *	-t	omit the timestamp/logo normally written to corner of plot
+ *	-l N	left edge; x plot origin in device pixels
+ *	-b N	bottom edge; y plot origin in device pixels
+ *	-w N	width of plot, device pixels starting from l
+ *	-h N	height of plot, device pixels starting from b
+ *	-p O.S	pen width `origin' and `slope'
+ *
+ * Numeric values may be appended directly to their flags or separated by a
+ * space; the input file name and the switches may occur in any order.
+ * Note that you can arrange for the Postscript output to be saved in a file
+ * as well as directed to the printer by calling the translator as
+ *
+ *	sgi2uapl.e [params] | tee -a file | lpr -Plw
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define SGK_MAXNDC	32767		/* SGK units			   */
+
+/* Device opcodes and parameters.  The default edge and width parameters (DEF_) 
+ * are given in Apple Laserwriter pixels, at 300 dots/inch.  Although bypassing
+ * the device-independence of Postscript, this achieves greater efficiency 
+ * both in translator performance and in transmission rate to the plotter.
+ * The device y-origin is at the lower left corner of the page, but we take
+ * care of this with a Postscript coordinate transformation.  Thus the maximum
+ * page `width' is 11*300 pixels, `height' is 8.5*300 pixels.
+ */
+#define DEV_FRAME	"showpage setcoords setjoins\n"		/* newframe   */
+#define DEV_SETLW	"setlinewidth\n"			/* linewidth  */
+
+#define	MAX_POINTS	512	/* maximum points on stack before a STROKE    */
+#define DEF_LEFT	30	/* origin in device pixels in x		      */
+#define DEF_WIDTH	3180	/* width in x (300d/i, 11" paper)	      */
+#define DEF_BOTTOM	60	/* origin in device pixels in y		      */
+#define DEF_HEIGHT	2415	/* height in y (300d/i, 8.5" paper)	      */
+#define	DEF_PENBASE	3	/* base pen width (LW 1->2)	      	      */
+#define DEF_PENSLOPE	4	/* pen width slope (LW 2->4, 3->6 etc.)	      */
+#define SZ_PENCMD	16	/* total no. of chars in penwidth instruction */
+#define	SZ_PENVAL	2	/* no. of chars in penwidth value	      */
+#define	SZ_VCODE	7	/* no. of chars in MOVE or DRAW opcode	      */
+#define	SZ_VECT		17	/* total no. chars in a MOVE or DRAW inst.    */
+#define	SZ_COORD	4	/* no. of chars in device coordinate          */
+#define	XY_MOVE		0
+#define	XY_DRAW		1
+
+struct sgi_inst {
+	short	opcode;
+	short	x;
+	short	y;
+};
+
+/* Commands to setup Postscript environment.
+ */
+static char *ps_init[] = {
+	"%!PS-Adobe-2.0",
+	"/devppi 300 def",
+	"/userppi 72 def",
+	"/pagewidth 8.5 def",
+	"/devpixtouser { userppi mul devppi div } def",
+	"/pagetolandscape 90 def",
+	"/setcoords { pagewidth userppi mul 0 translate",
+	"    pagetolandscape rotate 1 devpixtouser 1 devpixtouser scale } def",
+	"/setjoins { 1 setlinejoin 1 setlinecap } def",
+	"erasepage initgraphics setcoords setjoins",
+	NULL };
+
+/* 7BYTE -- Postscript procedures to move or draw, with the X,Y coordinates
+ * encoded as a 4 byte sequence (7 bytes including the command name and spaces)
+ * following the command name.  This is the fastest encoding, since it
+ * minimizes the Postscript interpreter execution time.
+ *
+ *	bit	76543210
+ * ------------------------------------------
+ *	     0  01XXXXXX	hi 6 X bits
+ *	     1  01XXXXXX	li 6 X bits
+ *	     2  01YYYYYY	hi 6 Y bits
+ *	     3  01YYYYYY	lo 6 Y bits
+ */
+static char *ps_7byte[] = {
+	"/getpoint {",
+	"	currentfile read pop 8#77 and 6 bitshift",
+	"	currentfile read pop 8#77 and or",
+	"	currentfile read pop 8#77 and 6 bitshift",
+	"	currentfile read pop 8#77 and or",
+	"	} def",
+	"/m { getpoint moveto } def",
+	"/d { getpoint lineto } def",
+	NULL };
+
+/* 4BYTE -- Postscript procedure to draw an arbitrary series of vectors,
+ * encoded 4 bytes per point.  This is the most space efficient encoding,
+ * but the runtime may be somewhat longer than for the 7byte encoding,
+ * due to the Postscript interpreter overhead.
+ *
+ * Optional Flag byte:
+ *		>		move instruction
+ *		+		draw instruction
+ *		$		terminate plotting
+ *		other		ignored (e.g., whitespace)
+ *
+ * Point Encoding:
+ *	       bit 76543210
+ *	 ------------------------------------------
+ *		1  01XXXXXX	hi 6 X bits
+ *		2  01XXXXXX	lo 6 X bits
+ *		3  01YYYYYY	hi 6 Y bits
+ *		4  01YYYYYY	lo 6 Y bits
+ *
+ * Data points are encoded 12 bits (0-4095) per X,Y coordinate.  The flag byte
+ * is used as the terminator, to toggle the move/draw state, and to permit
+ * whitespace to be ignored.  A high bit is set in each byte to ensure a
+ * printable character, as control codes would interfere with the operation of
+ * the Postscript interpreter.
+ */
+#define	CH_MOVE		'>'
+#define	CH_DRAW		'+'
+#define	CH_EXITPLOT	'$'
+
+static char *ps_4byte[] = {
+	"/plot { /movepen { moveto } def",
+	"	 { currentfile read not { exit } if",
+	"	   { dup 8#100 ge",
+	"	     { exit }",
+	"	     { dup 8#076 eq",
+	"	       { pop /movepen { moveto } def",
+	"		 currentfile read not { exit } if }",
+	"	       { dup 8#053 eq",
+	"	         { pop /movepen { lineto } def",
+	"		   currentfile read not { exit } if }",
+	"	         { dup 8#044 eq",
+	"		   { exit }",
+	"		   { pop currentfile read not { exit } if }",
+	"		   ifelse }",
+	"		 ifelse }",
+	"	       ifelse }",
+	"	     ifelse",
+	"	   } loop",
+	"	   dup 8#044 eq { pop exit } { 8#77 and 6 bitshift } ifelse",
+	"	   currentfile read pop 8#77 and or",
+	"	   currentfile read pop 8#77 and 6 bitshift",
+	"	   currentfile read pop 8#77 and or",
+	"	   movepen",
+	"	 } loop",
+	"      } def",
+	NULL };
+
+static	int fourbyte = 0;
+static	int penmode = -1;
+static	int omit_logo = 0;
+static	int dev_left;
+static	int dev_bottom;
+static	int dev_width;
+static	int dev_height;
+static	int dev_penbase  = DEF_PENBASE;
+static	int dev_penslope = DEF_PENSLOPE;
+static	int npts = 0;
+
+
+static void  translate (FILE *in, FILE *out);
+static char *make_label (void);
+static void  textout (FILE *out, char *text[]);
+static char *penencode (int val, char *code);
+static void  xy_flush (FILE *out);
+static void  xy_point (FILE *out, register int x, register int y, int flag);
+
+
+
+/* MAIN -- Main entry point for SGI2UAPL.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+	char	*argp;
+	int	argno;
+	int	np;
+	char	penparam[SZ_PENCMD];
+
+
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+	    if (argp[0] == '-') {
+		/* A window-control or pen width switch.
+		 */
+		switch (argp[1]) {
+		case '4':
+		    fourbyte++;
+		    break;
+		case 't':
+		    omit_logo++;
+		    break;
+		case 'l':
+		    dev_left = get_iarg (argp[2], argv, argno, DEF_LEFT);
+		    break;
+		case 'b':
+		    dev_bottom = get_iarg (argp[2], argv, argno, DEF_BOTTOM);
+		    break;
+		case 'w':
+		    dev_width = get_iarg (argp[2], argv, argno, DEF_WIDTH);
+		    break;
+		case 'h':
+		    dev_height = get_iarg (argp[2], argv, argno, DEF_HEIGHT);
+		    break;
+		case 'p':
+		    if (argp[2] == (char) 0)
+			if (argv[argno+1] == NULL) {
+			    fprintf (stderr, "missing arg to switch `%s';",
+				argp);
+			    fprintf (stderr, " reset to %d.%d\n", dev_penbase,
+				dev_penslope);
+			} else
+			    strcpy (penparam, argv[++argno]);
+		    else
+			strcpy (penparam, argv[argno]+2);
+		    
+		    np = sscanf (penparam, "%d . %d", &dev_penbase,
+			&dev_penslope);
+		    if (np == 1) {
+			dev_penslope = dev_penbase;
+		    } else if (np < 1) {
+			dev_penbase = DEF_PENBASE;
+			dev_penslope = DEF_PENSLOPE;
+		    }
+
+		    break;
+		default:
+		    fprintf (stderr, "sgi2uapl: unknown switch '%s'\n", argp);
+		}
+
+	    } else {
+		/* Input sgi-metacode file specification.
+		 */
+		infile = argp;
+	    }
+	}
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2uapl):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the metacode.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into device 
+ * instructions and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+	int	 n, x, y, curpoints = 0, swap_bytes;
+	float	 xscale, yscale;
+
+
+	swap_bytes = isSwapped();
+
+	xscale = (float) dev_width / (float) SGK_MAXNDC;
+	yscale = (float) dev_height / (float) SGK_MAXNDC;
+
+	/* Output device initialization.  */
+	textout (out, ps_init);
+
+	/* Define the Postscript plotting procedures. */
+	if (fourbyte)
+	    textout (out, ps_4byte);
+	else
+	    textout (out, ps_7byte);
+
+	/* Initialize pen width.  */
+	fwrite (penencode (dev_penbase, DEV_SETLW), SZ_PENCMD, 1, out);
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    xy_flush (out);
+		    fprintf (out, DEV_FRAME);
+		    break;
+
+		case SGK_MOVE:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    xy_point (out, x, y, XY_MOVE);
+		    break;
+
+		case SGK_DRAW:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    xy_point (out, x, y, XY_DRAW);
+
+		    /* Limit number of points passed to Postscript between
+		     * 'stroke' commands to draw the buffered points.
+		     */
+		    curpoints = curpoints + 1;
+		    if (curpoints > MAX_POINTS) {
+			xy_flush (out);
+			xy_point (out, x, y, XY_MOVE);
+			curpoints = 0;
+		    }
+		    break;
+
+		case SGK_SETLW: {
+		    /* Set pen width.
+		     */
+		    int x = max (0, sgip->x - 1);
+
+		    xy_flush (out);
+		    curpoints = 0;
+		    fwrite (penencode (
+			max (1, dev_penbase + x * dev_penslope), DEV_SETLW),
+			SZ_PENCMD, 1, out);
+		    }
+		    break;
+		
+		default:
+		    fprintf (stderr, "sgi2uapl: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	xy_flush (out);
+
+	/* Add the NOAO logo and timestamp at the bottom of the page and
+	 * output the page.
+	 */
+	if (!omit_logo) {
+	    fprintf (out, "/Times-Roman findfont 24 scalefont setfont\n");
+
+	    /* fprintf (out, "[-1 0 0 -1 2350 3180] setmatrix\n"); */
+	    fprintf (out, "initmatrix\n");
+	    fprintf (out, "-1 72 mul 300 div 1 72 mul 300 div scale\n");
+	    fprintf (out, "-2409 88 translate\n");
+
+	    fprintf (out, "%d %d moveto\n", 1600, 3150);
+	    fprintf (out, "[1 0 0 -1 0 0] concat\n");
+	    fprintf (out, "(%s) show\n", make_label());
+	}
+
+	fprintf (out, "showpage\n");
+}
+
+
+/* XY_POINT -- Output a move or draw instruction, using either the 4 byte or
+ * 7 byte encoding scheme.
+ */
+static void
+xy_point (
+    FILE *out,			/* output file */
+    register int x, 		/* coords to move to */
+    register int y, 		/* coords to move to */
+    int	flag			/* move or draw? */
+)
+{
+	static char o[] = "m XXXX";
+	register char	*op = o;
+	register int	n;
+
+	if (fourbyte) {
+	    if (npts == 0) {
+		fputs ("plot\n", out);
+		penmode = XY_MOVE;
+	    }
+
+	    if (flag != penmode)
+		*op++ = ((penmode = flag) == XY_MOVE) ? CH_MOVE : CH_DRAW;
+
+	    *op++ = ((n = ((x >> 6) & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = (x & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = ((y >> 6) & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = (y & 077)) == 077) ? n : (0100 | n);
+
+	    fwrite (o, op-o, 1, out);
+	    if (!(++npts % 15))
+		fputc ('\n', out);
+
+	} else {
+	    o[0] = (flag == XY_MOVE) ? 'm' : 'd';
+	    o[2] = ((n = ((x >> 6) & 077)) == 077) ? n : (0100 | n);
+	    o[3] = ((n = (x & 077)) == 077) ? n : (0100 | n);
+	    o[4] = ((n = ((y >> 6) & 077)) == 077) ? n : (0100 | n);
+	    o[5] = ((n = (y & 077)) == 077) ? n : (0100 | n);
+
+	    fwrite (o, 6, 1, out);
+	    if (!(++npts % 10))
+		fputc ('\n', out);
+	    else
+		fputc (' ', out);
+	}
+}
+
+
+/* XY_FLUSH -- Terminate the current drawing sequence, if any, and issue the
+ * stroke command to Postscript to draw the buffered points.
+ */
+static void
+xy_flush (FILE *out)
+{
+	if (npts > 0) {
+	    if (fourbyte)
+		fputs ("$\n", out);
+	    else if (npts % 10)
+		fputc ('\n', out);
+	    fputs ("stroke\n", out);
+	    npts = 0;
+	}
+}
+
+
+/* PENENCODE -- Encode base, slope into a character string formatted for the
+ * device set-pen command.
+ */
+static char *
+penencode (
+    int	  val,			/* device line width 		*/
+    char *code 			/* device set-linewidth command */
+)
+{
+	static char	obuf[SZ_PENCMD+1];
+	register int	digit, n;
+	register char	*op, *ip;
+
+	for (op = &obuf[SZ_PENVAL-1], digit = SZ_PENVAL, n=val;  --digit >= 0;
+	    n = n / 10)
+	    *op-- = n % 10 + '0';
+	obuf[SZ_PENVAL] = ' ';
+	for (op = &obuf[SZ_PENVAL+1], ip = code, n = SZ_PENCMD;  --n >= 0;  )
+	    *op++ = *ip++;
+
+	return (obuf);
+}
+
+
+/* TEXTOUT -- Output lines of text to a file.
+ */
+static void
+textout (
+    FILE  *out,			/* output file */
+    char  *text[] 		/* array of lines of text */
+)
+{
+	register char **lp;
+
+	for (lp=text;  *lp;  lp++) {
+	    fputs (*lp, out);
+	    fputc ('\n', out);
+	}
+}
+
+
+/* MAKE_LABEL -- Generate the label for the output printer page.
+ */
+static char *
+make_label (void)
+{
+	static	char buf[128];
+	char	hostname[32];
+	char	username[32];
+	struct	passwd *pw;
+	time_t	clock;
+
+#ifdef SOLARIS
+	sysinfo (SI_HOSTNAME, hostname, 32);
+#else
+	gethostname (hostname, 32);
+#endif
+
+	clock = time(0);
+	pw = getpwuid (getuid());
+	strcpy (username, pw->pw_name);
+	endpwent();
+
+	sprintf (buf, "NOAO/IRAF  %s@%s  %s",
+	    username, hostname, asctime(localtime(&clock)));
+
+	return (buf);
+}
diff --git a/unix/gdev/sgidev/sgi2ueps.c b/unix/gdev/sgidev/sgi2ueps.c
new file mode 100644
index 00000000..345eb702
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2ueps.c
@@ -0,0 +1,530 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <ctype.h>
+#include <time.h>
+#include <pwd.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UEPS.C -- Read IRAF SGI metacode from standard input, translate into
+ * Encapsulated Postscript and write to standard output.
+ *
+ * Usage:
+ *
+ *	sgi2ueps.e [-params] [sgi_metacode] [| lpr -Plw]
+ *
+ *	-4	use 4 byte point encoding scheme (default is 7 byte)
+ *	-l N	left edge; x plot origin in device pixels
+ *	-b N	bottom edge; y plot origin in device pixels
+ *	-w N	width of plot, device pixels starting from l
+ *	-h N	height of plot, device pixels starting from b
+ *	-p O.S	pen width `origin' and `slope'
+ *
+ * Numeric values may be appended directly to their flags or separated by a
+ * space; the input file name and the switches may occur in any order.
+ * Note that you can arrange for the Postscript output to be saved in a file
+ * as well as directed to the printer by calling the translator as
+ *
+ *	sgi2ueps.e [params] | tee -a file | lpr -Plw
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define SGK_MAXNDC	32767		/* SGK units			   */
+
+/* Device opcodes and parameters.  The default edge and width parameters (DEF_) 
+ * are given in pixels at 300 dots/inch.  Although bypassing the
+ * device-independence of Postscript, this achieves greater efficiency 
+ * both in translator performance and in transmission rate to the plotter.
+ * The device y-origin is at the lower left corner of the page, but we take
+ * care of this with a Postscript coordinate transformation.  Thus the maximum
+ * page `width' is 11*300 pixels, `height' is 8.5*300 pixels.
+ */
+#define DEV_FRAME	"showpage setcoords setjoins\n"		/* newframe   */
+#define DEV_SETLW	"setlinewidth\n"			/* linewidth  */
+
+#define	MAX_POINTS	512	/* maximum points on stack before a STROKE    */
+#define DEF_LEFT	30	/* origin in device pixels in x		      */
+#define DEF_WIDTH	3180	/* width in x (300d/i, 11" paper)	      */
+#define DEF_BOTTOM	60	/* origin in device pixels in y		      */
+#define DEF_HEIGHT	2415	/* height in y (300d/i, 8.5" paper)	      */
+#define	DEV_UNITS	300	/* EPS translator units: N per inch	      */
+#define	EPS_UNITS	72	/* PostScript units (points)		      */
+#define	DEF_PENBASE	3	/* base pen width (LW 1->2)	      	      */
+#define DEF_PENSLOPE	4	/* pen width slope (LW 2->4, 3->6 etc.)	      */
+#define SZ_PENCMD	16	/* total no. of chars in penwidth instruction */
+#define	SZ_PENVAL	2	/* no. of chars in penwidth value	      */
+#define	SZ_VCODE	7	/* no. of chars in MOVE or DRAW opcode	      */
+#define	SZ_VECT		17	/* total no. chars in a MOVE or DRAW inst.    */
+#define	SZ_COORD	4	/* no. of chars in device coordinate          */
+#define	XY_MOVE		0
+#define	XY_DRAW		1
+
+struct sgi_inst {
+	short	opcode;
+	short	x;
+	short	y;
+};
+
+/* Commands to setup Postscript environment.
+ */
+static char *ps_init[] = {
+	"/devppi 300 def",
+	"/userppi 72 def",
+	"/pagewidth 8.5 def",
+	"/devpixtouser { userppi mul devppi div } def",
+	"/setscale { 1 devpixtouser 1 devpixtouser scale } def",
+	"/pagetolandscape 90 def",
+	"/setcoords { pagewidth userppi mul 0 translate",
+	"    pagetolandscape rotate setscale } def",
+	"/setjoins { 1 setlinejoin 1 setlinecap } def",
+	NULL };
+
+static char *ps_endprolog[] = {
+	"%%EndProlog",
+	"%%Page: 1 1",
+	"gsave setscale setjoins",
+	NULL };
+
+/* 7BYTE -- Postscript procedures to move or draw, with the X,Y coordinates
+ * encoded as a 4 byte sequence (7 bytes including the command name and spaces)
+ * following the command name.  This is the fastest encoding, since it
+ * minimizes the Postscript interpreter execution time.
+ *
+ *	bit	76543210
+ * ------------------------------------------
+ *	     0  01XXXXXX	hi 6 X bits
+ *	     1  01XXXXXX	li 6 X bits
+ *	     2  01YYYYYY	hi 6 Y bits
+ *	     3  01YYYYYY	lo 6 Y bits
+ */
+static char *ps_7byte[] = {
+	"/getpoint {",
+	"	currentfile read pop 8#77 and 6 bitshift",
+	"	currentfile read pop 8#77 and or",
+	"	currentfile read pop 8#77 and 6 bitshift",
+	"	currentfile read pop 8#77 and or",
+	"	} def",
+	"/m { getpoint moveto } def",
+	"/d { getpoint lineto } def",
+	NULL };
+
+/* 4BYTE -- Postscript procedure to draw an arbitrary series of vectors,
+ * encoded 4 bytes per point.  This is the most space efficient encoding,
+ * but the runtime may be somewhat longer than for the 7byte encoding,
+ * due to the Postscript interpreter overhead.
+ *
+ * Optional Flag byte:
+ *		>		move instruction
+ *		+		draw instruction
+ *		$		terminate plotting
+ *		other		ignored (e.g., whitespace)
+ *
+ * Point Encoding:
+ *	       bit 76543210
+ *	 ------------------------------------------
+ *		1  01XXXXXX	hi 6 X bits
+ *		2  01XXXXXX	lo 6 X bits
+ *		3  01YYYYYY	hi 6 Y bits
+ *		4  01YYYYYY	lo 6 Y bits
+ *
+ * Data points are encoded 12 bits (0-4095) per X,Y coordinate.  The flag byte
+ * is used as the terminator, to toggle the move/draw state, and to permit
+ * whitespace to be ignored.  A high bit is set in each byte to ensure a
+ * printable character, as control codes would interfere with the operation of
+ * the Postscript interpreter.
+ */
+#define	CH_MOVE		'>'
+#define	CH_DRAW		'+'
+#define	CH_EXITPLOT	'$'
+
+static char *ps_4byte[] = {
+	"/plot { /movepen { moveto } def",
+	"	 { currentfile read not { exit } if",
+	"	   { dup 8#100 ge",
+	"	     { exit }",
+	"	     { dup 8#076 eq",
+	"	       { pop /movepen { moveto } def",
+	"		 currentfile read not { exit } if }",
+	"	       { dup 8#053 eq",
+	"	         { pop /movepen { lineto } def",
+	"		   currentfile read not { exit } if }",
+	"	         { dup 8#044 eq",
+	"		   { exit }",
+	"		   { pop currentfile read not { exit } if }",
+	"		   ifelse }",
+	"		 ifelse }",
+	"	       ifelse }",
+	"	     ifelse",
+	"	   } loop",
+	"	   dup 8#044 eq { pop exit } { 8#77 and 6 bitshift } ifelse",
+	"	   currentfile read pop 8#77 and or",
+	"	   currentfile read pop 8#77 and 6 bitshift",
+	"	   currentfile read pop 8#77 and or",
+	"	   movepen",
+	"	 } loop",
+	"      } def",
+	NULL };
+
+static	int npts = 0;
+static	int fourbyte = 0;
+static	int penmode = -1;
+static	int dev_left;
+static	int dev_bottom;
+static	int dev_width;
+static	int dev_height;
+static	int dev_penbase  = DEF_PENBASE;
+static	int dev_penslope = DEF_PENSLOPE;
+static	char progname[SZ_LINE+1];
+
+static  void  translate (FILE *in, FILE *out);
+static  void  xy_point (FILE *out, register int x, register int y, int flag);
+static  void  xy_flush (FILE *out);
+static  char *penencode (int val, char *code);
+static  void  textout (FILE *out, char *text[]);
+static  void  eps_comments (FILE *out);
+
+
+
+/* MAIN -- Main entry point for SGI2UAPL.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+	char	*argp;
+	int	argno;
+	int	np;
+	char	penparam[SZ_PENCMD];
+
+
+	strcpy (progname, argv[0]);
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+	    if (argp[0] == '-') {
+		/* A window-control or pen width switch.
+		 */
+		switch (argp[1]) {
+		case '4':
+		    fourbyte++;
+		    break;
+		case 'l':
+		    dev_left = get_iarg (argp[2], argv, argno, DEF_LEFT);
+		    break;
+		case 'b':
+		    dev_bottom = get_iarg (argp[2], argv, argno, DEF_BOTTOM);
+		    break;
+		case 'w':
+		    dev_width = get_iarg (argp[2], argv, argno, DEF_WIDTH);
+		    break;
+		case 'h':
+		    dev_height = get_iarg (argp[2], argv, argno, DEF_HEIGHT);
+		    break;
+		case 'p':
+		    if (argp[2] == (char) 0)
+			if (argv[argno+1] == NULL) {
+			    fprintf (stderr, "missing arg to switch `%s';",
+				argp);
+			    fprintf (stderr, " reset to %d.%d\n", dev_penbase,
+				dev_penslope);
+			} else
+			    strcpy (penparam, argv[++argno]);
+		    else
+			strcpy (penparam, argv[argno]+2);
+		    
+		    np = sscanf (penparam, "%d . %d", &dev_penbase,
+			&dev_penslope);
+		    if (np == 1) {
+			dev_penslope = dev_penbase;
+		    } else if (np < 1) {
+			dev_penbase = DEF_PENBASE;
+			dev_penslope = DEF_PENSLOPE;
+		    }
+
+		    break;
+		default:
+		    fprintf (stderr, "sgi2ueps: unknown switch '%s'\n", argp);
+		}
+
+	    } else {
+		/* Input sgi-metacode file specification.
+		 */
+		infile = argp;
+	    }
+	}
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2ueps):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the metacode.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into device 
+ * instructions and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+	int	 n, x, y, curpoints = 0, swap_bytes;
+	float	 xscale, yscale;
+
+
+	swap_bytes = isSwapped();
+
+	xscale = (float) dev_width / (float) SGK_MAXNDC;
+	yscale = (float) dev_height / (float) SGK_MAXNDC;
+
+	/* Output device initialization.  */
+	eps_comments (out);
+	textout (out, ps_init);
+
+	/* Define the Postscript plotting procedures. */
+	if (fourbyte)
+	    textout (out, ps_4byte);
+	else
+	    textout (out, ps_7byte);
+
+	textout (out, ps_endprolog);
+
+	/* Initialize pen width.  */
+	fwrite (penencode (dev_penbase, DEV_SETLW), SZ_PENCMD, 1, out);
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    xy_flush (out);
+		    fprintf (out, DEV_FRAME);
+		    break;
+
+		case SGK_MOVE:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    xy_point (out, x, y, XY_MOVE);
+		    break;
+
+		case SGK_DRAW:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    xy_point (out, x, y, XY_DRAW);
+
+		    /* Limit number of points passed to Postscript between
+		     * 'stroke' commands to draw the buffered points.
+		     */
+		    curpoints = curpoints + 1;
+		    if (curpoints > MAX_POINTS) {
+			xy_flush (out);
+			xy_point (out, x, y, XY_MOVE);
+			curpoints = 0;
+		    }
+		    break;
+
+		case SGK_SETLW: {
+		    /* Set pen width.
+		     */
+		    int x = max (0, sgip->x - 1);
+
+		    xy_flush (out);
+		    curpoints = 0;
+		    fwrite (penencode (
+			max (1, dev_penbase + x * dev_penslope), DEV_SETLW),
+			SZ_PENCMD, 1, out);
+		    }
+		    break;
+		
+		default:
+		    fprintf (stderr, "sgi2ueps: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	xy_flush (out);
+
+	fprintf (out, "grestore showpage\n");
+}
+
+
+/* XY_POINT -- Output a move or draw instruction, using either the 4 byte or
+ * 7 byte encoding scheme.
+ */
+static void
+xy_point (
+    FILE *out,			/* output file */
+    register int x, 		/* coords to move to */
+    register int y,		/* coords to move to */
+    int	flag 			/* move or draw? */
+)
+{
+	static char o[] = "m XXXX";
+	register char	*op = o;
+	register int	n;
+
+	if (fourbyte) {
+	    if (npts == 0) {
+		fputs ("plot\n", out);
+		penmode = XY_MOVE;
+	    }
+
+	    if (flag != penmode)
+		*op++ = ((penmode = flag) == XY_MOVE) ? CH_MOVE : CH_DRAW;
+
+	    *op++ = ((n = ((x >> 6) & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = (x & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = ((y >> 6) & 077)) == 077) ? n : (0100 | n);
+	    *op++ = ((n = (y & 077)) == 077) ? n : (0100 | n);
+
+	    fwrite (o, op-o, 1, out);
+	    if (!(++npts % 15))
+		fputc ('\n', out);
+
+	} else {
+	    o[0] = (flag == XY_MOVE) ? 'm' : 'd';
+	    o[2] = ((n = ((x >> 6) & 077)) == 077) ? n : (0100 | n);
+	    o[3] = ((n = (x & 077)) == 077) ? n : (0100 | n);
+	    o[4] = ((n = ((y >> 6) & 077)) == 077) ? n : (0100 | n);
+	    o[5] = ((n = (y & 077)) == 077) ? n : (0100 | n);
+
+	    fwrite (o, 6, 1, out);
+	    if (!(++npts % 10))
+		fputc ('\n', out);
+	    else
+		fputc (' ', out);
+	}
+}
+
+
+/* XY_FLUSH -- Terminate the current drawing sequence, if any, and issue the
+ * stroke command to Postscript to draw the buffered points.
+ */
+static void
+xy_flush (FILE *out)
+{
+	if (npts > 0) {
+	    if (fourbyte)
+		fputs ("$\n", out);
+	    else if (npts % 10)
+		fputc ('\n', out);
+	    fputs ("stroke\n", out);
+	    npts = 0;
+	}
+}
+
+
+/* PENENCODE -- Encode base, slope into a character string formatted for the
+ * device set-pen command.
+ */
+static char *
+penencode (
+    int	  val, 			/* device line width 		*/
+    char *code			/* device set-linewidth command */
+)
+{
+	static char	obuf[SZ_PENCMD+1];
+	register int	digit, n;
+	register char	*op, *ip;
+
+	for (op = &obuf[SZ_PENVAL-1], digit = SZ_PENVAL, n=val;  --digit >= 0;
+	    n = n / 10)
+	    *op-- = n % 10 + '0';
+	obuf[SZ_PENVAL] = ' ';
+	for (op = &obuf[SZ_PENVAL+1], ip = code, n = SZ_PENCMD;  --n >= 0;  )
+	    *op++ = *ip++;
+
+	return (obuf);
+}
+
+
+/* TEXTOUT -- Output lines of text to a file.
+ */
+static void
+textout (
+    FILE  *out,			/* output file */
+    char  *text[] 		/* array of lines of text */
+)
+{
+	register char **lp;
+
+	for (lp=text;  *lp;  lp++) {
+	    fputs (*lp, out);
+	    fputc ('\n', out);
+	}
+}
+
+
+/* EPS_COMMENTS -- Set identifying comments for EPS conformance.
+ */
+static void
+eps_comments (FILE *out)
+{
+	time_t	clock;
+	int	llx, lly, urx, ury;
+
+	clock = time(0);
+
+	fprintf (out, "%%!PS-Adobe-3.0 EPSF-3.0\n");
+	fprintf (out, "%%%%Title: IRAF SGI plot\n");
+	fprintf (out, "%%%%Creator: %s\n", progname);
+	fprintf (out, "%%%%CreationDate: %s", asctime(localtime(&clock)));
+
+	/* Compute bounding box in PostScript coordinates. */
+	llx = ((float) dev_left / (float) DEV_UNITS) * (float) EPS_UNITS;
+	lly = ((float) dev_bottom / (float) DEV_UNITS) * (float) EPS_UNITS;
+	urx = ((float) (dev_left + dev_width) / (float) DEV_UNITS)
+	    * (float) EPS_UNITS;
+	ury = ((float) (dev_bottom + dev_height) / (float) DEV_UNITS)
+	    * (float) EPS_UNITS;
+
+	fprintf (out, "%%%%BoundingBox: %d %d %d %d\n", llx, lly, urx, ury);
+	fprintf (out, "%%%%Pages: 1\n");
+	fprintf (out, "%%%%EndComments\n");
+}
diff --git a/unix/gdev/sgidev/sgi2uhpgl.c b/unix/gdev/sgidev/sgi2uhpgl.c
new file mode 100644
index 00000000..2e952446
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uhpgl.c
@@ -0,0 +1,160 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UHPGL.C -- Read IRAF SGI metacode from standard input, translate into
+ * HP graphics language call for HP 7550A plotter
+ *
+ * Usage
+ *	sgi2uhpgl.e [sgi_metacode] [| lpr -Papple]
+ *
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define GKI_MAXNDC	32767		/* SGK units			   */
+
+/* Device opcodes and parameters.  
+ */
+#define DEV_INIT	"IN;DF;SP1;"				/* initialize */
+#define DEV_END		"SP0;PG:"				/* terminate  */
+#define DEV_FRAME	"PG;"					/* newframe   */
+#define DEV_MOVE 	"PU"					/* move       */
+#define DEV_DRAW 	"PD"					/* draw       */
+#define	PRES		1016		/* plotter resolution per inch */
+#define XLEN_INCHES	10.0		/* width of plot (x) in inches */
+#define YLEN_INCHES	8.0		/* height of plot (y) in inches */
+#define XSCALE		PRES * XLEN_INCHES / GKI_MAXNDC
+#define YSCALE		PRES * YLEN_INCHES / GKI_MAXNDC
+
+
+#define	SZ_COORD	4	/* no. of chars in device coordinate          */
+
+struct sgi_inst {
+	short	opcode;
+	short	x;
+	short	y;
+};
+
+static void translate (FILE *in, FILE *out);
+
+
+/* MAIN -- Main entry point for SGI2UHPGL.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+
+
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	infile = argv[1];
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2uhpp):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the metacode.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into device 
+ * instructions and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+	int	 n, swap_bytes;
+	float	x, y;
+
+
+	swap_bytes = isSwapped();
+
+	/* Output device initialization.
+	 */
+	fprintf (out, "%s\n", DEV_INIT);
+
+	/* Initialize pen width. Not implemented.
+	 */
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    fprintf (out, "%s\n", DEV_FRAME);
+		    break;
+
+		case SGK_MOVE:
+		    x = sgip->x * XSCALE;
+		    y = sgip->y * YSCALE;
+		    fprintf (out,
+			"%s%06.0f%s%06.0f%s\n", DEV_MOVE, x, ",", y, ";");
+		    break;
+
+		case SGK_DRAW:
+		    x = sgip->x * XSCALE;
+		    y = sgip->y * YSCALE;
+		    fprintf (out,
+			"%s%06.0f%s%06.0f%s\n", DEV_DRAW, x, ",", y, ";");
+		    break;
+
+		case SGK_SETLW:
+		    /* Set pen width.
+		     */
+		    break;
+		default:
+		    fprintf (stderr, "sgi2uhpp: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	fwrite (DEV_END, strlen(DEV_END), 1, out);
+	fprintf (out, "\n");
+}
diff --git a/unix/gdev/sgidev/sgi2uhplj.c b/unix/gdev/sgidev/sgi2uhplj.c
new file mode 100644
index 00000000..7c8956ce
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uhplj.c
@@ -0,0 +1,223 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UHPLJ.C -- Read IRAF SGI rasterfile from standard input, translate into
+ * the Hewlett Packard Printer Command Language (HP Laserjet Series) and
+ * write to standard output.
+ *
+ * Warning
+ *	The output of this is for 150 dpi. At this resolution it will take
+ *	some 200 seconds to plot an simple "prow".
+ *
+ * Usage
+ *	sgi2uhplj.e [-params] [sgi_] [| lpr -Phpraw]
+ *
+ *	-l N   left edge; x plot origin in device pixels      def DEF_LEFT
+ *	-b N   bottom edge; y plot origin in device pixels    def DEF_BOTTOM
+ *	-w N   width of plot, device pixels starting from l   def DEF_WIDTH
+ *	-h N   height of plot, device pixels starting from b  def DEF_HEIGHT
+ *
+ * Numeric values may be appended directly to their flags or separated by a
+ * space; the input file name and the switches may occur in any order.
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define NBITS_CHAR	8		/* number of bits in a char        */	
+
+/* Device opcodes and parameters.  The default edge and width parameters (DEF_) 
+ * are given in HP pixels, at 150 dots/inch.  The HP plots in portrait mode
+ * by default so RO must be set in GRAPHCAP. Thus the maximum page `width' is 
+ * 11*150pixels, `height' is 8.5*150 pixels.
+ */
+
+#define DEV_INIT	"\033*t150R\033*r1A"	/* Enter graph.               */
+#define DEV_END		"\033*rB\014" 		/* Exit graph. */
+#define DEV_VECT	"\033*p%03dX\033*p%03dY"/* x,y cursor posn in dots */
+#define DEV_RAST	"\033*b%03dW"		/* transfer raster graphics */
+
+#define DEF_LEFT	15	/* origin in device pixels in x		      */
+#define DEF_WIDTH	1216	/* width in x (150d/i, 8.5" paper)	      */
+#define DEF_BOTTOM	30	/* origin in device pixels in y		      */
+#define DEF_HEIGHT	1590	/* height in y (150d/i, 11" paper)	      */
+
+#define SZ_VECT		14	/* total chars in cursor position command   */
+#define SZ_RAST		7	/* total chars in transfer graphics command   */
+
+/* graphcap entry for uhplj and sgi_hplaserjet. one problem with current
+ * entry is that graph comes out slightly to the right of center on the page
+ * The printer used, "hpraw", is site dependent.
+ *
+ * uhplj|UNIX generic interface to Hewlett-Packard LaserJet II:\
+ * 	:BF:WS:XO#0:YO#0:LO#2:LS#2:\
+ * 	:DD=plnode!hpii,tmp$sgk,!{ sgidispatch sgi2uhpii $F \
+ *	-l$(XO) -b$(YO) -w$(PX) -h$(PY) $F | lpr -Phpraw; rm $F; }&:\
+ *	:tc=sgi_hplaserjet:
+ *
+ * sgi_hplaserjet|Hewlett Packard LaserJet Plus at 150 dpi:\
+ *	:kf=bin$x_sgikern.e:tn=sgikern:cw#.0125:ch#.0294:\
+ *	:ar#1.325:xs#.2032:ys#.2692:xr#1200:yr#1590:\
+ *	:XO#8:YO#0:XW#1200:YW#1590:PX#1216:PY#1590:LO#1:LS#0:\
+ *	:BI:MF#8:RO:NB#8:
+ */
+
+int	dev_left;
+int	dev_bottom;
+int	dev_width;
+int	dev_height;
+
+static void  translate (FILE *in, FILE *out);
+static char *xyencode (int x, int y);
+
+
+/* MAIN -- Main entry point for SGI2UHPII.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+	char	*argp;
+	int	argno;
+
+
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+	    if (argp[0] == '-') {
+		/* A window-control or pen width switch.
+		 */
+		switch (argp[1]) {
+		case 'l':
+		    dev_left = get_iarg (argp[2], argv, argno, DEF_LEFT);
+		    break;
+		case 'b':
+		    dev_bottom = get_iarg (argp[2], argv, argno, DEF_BOTTOM);
+		    break;
+		case 'w':
+		    dev_width = get_iarg (argp[2], argv, argno, DEF_WIDTH);
+		    break;
+		case 'h':
+		    dev_height = get_iarg (argp[2], argv, argno, DEF_HEIGHT);
+		    break;
+		default:
+		    break;
+		}
+
+	    } else {
+		/* Input sgi-raster file specification.
+		 */
+		infile = argp;
+	    }
+	}
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2uhpii):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the rasterfile.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI Raster File format into Hewlett Packard
+ * Raster graphics instructions and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	int	n1, swap_bytes;
+	int	n, nlines, length, len_buf;
+	register unsigned char *bp1, *buffer1;
+	char buf_rast [SZ_RAST];
+
+
+	swap_bytes = isSwapped ();
+
+	len_buf = dev_width / NBITS_CHAR;
+	buffer1 = (unsigned char *)malloc (len_buf);
+
+	/* Output device initialization.
+	 */
+	fwrite (xyencode (dev_left, dev_bottom), SZ_VECT, 1, out);
+	fwrite (DEV_INIT, strlen(DEV_INIT), 1, out);
+
+	/* Process the raster file
+	 */
+	nlines = dev_height;
+	while ((n = fread (buffer1, len_buf, 1, in)) > 0) {
+
+	    if (swap_bytes) 
+		bswap2 (buffer1, buffer1, len_buf);
+
+	    /* Keep track of number of lines left on the page.
+	     */
+	    if (!(nlines--)) {
+		nlines += dev_height;
+		fwrite (DEV_END, strlen (DEV_END), 1, out);
+		fwrite (xyencode (dev_left, dev_bottom), SZ_VECT, 1, out);
+		fwrite (DEV_INIT, strlen (DEV_INIT), 1, out);
+	    }
+
+	    /* Search for trailing null bytes to trim them off.
+	     */
+	    length = len_buf;
+	    for (bp1 = buffer1+length; length && *(--bp1) == 0; length--)
+		;
+
+	    n1 = length;
+	    if (n1 == 0) {
+		n1 = 1;
+		*buffer1 = 0;
+	    }
+
+	    /* Now copy out this line and prefix it with the control codes.
+	     */
+	    sprintf (buf_rast, DEV_RAST, n1);
+	    fwrite (buf_rast, SZ_RAST, 1, out);
+	    fwrite (buffer1, n1, 1, out);
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	fwrite (DEV_END, strlen(DEV_END), 1, out);
+}
+
+
+/* XYENCODE -- Encode x, y into a character string formatted for the device.
+ */
+static char *
+xyencode (int x, int y)
+{
+    static char obuf [SZ_VECT];
+
+    memset (obuf, 0, SZ_VECT);
+    sprintf (obuf, DEV_VECT, x, y);
+    return (obuf);
+}
diff --git a/unix/gdev/sgidev/sgi2uimp.c b/unix/gdev/sgidev/sgi2uimp.c
new file mode 100644
index 00000000..a8f566ed
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uimp.c
@@ -0,0 +1,341 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UIMP.C -- Read IRAF SGI metacode from standard input, translate into
+ * the Impress language and write to standard output.
+ *
+ * Usage
+ *	sgi2uimp.e [-params] [sgi_metacode] [| lpr -v -Pimagen]
+ *
+ *	-l N  left edge; x plot origin in device pixels       def DEF_LEFT
+ *	-b N  bottom edge; y plot origin in device pixels     def DEF_BOTTOM
+ *	-w N  width of plot, device pixels starting from l    def DEF_WIDTH
+ *	-h N  height of plot, device pixels starting from b   def DEF_HEIGHT
+ *	-p O.S pen width `origin' and `slope'	 	      def DEF_PENBASE
+ *								 .DEF_PENSLOPE
+ *
+ * Numeric values may be appended directly to their flags or separated by a
+ * space; the input file name and the switches may occur in any order.
+ * The windowing parameters are specified explicitly rather than using the
+ * plotter resolution and paper size due to differences in exactly where
+ * each different Imagen begins and ends plotting within the paper window.
+ *
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define GKI_MAXNDC	32767		/* SGK units			   */
+
+/* Device opcodes and parameters.  The default edge and width parameters
+ * (DEF_), given in device pixels for a 240 dot/inch Imagen with 8 1/2" x 11"
+ * paper, should be modified to fit the local plotter.
+ */
+#define DEF_LEFT	85		/* origin in device pixels in x	   */
+#define DEF_WIDTH	2490		/* width in x (240d/i, 11" paper)  */
+#define DEF_BOTTOM	50		/* origin in device pixels in y    */
+#define DEF_HEIGHT	1905		/* height in y (240d/i, 8.5" paper)*/
+#define	DEF_PENBASE	2		/* base pen width 		   */
+#define DEF_PENSLOPE	2		/* pen slope (b.s=3.2 ==> 3,5,7,9) */
+#define SZ_PENPARAM	5		/* max chars in penwidth parameter */
+#define BLACK_LINE	15		/* draw solid line		   */
+#define CREATE_PATH	230		/* set up set of vertices	   */
+#define DRAW_PATH	234		/* draw that set of vertices	   */
+#define END_DOCUMENT	255		/* end of document		   */
+#define END_PAGE	219		/* formfeed			   */
+#define HV_VALUE	125		/* 0 11 11 101 (orig, axes, orient)*/
+#define SET_ABS_H	135		/* move absolute in h              */
+#define SET_ABS_V	137		/* move absolute in v		   */
+#define SET_HV_SYSTEM	205		/* establish coordinate system     */
+#define SET_PEN		232		/* set pen width		   */
+#define SZ_HEAD		3		/* # header opcode bytes in obuf   */
+#define SZ_TAIL		2		/* # trailing opcode bytes in obuf */
+#define	COUNT_OFFSET	1		/* byte offset to npoints in obuf  */
+
+/* Output macros -- watch out for SZ_OBUF; some Imagens have a limited amount
+ * of memory for the DRAW buffer:
+ */
+#define SZ_OBUF		(1024)
+#define DECL_OBUF	register char *op; char *np; char obuf[SZ_OBUF+1];
+#define o_clear		(op=obuf)
+#define o_flush(o)	fwrite(obuf,op-obuf,1,o)
+#define putbyte(v)	(*op++ = (v))
+#define putword(v)	((*op++ = (v)/256), (*op++ = (v)%256))
+#define setcount(b,v)	((np = obuf+b), (*np++ = (v)/256), (*np = (v)%256))
+#define npoints		((op-obuf - SZ_HEAD)/4)
+#define obuf_full	((op-obuf + SZ_TAIL) >= SZ_OBUF)
+
+struct sgi_inst {
+	short	opcode;
+	short	x;
+	short	y;
+};
+
+int	imp_left;
+int	imp_bottom;
+int	imp_width;
+int	imp_height;
+int	imp_penbase  = DEF_PENBASE;
+int	imp_penslope = DEF_PENSLOPE;
+
+static void translate (FILE *in, FILE *out);
+
+
+/* MAIN -- Main entry point for SGI2UIMP.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+	char	*argp;
+	int	argno;
+	int	np;
+	char	penparam[SZ_PENPARAM];
+
+
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+	    if (argp[0] == '-') {
+		/* A window-control or pen width switch.
+		 */
+		switch (argp[1]) {
+		case 'l':
+		    imp_left = get_iarg (argp[2], argv, argno, DEF_LEFT);
+		    break;
+		case 'b':
+		    imp_bottom = get_iarg (argp[2], argv, argno, DEF_BOTTOM);
+		    break;
+		case 'w':
+		    imp_width = get_iarg (argp[2], argv, argno, DEF_WIDTH);
+		    break;
+		case 'h':
+		    imp_height = get_iarg (argp[2], argv, argno, DEF_HEIGHT);
+		    break;
+		case 'p':
+		    if (argp[2] == (char) 0)
+			if (argv[argno+1] == NULL) {
+			    fprintf (stderr, "missing arg to switch `%s';",
+				argp);
+			    fprintf (stderr, " reset to %d.%d\n", imp_penbase,
+				imp_penslope);
+			} else
+			    strcpy (penparam, argv[++argno]);
+		    else
+			strcpy (penparam, argv[argno]+2);
+		    
+		    np = sscanf (penparam, "%d . %d", &imp_penbase,
+			&imp_penslope);
+		    if (np == 1) {
+			imp_penslope = imp_penbase;
+		    } else if (np < 1) {
+			imp_penbase = DEF_PENBASE;
+			imp_penslope = DEF_PENSLOPE;
+		    }
+
+		    break;
+		default:
+		    break;
+		}
+
+	    } else {
+		/* Input sgi-metacode file specification.
+		 */
+		infile = argp;
+	    }
+	}
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2uimp):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the metacode.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into the device
+ * language and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	int	 n, x, y, swap_bytes;
+	float	 xscale, yscale;
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+	DECL_OBUF;
+
+	swap_bytes = isSwapped();
+
+	xscale = (float) imp_width / (float) GKI_MAXNDC;
+	yscale = (float) imp_height / (float) GKI_MAXNDC;
+
+	/* Output device header instructions.
+	 */
+	fprintf (out, "@Document(%s, %s, %s, %s, %s, %s)",
+	    "language impress", "pagecollation on", "jamresistance on",
+	    "name \"IRAF SGI plot\"", "prerasterization on", "jobheader off");
+
+	/* Output page orientation and coordinate system initialization.
+	 */
+	putc (SET_HV_SYSTEM, out);
+	putc (HV_VALUE, out);
+
+	/* Initialize pen width.
+	 */
+	putc (SET_PEN, out);
+	putc (1 * imp_penbase, out);
+
+	o_clear;
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    /* Terminate and output any DRAW buffer contents.
+		     */
+		    if (npoints > 1) {
+			setcount (COUNT_OFFSET, npoints);
+			putbyte (DRAW_PATH);
+			putbyte (BLACK_LINE);
+			o_flush (out);
+		    }
+
+		    o_clear;
+		    putbyte (END_PAGE);
+		    putbyte (SET_ABS_H);
+		    putword (0);
+		    putbyte (SET_ABS_V);
+		    putword (0);
+		    o_flush (out);
+		    break;
+
+		case SGK_MOVE:
+		    /* Terminate and output any DRAW buffer contents.
+		     */
+		    if (npoints > 1) {
+			setcount (COUNT_OFFSET, npoints);
+			putbyte (DRAW_PATH);
+			putbyte (BLACK_LINE);
+			o_flush (out);
+		    }
+
+		    x = imp_left + sgip->x * xscale;
+		    y = imp_bottom + sgip->y * yscale;
+
+		    /* Initialize output buffer for start of draw instruction.
+		     */
+		    o_clear;
+		    putbyte (CREATE_PATH);
+		    putword (1);
+		    putword (x); putword (y);
+
+		    break;
+
+		case SGK_DRAW:
+		    x = imp_left + sgip->x * xscale;
+		    y = imp_bottom + sgip->y * yscale;
+		    putword (x); putword (y);
+
+		    /* If we are about to exceed output buffer, flush and re-
+		     * initialize starting with current point.
+		     */
+		    if (obuf_full) {
+			setcount (COUNT_OFFSET, npoints);
+			putbyte (DRAW_PATH);
+			putbyte (BLACK_LINE);
+			o_flush (out);
+
+			/* Reinitialize DRAW buffer.
+			 */
+			o_clear;
+			putbyte (CREATE_PATH);
+			putword (1);
+			putword (x); putword (y);
+		    }
+
+		    break;
+
+		case SGK_SETLW:
+		    /* Terminate and output any DRAW buffer contents.
+		     */
+		    if (npoints > 1) {
+			setcount (COUNT_OFFSET, npoints);
+			putbyte (DRAW_PATH);
+			putbyte (BLACK_LINE);
+			o_flush (out);
+			o_clear;
+		    }
+
+		    /* Set pen width.
+		     */
+		    putc (SET_PEN, out);
+		    putc ((imp_penbase + ((sgip->x) - 1) * imp_penslope), out);
+		    break;
+		
+		default:
+		    fprintf (stderr, "sgi2uimp: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Flush any remaining buffered points.
+	 */
+	if (npoints > 1) {
+	    setcount (COUNT_OFFSET, npoints);
+	    putbyte (DRAW_PATH);
+	    putbyte (BLACK_LINE);
+	    o_flush (out);
+	}
+
+	/* Signal end of page and end of document.
+	 */
+	putc (END_PAGE, out);
+	putc (END_DOCUMENT, out);
+}
diff --git a/unix/gdev/sgidev/sgi2uptx.c b/unix/gdev/sgidev/sgi2uptx.c
new file mode 100644
index 00000000..6c44f334
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uptx.c
@@ -0,0 +1,61 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	NBITS_CHAR	8	/* number of bits in a char */
+#define	MASK	64	/* printronix raster flag */
+#define	START_LINE	"\005"		/* start of raster line control code */
+#define	END_LINE	"\012"		/* end   of raster line control code */
+#define	START_PAGE	"\014"		/* form feed */
+
+/* PRINTRONIX translator from the SGI bitmap file to the STDOUT */
+
+int
+main (int argc, char *argv[])
+{
+
+   FILE	*fpi;
+   char	*buffer;
+   int	n, len_buf, nlines;
+   int index; /* goes through all 8 files */
+   int	px, py;
+
+   px = atoi (argv[1]);
+   py = atoi (argv[2]);
+   len_buf = px/NBITS_CHAR;
+   buffer = (char *) malloc (len_buf);
+
+   for (index=3; index<argc; index++) {
+
+      if (index != 3) fwrite (START_PAGE, 1, 1, stdout);
+      fpi = fopen (argv[index], "r");
+      nlines = py;
+   
+      while (fread (buffer, len_buf, 1, fpi)) {
+
+         /* Keep track of number of lines left on the page. */
+         if (!(nlines--)) {
+	    nlines += py;
+            fwrite (START_PAGE, 1, 1, stdout);
+	 }
+
+         /* Turn on the raster flag on every data byte */
+         for (n = 0; n < len_buf; n++) buffer[n] |= MASK;
+
+         /* Now copy out this line and bracket it with the control codes. */
+         fwrite (START_LINE, 1, 1, stdout);
+         fwrite (buffer, len_buf, 1, stdout);
+         fwrite (END_LINE, 1, 1, stdout);
+
+      }
+
+      fclose (fpi);
+
+   }
+
+   return (0);
+}
diff --git a/unix/gdev/sgidev/sgi2uqms.c b/unix/gdev/sgidev/sgi2uqms.c
new file mode 100644
index 00000000..e91d7e38
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2uqms.c
@@ -0,0 +1,296 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+#include "sgiUtil.h"
+
+
+/*
+ * SGI2UQMS.C -- Read IRAF SGI metacode from standard input, translate into
+ * the QMS Vector Graphics Mode (Talaris Lasergrafix, QUIC Command Mode) and
+ * write to standard output.
+ *
+ * Usage
+ *	sgi2uqms.e [-params] [sgi_metacode] [| lpr -Pqms]
+ *
+ *	-l N   left edge; x plot origin in device pixels      def DEF_LEFT
+ *	-b N   bottom edge; y plot origin in device pixels    def DEF_BOTTOM
+ *	-w N   width of plot, device pixels starting from l   def DEF_WIDTH
+ *	-h N   height of plot, device pixels starting from b  def DEF_HEIGHT
+ *	-p O.S pen width `origin' and `slope'	 	      def DEF_PENBASE
+ *								 .DEF_PENSLOPE
+ *
+ * Numeric values may be appended directly to their flags or separated by a
+ * space; the input file name and the switches may occur in any order.
+ */
+
+#define	OSOK		0		/* normal successful completion	   */
+#define	LEN_MCBUF	1024		/* number of SGK instrs in buffer  */
+#define	SGK_FRAME	1		/* new frame instruction	   */
+#define	SGK_MOVE	2		/* move pen	  		   */
+#define	SGK_DRAW	3		/* draw pen			   */
+#define	SGK_SETLW	4		/* set line width		   */
+#define GKI_MAXNDC	32767		/* SGK units			   */
+
+/* Device opcodes and parameters.  The default edge and width parameters (DEF_) 
+ * are given in QMS pixels, at 300 dots/inch.  The QMS y-origin is at the
+ * top of the page, so in GRAPHCAP, YF must be set, and Landscape Orientation
+ * used in the QMS.  Thus the maximum page `width' is 11*300 pixels, `height'
+ * is 8.5*300 pixels.
+ */
+#define DEV_INIT	"\012^PY^-\012^ISYNTAX00010^IOL^F^IGV" /* Enter graph.*/
+#define DEV_END		"^IGE^ISYNTAX00000^IOP^O\012^PN^-\012" /* Exit graph. */
+#define DEV_FRAME	"^,"	/* QMS Vector Graphics Mode form feed instr   */
+#define DEV_MOVE 	"^U"	/* QMS (VGM) pen-up instruction		      */
+#define DEV_DRAW 	"^D"	/* QMS (VGM) pen-down instruction	      */
+#define DEV_SETLW	"^PW"	/* QMS (VGM) Set Line Width (follow w/ nn)    */
+
+#define DEF_LEFT	30	/* origin in device pixels in x		      */
+#define DEF_WIDTH	3180	/* width in x (300d/i, 11" paper)	      */
+#define DEF_BOTTOM	60	/* origin in device pixels in y		      */
+#define DEF_HEIGHT	2415	/* height in y (300d/i, 8.5" paper)	      */
+#define	DEF_PENBASE	3	/* base pen width (LW 1->2)	      	      */
+#define DEF_PENSLOPE	4	/* pen width slope (LW 2->4, 3->6 etc.)	      */
+#define SZ_PENCMD	5	/* total no. of chars in penwidth instruction */
+#define	SZ_PENVAL	2	/* no. of chars in penwidth value	      */
+#define	SZ_VECT		11	/* total no. chars in a MOVE or DRAW inst.    */
+#define	SZ_COORD	4	/* no. of chars in device coordinate          */
+
+struct sgi_inst {
+	short	opcode;
+	short	x;
+	short	y;
+};
+
+int	dev_left;
+int	dev_bottom;
+int	dev_width;
+int	dev_height;
+int	dev_penbase  = DEF_PENBASE;
+int	dev_penslope = DEF_PENSLOPE;
+
+static void  translate (FILE *in, FILE *out);
+static char *xyencode (int opcode, int x, int y);
+static char *penencode (char *opcode, int val);
+
+
+
+/* MAIN -- Main entry point for SGI2UQMS.  Optional arguments are device
+ * window parameters and name of input file.
+ */
+int
+main (int argc, char *argv[])
+{
+	FILE	*in;
+	char	*infile;
+	char	*argp;
+	int	argno;
+	int	np;
+	char	penparam[SZ_PENCMD];
+
+
+	infile = "stdin";
+
+	/* Process the command line.
+	 */
+	for (argno=1;  (argp = argv[argno]) != NULL;  argno++) {
+	    if (argp[0] == '-') {
+		/* A window-control or pen width switch.
+		 */
+		switch (argp[1]) {
+		case 'l':
+		    dev_left = get_iarg (argp[2], argv, argno, DEF_LEFT);
+		    break;
+		case 'b':
+		    dev_bottom = get_iarg (argp[2], argv, argno, DEF_BOTTOM);
+		    break;
+		case 'w':
+		    dev_width = get_iarg (argp[2], argv, argno, DEF_WIDTH);
+		    break;
+		case 'h':
+		    dev_height = get_iarg (argp[2], argv, argno, DEF_HEIGHT);
+		    break;
+		case 'p':
+		    if (argp[2] == (char) 0)
+			if (argv[argno+1] == NULL) {
+			    fprintf (stderr, "missing arg to switch `%s';",
+				argp);
+			    fprintf (stderr, " reset to %d.%d\n", dev_penbase,
+				dev_penslope);
+			} else
+			    strcpy (penparam, argv[++argno]);
+		    else
+			strcpy (penparam, argv[argno]+2);
+		    
+		    np = sscanf (penparam, "%d . %d", &dev_penbase,
+			&dev_penslope);
+		    if (np == 1) {
+			dev_penslope = dev_penbase;
+		    } else if (np < 1) {
+			dev_penbase = DEF_PENBASE;
+			dev_penslope = DEF_PENSLOPE;
+		    }
+
+		    break;
+		default:
+		    break;
+		}
+
+	    } else {
+		/* Input sgi-metacode file specification.
+		 */
+		infile = argp;
+	    }
+	}
+
+	if (strcmp (infile, "stdin") == 0)
+	    in = stdin;
+	else
+	    in = fopen (infile, "r");
+
+	if (in == NULL) {
+	    fprintf (stderr, "Fatal error (sgi2uqms):  Cannot open `%s'\n",
+		infile);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Process the metacode.
+	 */
+	translate (in, stdout);
+
+	if (in != stdin)
+	    fclose (in);
+
+	return (0);
+}
+
+
+/* TRANSLATE -- Interpret input SGI metacode instructions into device 
+ * instructions and write to stdout.
+ */
+static void
+translate (FILE *in, FILE *out)
+{
+	int	 n, x, y, swap_bytes;
+	float	 xscale, yscale;
+	register struct sgi_inst *sgip;
+	struct	 sgi_inst inbuf[LEN_MCBUF], *buftop;
+
+
+	swap_bytes = isSwapped();
+
+	xscale = (float) dev_width / (float) GKI_MAXNDC;
+	yscale = (float) dev_height / (float) GKI_MAXNDC;
+
+	/* Output device initialization.
+	 */
+	fwrite (DEV_INIT, strlen(DEV_INIT), 1, out);
+
+	/* Initialize pen width.
+	 */
+	fwrite (penencode (DEV_SETLW, dev_penbase), SZ_PENCMD, 1, out);
+
+	/* Process the metacode:
+	 */
+	while ((n = fread ((char *)inbuf, sizeof(*sgip), LEN_MCBUF, in)) > 0) {
+
+	    if (swap_bytes)
+		bswap2 ((unsigned char *)inbuf, (unsigned char *)inbuf, 
+		    sizeof(*sgip) * n);
+
+	    buftop = inbuf + n;
+
+	    for (sgip = inbuf;  sgip < buftop;  sgip++) {
+		switch (sgip->opcode) {
+		case SGK_FRAME:
+		    fwrite (DEV_FRAME, strlen(DEV_FRAME), 1, out);
+		    break;
+
+		case SGK_MOVE:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    fwrite (xyencode ('U', x, y), SZ_VECT, 1, out);
+		    break;
+
+		case SGK_DRAW:
+		    x = dev_left + sgip->x * xscale;
+		    y = dev_bottom + sgip->y * yscale;
+		    fwrite (xyencode ('D', x, y), SZ_VECT, 1, out);
+		    break;
+
+		case SGK_SETLW:
+		    /* Set pen width.
+		     */
+		    fwrite (penencode (DEV_SETLW, dev_penbase +
+			((sgip->x) - 1) * dev_penslope), SZ_PENCMD, 1, out);
+		    break;
+		
+		default:
+		    fprintf (stderr, "sgi2uqms: unrecognized sgi opcode %d\n",
+			sgip->opcode);
+		    break;
+		}
+	    }
+	}
+
+	/* Terminate plotting and exit.
+	 */
+	fwrite (DEV_END, strlen(DEV_END), 1, out);
+}
+
+
+/* XYENCODE -- Encode x, y into a character string formatted for the device.
+ */
+static char *
+xyencode (
+    int	opcode,		/* draw or move		*/
+    int	x, 		/* must be positive	*/
+    int	y		/* must be positive	*/
+)
+{
+	static char	obuf[] = "^X0000:0000";
+	register int	digit, n;
+	register char	*op;
+	int	 	i;
+
+	obuf[1] = opcode;
+	i = SZ_VECT - 1 - SZ_COORD - 1;
+	for (op = &obuf[i], digit = SZ_COORD, n=x;  --digit >= 0;  n = n / 10)
+	    *op-- = n % 10 + '0';
+	i = SZ_VECT - 1;
+	for (op = &obuf[i], digit = SZ_COORD, n=y;  --digit >= 0;  n = n / 10)
+	    *op-- = n % 10 + '0';
+
+	return (obuf);
+}
+
+
+/* PENENCODE -- Encode base, slope into a character string formatted for the
+ * device set-pen command.
+ */
+static char *
+penencode (
+    char *opcode,		/* device set-linewidth command */
+    int	  val 			/* device line width 		*/
+)
+{
+	static char	obuf[SZ_PENCMD+1];
+	register int	digit, n;
+	register char	*op;
+
+	strcpy (obuf, opcode);
+	for (op = &obuf[SZ_PENCMD-1], digit = SZ_PENVAL, n=val;  --digit >= 0;
+	    n = n / 10)
+	    *op-- = n % 10 + '0';
+
+	return (obuf);
+}
diff --git a/unix/gdev/sgidev/sgi2xbm.c b/unix/gdev/sgidev/sgi2xbm.c
new file mode 100644
index 00000000..6d4c230a
--- /dev/null
+++ b/unix/gdev/sgidev/sgi2xbm.c
@@ -0,0 +1,135 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "sgiUtil.h"
+
+
+/* SGI2XBM.C -- Read an IRAF SGI bitmap file on standard input and convert
+ *  to a GIF format image on standard outout.
+ *
+ *  Usage:
+ *          sgi2xbm.e [-w N] [-h NY] [-i] [ [sgi_bitmap] [sgi_bitmap] ... ]
+ *
+ *      -w N         width of input bitmap and output image
+ *      -h N         height of input bitmap and output image
+ *	-i	     invert the bitmap values before conversion
+ *
+ *  The input file name and the switches may occur in any order.  The bitmap
+ * may be inverted here using the -i flag.
+ *
+ *  Sample graphcaps for this translator might look like:
+ *
+ *      g-xbm|UNIX generic interface to multi-frame XBM file generator:\
+ *          :DD=ugif,tmp$sgk,!{ sgidispatch sgi2xbm -w $(PX) -h $(PY) \
+ *	    $F.[1-8]  > sgixbm$$; rm $F.[1-8]; }&:\
+ *	    :MF#8:NF:tc=sgi_image_format:
+ *
+ *      sgi_image_format|Generic raster file format specification:\
+ *          :kf=bin$x_sgikern.e:tn=sgikern:ar#.75:\
+ *          :xr#640:yr#480:PX#640:PY#480:XW#640:YW#480:\
+ *          :BI:MF#1:YF:NB#8:LO#1:LS#0:XO#0:YO#0:
+ *
+ *  All bitmaps will be dumped to the file 'sgixbmXXX' in the local directory
+ *  where XXX is a pid.
+ *
+ *  To change the image size the graphcap :xr, :PX, :XW (X-dimension) and
+ *  :yr, :PY, :XY (Y-dimension) fields all need to be changed.  The -i 
+ *  flag must be specified in the graphcap DD string.
+ *
+ */
+
+#define	NBITS_CHAR	8		/* number of bits in a char 	*/
+#define DEF_WIDTH       640             /* default image width          */
+#define DEF_HEIGHT      480             /* default image height         */
+#define MAX_INFILES     16              /* max number of input bitmaps  */
+#define SZ_FNAME        64              /* size of a filename           */
+
+typedef unsigned char   byte;
+
+static int px = DEF_WIDTH;
+static int py = DEF_HEIGHT;
+static int invert = 0;
+static char *infile[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+
+int
+main (int argc, char *argv[])
+{
+	FILE	*fd;
+	byte 	*buffer;
+	int	i, n, len_buf, numin = 0, cnt = 0;
+	int     index; 			/* goes through all files */
+
+
+	/* Process the command line.
+	 */
+        for (i=1;  i < argc;  i++) {
+            if (argv[i][0] == '-') {
+                if (strcmp (argv[i], "-w") == 0)
+                    px = atoi (argv[++i]);
+                else if (strcmp (argv[i], "-h") == 0)
+                    py = atoi (argv[++i]);
+                else if (strcmp (argv[i], "-i") == 0)
+                    invert++;
+            } else {
+                /* input sgi-bitmap file specification */
+                if (numin < MAX_INFILES)
+                    infile[numin++] = argv[i];     
+            }
+
+	}
+
+	/* Allocate some space for the working buffer. */
+	len_buf = px / NBITS_CHAR;
+	buffer = (byte *) malloc (len_buf);
+
+        /* Loop over the input bitmaps, writing the converted output to
+         * the stdout.
+         */
+        for (index = 0; index == 0 || index < numin; index++) {
+
+            /* Open the input file. */
+            fd = (infile[index] ? fopen (infile[index], "r") : stdin);
+
+	    if (index > 0) printf ("\n");
+
+	    printf ("#define xbm%03d_width %d\n", index, px);
+	    printf ("#define xbm%03d_height %d\n", index, py);
+	    printf ("static char xbm%03d_bits[] = {\n  ", index);
+
+	    n = 0;
+	    cnt = 0;
+	    while (fread (buffer, len_buf, 1, fd)) {
+                /* If we're on a MSB ordered machine wordswap the bitmap so
+                 * it's in the correct order for unpacking to be interpreted
+                 * as an LSB-ordered image.
+                 */
+                if (!isSwapped ())
+                    bswap4 (buffer, buffer, len_buf);
+
+		/* Write out the pixels. */
+		for (i=0; i < len_buf; i++, cnt++) {
+		    printf ("0x%.2x", 
+			(byte) (invert ? ~buffer[i]: buffer[i])), n += 4;
+		    if (cnt < (len_buf * py - 1))
+		        printf (","), n++;
+		    else
+	    		printf ("};\n");
+		    if (n > 70)
+		        printf ("\n  "), n=0;
+		}
+	    }
+
+            if (fd != stdin)
+                fclose (fd);
+            fflush (fd);
+	}
+	free (buffer);
+
+	return (0);
+}
diff --git a/unix/gdev/sgidev/sgiUtil.c b/unix/gdev/sgidev/sgiUtil.c
new file mode 100644
index 00000000..25214450
--- /dev/null
+++ b/unix/gdev/sgidev/sgiUtil.c
@@ -0,0 +1,132 @@
+/**
+ *  SGIUTIL.C -- Shared utility procedures for the SGI translators.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <string.h>
+
+#define	import_spp
+#define	import_error
+#include <iraf.h>
+
+
+/** 
+ *  BSWAP2 -- Move bytes from array "a" to array "b", swapping successive
+ *  pairs of bytes.  The two arrays may be the same but may not be offset
+ *  and overlapping.
+ */
+void
+bswap2 (
+    unsigned char *a,			/* input array			*/
+    unsigned char *b,			/* output array			*/
+    int	  nbytes		/* number of bytes to swap	*/
+)
+{
+    register unsigned char *ip, *op, *otop;
+    register unsigned int temp;
+
+    ip = a;
+    op = b;
+    otop = op + (nbytes & ~1);
+
+    /* Swap successive pairs of bytes.
+     */
+    while (op < otop) {
+        temp  = *ip++;
+        *op++ = *ip++;
+        *op++ = temp;
+    }
+
+    /* If there is an odd byte left, move it to the output array.
+     */
+    if (nbytes & 1)
+        *op = *ip;
+}
+
+
+/* BSWAP4 - Move bytes from array "a" to array "b", swapping the four bytes
+ * in each successive 4 byte group, i.e., 12345678 becomes 43218765.
+ * The input and output arrays may be the same but may not partially overlap.
+*/
+void
+bswap4 (
+    unsigned char  *a,                     /* input array                  */
+    unsigned char  *b,                     /* output array                 */
+    int    nbytes                 /* number of bytes to swap      */
+)
+{
+    register int    n;
+    register unsigned char *ip, *op, *tp;
+    static   unsigned char  temp[4];
+
+    tp = temp;
+    ip = (unsigned char *)a;
+    op = (unsigned char *)b;
+
+    /* Swap successive four byte groups.
+     */
+    for (n = nbytes >> 2;  --n >= 0;  ) {
+        *tp++ = *ip++;
+        *tp++ = *ip++;
+        *tp++ = *ip++;
+        *tp++ = *ip++;
+        *op++ = *--tp;
+        *op++ = *--tp;
+        *op++ = *--tp;
+        *op++ = *--tp;
+    }
+
+    /* If there are any odd bytes left, move them to the output array.
+     * Do not bother to swap as it is unclear how to swap a partial
+     * group, and really incorrect if the data is not modulus 4.
+     */
+    for (n = nbytes & 03;  --n >= 0;  )
+        *op++ = *ip++;
+}
+
+
+/**
+ *  ISSWAPPED -- Test whether we are running on a byte-swapped machine.
+ */
+int
+isSwapped (void)
+{
+    union {
+        short   tswap;
+        char    b[2];
+    } test;
+
+    test.tswap = 1;
+    return ((int) test.b[0]);
+}	
+
+
+/**
+ *  GET_IARG -- Get an integer argument, whether appended directly to flag
+ *  or separated by a whitespace character; if error, report and assign
+ *  default.
+ */
+int
+get_iarg (
+    char   argp,
+    char **argv,
+    int    argno,
+    int    def_val
+)
+{
+    int     temp_val;
+
+    if (argp == (char) 0) {
+        if (argv[argno+1] == NULL) {
+            fprintf (stderr, "missing arg to switch `%c';", argp);
+            fprintf (stderr, " reset to %d\n", def_val);
+            temp_val = def_val;
+        } else
+            temp_val = atoi (argv[++argno]);
+    } else
+        temp_val = atoi (argv[argno]+2);
+
+    return (temp_val);
+}
diff --git a/unix/gdev/sgidev/sgiUtil.h b/unix/gdev/sgidev/sgiUtil.h
new file mode 100644
index 00000000..9630a03e
--- /dev/null
+++ b/unix/gdev/sgidev/sgiUtil.h
@@ -0,0 +1,10 @@
+/**
+ *  SGIUTIL.H -- Declarations for the SGI utility routines.
+ */
+
+void  bswap2 (unsigned char *a, unsigned char *b, int nbytes);
+void  bswap4 (unsigned char *a, unsigned char *b, int nbytes);
+
+int   isSwapped (void);
+
+int   get_iarg (char argp, char **argv, int argno, int def_val);
diff --git a/unix/gdev/sgidev/sgidispatch.c b/unix/gdev/sgidev/sgidispatch.c
new file mode 100644
index 00000000..90201460
--- /dev/null
+++ b/unix/gdev/sgidev/sgidispatch.c
@@ -0,0 +1,70 @@
+/* Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#define	import_spp
+#define	import_error
+#define	import_kernel
+#define	import_knames
+#include <iraf.h>
+
+
+/*
+ * SGIDISPATCH.C -- Determine pathname to the executable for the named SGI
+ * translator, and execute the translator.  Pass all command line arguments
+ * to the child, which also inherits stdin, stdout, and stderr.
+ *
+ * Usage: 	sgidispatch translator [args]
+ */
+
+#define	DEF_HOST	"unix"		/* default host system        */
+#define	F_OK		0		/* access mode `file exists'  */
+#ifndef X_OK
+#define	X_OK		1		/* access mode `executable'   */
+#endif
+
+char	*irafpath();
+
+
+/* MAIN -- Main entry point for SGIDISPATCH.
+ */
+int
+main (int argc, char *argv[])
+{
+	char	tpath[SZ_PATHNAME+1];
+	char	translator[SZ_PATHNAME+1];
+	int	ip;
+
+	/* Do nothing if called with no arguments.
+	 */
+	if (argc < 2)
+	    exit (OSOK);
+
+	/* Construct pathname to translator.
+	 */
+	strcpy (translator, argv[1]);
+	ip = strlen (translator);
+	if (strcmp (&translator[ip], ".e") != 0)
+	    strcat (translator, ".e");
+	sprintf (tpath, "%s", irafpath(translator));
+
+	if (access (tpath, X_OK) == ERR) {
+	    fprintf (stderr, "Fatal (sgidispatch): unable to access SGI");
+	    fprintf (stderr, " translator `%s'\n", tpath);
+	    fflush (stderr);
+	    exit (OSOK+1);
+	}
+
+	/* Set up i/o for translator and attempt to fork.
+	 */
+	argv[argc] = 0;
+	execv (tpath, &argv[1]);
+	fprintf (stderr, "Fatal (sgidispatch): unable to execv(%s, ...)\n",
+	    tpath);
+	fflush (stderr);
+	exit (OSOK+1);
+}
diff --git a/unix/gdev/zfiogd.x b/unix/gdev/zfiogd.x
new file mode 100644
index 00000000..a401f9ff
--- /dev/null
+++ b/unix/gdev/zfiogd.x
@@ -0,0 +1,420 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include <mach.h>
+include	<fio.h>
+
+# ZFIOGD -- FIO device driver for the interactive binary graphics devices.
+# This code is host system dependent (at least in part) as well as node
+# dependent, since the set of graphics devices available on a particular node
+# can vary greatly.  The devices for which driver subroutines are linked
+# into this particular version of ZFIOGD are listed below.  The individual
+# driver subroutines must be named explicitly in the case statements in
+# each generic driver subroutine.
+
+define	DEVICES		"|iism70|iism75|imtool|"
+define	DEF_OSDEV_1	"unix:/tmp/.IMT%d"
+define	DEF_OSDEV_2	"fifo:/dev/imt1i:/dev/imt1o"
+define	IMTDEV		"IMTDEV"
+define	DELIMCH		','
+
+define	SZ_OSDEV	512		# device specification string
+define	MAXDEV		8
+define	MAXBYTES	4000		# fifo transfer size, bytes
+define	MAXTRYS		50		# fifo timeout
+define	DELAY		10		# fifo i/o interval, msec
+
+define	IISM70		1		# IIS Model 70 image display
+define	IISM75		2		# IIS Model 75 image display
+define	IMTOOL		3		# IMTOOL-type display server
+define	NDEVICES	3
+
+
+# ZOPNGD -- Open a binary graphics device.  The format of the DEVINFO string
+# is "devname:osdev" (the KI will have already taken care of any network
+# node prefix by the time we are called).
+
+procedure zopngd (devinfo, mode, chan)
+
+char	devinfo[ARB]		#I PACKED device info string
+int	mode			#I access mode
+int	chan			#O receives assigned channel
+
+bool	first_time
+pointer	devname, envname
+pointer	sp, info, imtdev, osdev, pkfname, ip, op
+int	nchars, dev, oschan, arg1, arg2, i
+int	strdic(), ctoi()
+data	first_time /true/
+define	err_ 91
+
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	call smark (sp)
+	call salloc (info, SZ_OSDEV, TY_CHAR)
+	call salloc (osdev, SZ_OSDEV, TY_CHAR)
+	call salloc (imtdev, SZ_OSDEV, TY_CHAR)
+	call salloc (pkfname, SZ_OSDEV, TY_CHAR)
+	call salloc (devname, SZ_FNAME, TY_CHAR)
+	call salloc (envname, SZ_FNAME, TY_CHAR)
+
+	if (first_time) {
+	    do i = 1, MAXDEV
+		gd_dev[i] = NULL
+	    first_time = false
+	}
+
+	# Parse device specification.
+	# -----------------------------
+	call strupk (devinfo, Memc[info], SZ_OSDEV)
+
+	# Extract generic device name.
+	op = devname
+	for (ip=info;  Memc[ip] != EOS && Memc[ip] != DELIMCH;  ip=ip+1) {
+	    Memc[op] = Memc[ip]
+	    op = op + 1
+	}
+	Memc[op] = EOS
+	if (Memc[ip] == DELIMCH)
+	    ip = ip + 1
+	else
+	    goto err_
+
+	# Look up the generic device name in the device table.
+	dev = strdic (Memc[devname], Memc[osdev], 0, DEVICES)
+	if (dev <= 0)
+	    goto err_
+
+	# Get the OS device name.
+	op = osdev
+	for (;  Memc[ip] != EOS && Memc[ip] != DELIMCH;  ip=ip+1) {
+	    Memc[op] = Memc[ip]
+	    op = op + 1
+	}
+	Memc[op] = EOS
+	if (Memc[ip] == DELIMCH)
+	    ip = ip + 1
+
+	# Get any optional integer arguments.
+	if (ctoi (Memc, ip, arg1) <= 0)
+	    arg1 = 0
+	if (Memc[ip] == DELIMCH)
+	    ip = ip + 1
+	if (ctoi (Memc, ip, arg2) <= 0)
+	    arg2 = 0
+
+	# Edit device specification as necessary.
+	# ------------------------------------------
+
+	# If the generic device is IMTOOL and we have an old style OS device
+	# name, convert it to the format required by the ND driver.  If the
+	# OS device name is null supply the default value.  If the user has
+	# "IMTDEV" defined in their host environment this overrides the value
+	# passed in the argument list.
+
+	if (dev == IMTOOL) {
+	    call strpak (IMTDEV, Memc[envname], SZ_FNAME)
+	    call zgtenv (Memc[envname], Memc[imtdev], SZ_OSDEV, nchars)
+
+	    if (nchars > 0) {
+		# Environment override.
+		call strupk (Memc[imtdev], Memc[osdev], SZ_OSDEV)
+
+	    } else if (Memc[osdev] == '/') {
+		# Old style device name.  Convert to the form "fifo:in:out".
+		call strcpy ("fifo:", Memc[imtdev], SZ_OSDEV)
+		call strcat (Memc[osdev], Memc[imtdev], SZ_OSDEV)
+		call strcat ("i:", Memc[imtdev], SZ_OSDEV)
+		call strcat (Memc[osdev], Memc[imtdev], SZ_OSDEV)
+		call strcat ("o", Memc[imtdev], SZ_OSDEV)
+		call strcpy (Memc[imtdev], Memc[osdev], SZ_OSDEV)
+	    }
+	}
+
+	# Allocate a slot in the GD device table for the device.  We need this
+	# to vector to the correct sub-driver when an i/o function is called.
+
+	for (chan=1;  chan <= MAXDEV;  chan=chan+1)
+	    if (gd_dev[chan] == NULL)
+		break
+	if (chan > MAXDEV)
+	    goto err_
+
+	# Try to physically open the device.  [ADD NEW DEVICES HERE].
+	switch (dev) {
+	case IISM70:
+	    call strpak (Memc[osdev], Memc[pkfname], SZ_OSDEV)
+	    call zopm70 (Memc[pkfname], mode, oschan)
+	case IISM75:
+	    call strpak (Memc[osdev], Memc[pkfname], SZ_OSDEV)
+	    call zopm75 (Memc[pkfname], mode, oschan)
+
+	case IMTOOL:
+	    if (Memc[osdev] == EOS) {
+		# Supply default value.
+		call strpak (DEF_OSDEV_1, Memc[pkfname], SZ_OSDEV)
+		call zopnnd (Memc[pkfname], mode, oschan)
+		if (oschan == ERR) {
+		    call strpak (DEF_OSDEV_2, Memc[pkfname], SZ_OSDEV)
+		    call zopnnd (Memc[pkfname], mode, oschan)
+		}
+	    } else {
+		call strpak (Memc[osdev], Memc[pkfname], SZ_OSDEV)
+		call zopnnd (Memc[pkfname], mode, oschan)
+	    }
+
+	default:
+	    oschan = ERR
+	}
+
+	if (oschan == ERR)
+	    goto err_
+
+	gd_dev[chan]    = dev
+	gd_oschan[chan] = oschan
+	gd_status[chan] = OK
+	gd_arg1[chan] = arg1
+	gd_arg2[chan] = arg2
+
+	call sfree (sp)
+	return
+err_
+	chan = ERR
+	call sfree (sp)
+end
+
+
+# ZCLSGD -- Close a binary graphics device.
+
+procedure zclsgd (chan, status)
+
+int	chan			#I channel assigned device
+int	status			#O receives status of close
+
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	# [ADD NEW DEVICES HERE].
+
+	if (chan < 1 || chan > MAXDEV) {
+	    status = ERR
+	    return
+	}
+
+	switch (gd_dev[chan]) {
+	case IISM70:
+	    call zclm70 (gd_oschan[chan], status)
+	case IISM75:
+	    call zclm75 (gd_oschan[chan], status)
+	case IMTOOL:
+	    call zclsnd (gd_oschan[chan], status)
+	default:
+	    status = ERR
+	}
+
+	gd_dev[chan] = NULL
+end
+
+
+# ZARDGD -- Read from a binary graphics device.
+
+procedure zardgd (chan, buf, maxbytes, offset)
+
+int	chan			# channel assigned device
+char	buf[ARB]		# buffer to be filled
+int	maxbytes		# max bytes to read
+long	offset			# file offset (function code else zero)
+
+int	nread, nleft, ntries, n, op
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	gd_status[chan] = OK
+
+	# [ADD NEW DEVICES HERE].
+
+	switch (gd_dev[chan]) {
+	case IISM70:
+	    call zrdm70 (gd_oschan[chan], buf, maxbytes, offset)
+	case IISM75:
+	    call zrdm75 (gd_oschan[chan], buf, maxbytes, offset)
+
+	case IMTOOL:
+	    # Nothing special here, except that we can only move 4096 bytes at
+	    # a time through the pipe to the display server.  Some provision
+	    # for timeout is necessary in the event that the sender dies during
+	    # the transfer.
+	    #
+	    # [we don't need all this for the ND driver, but there is still
+	    # a 4096 byte limit for fifo's, so leave this in for now.]
+
+	    nread  = 0
+	    ntries = 0
+	    op = 1
+
+	    for (nleft=maxbytes;  nleft > 0;  ) {
+		n = min (nleft, MAXBYTES)
+		call zardnd (gd_oschan[chan], buf[op], n, offset)
+		call zawtnd (gd_oschan[chan], n)
+		if (n < 0) {
+		    nread = ERR
+		    break
+		}
+
+		nread = nread + n
+		op = op + n / SZB_CHAR
+		nleft = nleft - n
+		if (n == 0)
+		    call zwmsec (DELAY)
+
+		ntries = ntries + 1
+		if (ntries > MAXTRYS) {
+		    nread = ERR
+		    break
+		}
+	    }
+
+	    gd_status[chan] = nread
+
+	default:
+	    gd_status[chan] = ERR
+	}
+end
+
+
+# ZAWRGD -- Write to a binary graphics device.
+
+procedure zawrgd (chan, buf, nbytes, offset)
+
+int	chan			# channel assigned device
+char	buf[ARB]		# buffer containing the data
+int	nbytes			# nbytes to be written
+long	offset			# file offset (function code else zero)
+
+int	nwrote, nleft, ntries, n, ip
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	gd_status[chan] = OK
+
+	# [ADD NEW DEVICES HERE].
+
+	switch (gd_dev[chan]) {
+	case IISM70:
+	    call zwrm70 (gd_oschan[chan], buf, nbytes, offset)
+	case IISM75:
+	    call zwrm75 (gd_oschan[chan], buf, nbytes, offset)
+
+	case IMTOOL:
+	    nwrote = 0
+	    ntries = 0
+	    ip = 1
+
+	    for (nleft=nbytes;  nleft > 0;  ) {
+		n = min (nleft, MAXBYTES)
+		call zawrnd (gd_oschan[chan], buf[ip], n, offset)
+		call zawtnd (gd_oschan[chan], n)
+		if (n < 0) {
+		    nwrote = ERR
+		    break
+		}
+
+		ip = ip + n / SZB_CHAR
+		nwrote = nwrote + n
+		nleft = nleft - n
+		if (n == 0)
+		    call zwmsec (DELAY)
+
+		ntries = ntries + 1
+		if (ntries > MAXTRYS) {
+		    nwrote = ERR
+		    break
+		}
+	    }
+
+	    gd_status[chan] = nwrote
+
+	default:
+	    gd_status[chan] = ERR
+	}
+end
+
+
+# ZAWTGD -- Wait for i/o to a binary graphics device.
+
+procedure zawtgd (chan, status)
+
+int	chan			# channel assigned device
+int	status			# receives nbytes transferred or ERR
+
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	if (gd_status[chan] == ERR) {
+	    status = ERR
+	    return
+	}
+	
+	# [ADD NEW DEVICES HERE].
+
+	switch (gd_dev[chan]) {
+	case IISM70:
+	    call zwtm70 (gd_oschan[chan], status)
+	case IISM75:
+	    call zwtm75 (gd_oschan[chan], status)
+	case IMTOOL:
+	    status = gd_status[chan]
+	default:
+	    status = ERR
+	}
+end
+
+
+# ZSTTGD -- Get the file status of a binary graphics device.
+
+procedure zsttgd (chan, what, lvalue)
+
+int	chan			# channel assigned device
+int	what			# status parameter being queried
+long	lvalue			# receives value of parameter
+
+int	gd_dev[MAXDEV], gd_oschan[MAXDEV]
+int	gd_status[MAXDEV], gd_arg1[MAXDEV], gd_arg2[MAXDEV]
+common	/zgdcom/ gd_dev, gd_oschan, gd_status, gd_arg1, gd_arg2
+
+begin
+	# [ADD NEW DEVICES HERE].
+
+	switch (gd_dev[chan]) {
+	case IISM70:
+	    call zstm70 (gd_oschan[chan], what, lvalue)
+	case IISM75:
+	    call zstm75 (gd_oschan[chan], what, lvalue)
+
+	case IMTOOL:
+	    switch (what) {
+	    case FSTT_FILSIZE:
+		lvalue = gd_arg1[chan] * gd_arg2[chan] * SZB_CHAR
+	    case FSTT_BLKSIZE:
+		lvalue = gd_arg1[chan] * SZB_CHAR
+	    case FSTT_OPTBUFSIZE:
+		lvalue = gd_arg1[chan] * SZB_CHAR
+	    case FSTT_MAXBUFSIZE:
+		lvalue = 32768
+	    default:
+		lvalue = ERR
+	    }
+	default:
+	    lvalue = ERR
+	}
+end