Repatch (from linux) of OSX IRAF

1 files changed, 183 insertions, 0 deletions

diff --git a/sys/gio/cursor/giotr.x b/sys/gio/cursor/giotr.x
new file mode 100644
index 00000000..cfc8f706
--- /dev/null
+++ b/sys/gio/cursor/giotr.x
@@ -0,0 +1,183 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<config.h>
+include	<xwhen.h>
+include	<gio.h>
+include	<gki.h>
+include	"gtr.h"
+
+# GIOTR -- A graphics filter, called by PR_PSIO (during normal graphics output)
+# and RCURSOR (when in cursor mode) to perform the workstation transformation
+# on a block of metacode instructions, writing the individual instructions to
+# either the inline stdgraph kernel or to an external kernel.  Input is taken
+# from the frame buffer for the stream.  All full instructions starting at the
+# input pointer IP and ending at the output pointer OP are processed, leaving
+# the input pointer positioned to BOI of the last (and incomplete) instruction
+# in the frame buffer.  If output is to an inline kernel the kernel is called
+# to execute each instruction as it is extracted.  If output is to an external
+# kernel instructions are written to the named stream, i.e., into the FIO
+# buffer associated with the stream, and later transferred to the kernel in the
+# external process when the process requests input from the named stream in an
+# XFER directive (see PR_PSIO).
+
+procedure giotr (stream)
+
+int	stream			# graphics stream
+
+pointer	tr, gki
+int	jmpbuf[LEN_JUMPBUF], fn
+int	mode, xint, status, junk, nwords
+common	/gtrvex/ jmpbuf
+
+pointer	gtr_init(), coerce()
+extern	giotr_onint(), gtr_delete()
+int	gtr_fetch_next_instruction(), locpr()
+errchk	gtr_init, gtr_fetch_next_instruction, gki_write
+data	status /OK/, xint /NULL/
+include	"gtr.com"
+
+begin
+	tr = gtr_init (stream)
+
+	# If an interrupt occurs while GIOTR is executing output is cancelled
+	# and further processing is disabled until the next frame begins.
+
+	if (xint == NULL)
+	    call xwhen (X_INT, locpr(giotr_onint), xint)
+
+	call zsvjmp (jmpbuf, status)
+	if (status != OK) {
+	    call gki_cancel (stream)
+	    call gki_deactivatews (stream, 0)
+	}
+
+	# Fetch, optionally transform, and execute each metacode instruction
+	# in the frame buffer.
+
+	while (gtr_fetch_next_instruction (tr, gki) != EOF) {
+	    switch (Mems[gki+GKI_HDR_OPCODE-1]) {
+
+	    case GKI_OPENWS:
+		mode = Mems[gki+GKI_OPENWS_M-1]
+		if (mode != APPEND)
+		    status = OK
+
+		if (status == OK) {
+		    # If the open instruction has already been passed to the
+		    # kernel by gtr_control, do not do so again here.
+
+		    if (TR_SKIPOPEN(tr) == YES)
+			TR_SKIPOPEN(tr) = NO
+		    else
+			call gki_write (stream, Mems[gki])
+
+		    # gtr_control does not call gki_escape so always do this.
+		    call gki_escape (stream, GKI_OPENWS, 0, 0)
+
+		    # Discard frame buffer contents up to and including the
+		    # openws instruction, so that it will only be executed
+		    # once.
+
+		    if (Mems[gki+GKI_OPENWS_M-1] == NEW_FILE)
+			call gtr_frame (tr, TR_IP(tr), stream)
+		}
+
+	    case GKI_CLOSEWS, GKI_DEACTIVATEWS, GKI_REACTIVATEWS:
+		# These instructions are passed directly to the kernel via
+		# the PSIOCTRL stream at runtime, but are ignored in metacode
+		# to avoid unnecessary mode switching of the terminal.
+		;
+
+	    case GKI_CANCEL:
+		# Cancel any buffered graphics data.
+		call gki_write (stream, Mems[gki])
+		call gtr_frame (tr, TR_IP(tr), stream)
+
+	    case GKI_FLUSH, GKI_GETCURSOR, GKI_GETCELLARRAY:
+		# Do not buffer these instructions.
+		call gki_write (stream, Mems[gki])
+		call gtr_delete (tr, gki)
+
+	    case GKI_CLEAR:
+		# Clear is special because it initializes things.
+		if (status != OK) {
+		    call gki_reactivatews (stream, 0)
+		    status = OK
+		}
+		# Execute the instruction.
+		call gki_write (stream, Mems[gki])
+		call gki_escape (stream, GKI_CLEAR, 0, 0)
+
+		# Discard frame buffer contents up to and including the clear.
+		call gtr_frame (tr, TR_IP(tr), stream)
+
+	    case GKI_SETWCS:
+		call gki_write (stream, Mems[gki])
+		nwords = Mems[gki+GKI_SETWCS_N-1]
+		call amovs (Mems[gki+GKI_SETWCS_WCS-1],
+		    Mems[coerce (TR_WCSPTR(tr,1), TY_STRUCT, TY_SHORT)],
+		    min (nwords, LEN_WCS * MAX_WCS * SZ_STRUCT / SZ_SHORT))
+
+	    case GKI_ESCAPE:
+		if (status == OK) {
+		    fn = Mems[gki+GKI_ESCAPE_FN-1]
+
+		    # Execute the escape instruction.
+		    if (wstranset == YES) {
+			call sge_wstran (fn, Mems[gki+GKI_ESCAPE_DC-1],
+			    vx1,vy1, vx2,vy2)
+		    } else
+			call gki_write (stream, Mems[gki])
+
+		    # Allow the kernel escape handling code to preserve,
+		    # delete, or edit the instruction.
+
+		    call sge_spoolesc (tr, gki, fn, Mems[gki+GKI_ESCAPE_DC-1],
+			TR_FRAMEBUF(tr), TR_OP(tr), locpr(gtr_delete))
+		}
+
+	    default:
+		if (status == OK)
+		    if (wstranset == YES) {
+			# Perform the workstation transformation and output the
+			# transformed instruction, if there is anything left.
+			call gtr_wstran (Mems[gki])
+		    } else
+			call gki_write (stream, Mems[gki])
+	    }
+	}
+
+	# Clear the frame buffer if spooling is disabled.  This is done by
+	# moving the upper part of the buffer to the beginning of the buffer,
+	# starting with the word pointed to by the second argument, preserving
+	# the partial instruction likely to be found at the end of the buffer.
+	# Truncate the buffer if it grows too large by the same technique of
+	# shifting data backwards, but in this case without destroying all
+	# of the data.
+
+	if (TR_SPOOLDATA(tr) == NO)
+	    call gtr_frame (tr, TR_IP(tr), stream)
+	else if (TR_OP(tr) - TR_FRAMEBUF(tr) > TR_MAXLENFRAMEBUF(tr))
+	    call gtr_truncate (tr, TR_IP(tr))
+
+	# Pop the interrupt handler.
+	if (xint != NULL) {
+	    call xwhen (X_INT, xint, junk)
+	    xint = NULL
+	}
+end
+
+
+# GIOTR_ONINT -- Interrupt handler for GIOTR.
+
+procedure giotr_onint (vex, next_handler)
+
+int	vex			# virtual exception
+int	next_handler		# next exception handler in chain
+int	jmpbuf[LEN_JUMPBUF]
+common	/gtrvex/ jmpbuf
+
+begin
+	call xer_reset()
+	call zdojmp (jmpbuf, vex)
+end