Repatch (from linux) of OSX IRAF

1 files changed, 178 insertions, 0 deletions

diff --git a/sys/gio/gki/gkiexe.x b/sys/gio/gki/gkiexe.x
new file mode 100644
index 00000000..05e8ec8d
--- /dev/null
+++ b/sys/gio/gki/gkiexe.x
@@ -0,0 +1,178 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<gki.h>
+
+# GKI_EXECUTE -- Execute a metacode instruction.  The instruction is decoded
+# and a graphics kernel driver subroutine is called to execute the instruction.
+# If the device driver does not include a procedure for the instruction the
+# instruction is discarded.  Integer and real parameters are unpacked from
+# their short integer metacode representation.  Character data is passed by
+# reference, i.e., as a SHORT integer array (not EOS delimited char!!), along
+# with the character count.  Attribute packets are passed to the set attribute
+# procedure by reference as a short integer array.
+
+procedure gki_execute (gki, dd)
+
+short	gki[ARB]		# graphics kernel instruction
+int	dd[ARB]			# device driver
+
+int	kp			# kernel procedure
+int	m, n, cn, fn, dummy, flags
+int	x, y, x1, y1, x2, y2
+
+begin
+	switch (gki[GKI_HDR_OPCODE]) {
+
+	case GKI_OPENWS:
+	    kp = dd[GKI_OPENWS]
+	    if (kp != NULL) {
+		m = gki[GKI_OPENWS_M]
+		n = gki[GKI_OPENWS_N]
+		call zcall3 (kp, gki[GKI_OPENWS_D], n, m)
+	    }
+	case GKI_CLOSEWS:
+	    kp = dd[GKI_CLOSEWS]
+	    if (kp != NULL) {
+		n = gki[GKI_CLOSEWS_N]
+		call zcall2 (kp, gki[GKI_CLOSEWS_D], n)
+	    }
+	case GKI_REACTIVATEWS:
+	    kp = dd[GKI_REACTIVATEWS]
+	    if (kp != NULL) {
+		flags = gki[GKI_REACTIVATEWS_F]
+		call zcall1 (kp, flags)
+	    }
+	case GKI_DEACTIVATEWS:
+	    kp = dd[GKI_DEACTIVATEWS]
+	    if (kp != NULL) {
+		flags = gki[GKI_DEACTIVATEWS_F]
+		call zcall1 (kp, flags)
+	    }
+	case GKI_MFTITLE:
+	    kp = dd[GKI_MFTITLE]
+	    if (kp != NULL) {
+		n = gki[GKI_MFTITLE_N]
+		call zcall2 (kp, gki[GKI_MFTITLE_T], n)
+	    }
+	case GKI_CLEAR:
+	    kp = dd[GKI_CLEAR]
+	    if (kp != NULL) {
+		call zcall1 (kp, dummy)
+	    }
+	case GKI_CANCEL:
+	    kp = dd[GKI_CANCEL]
+	    if (kp != NULL) {
+		call zcall1 (kp, dummy)
+	    }
+	case GKI_FLUSH:
+	    kp = dd[GKI_FLUSH]
+	    if (kp != NULL) {
+		call zcall1 (kp, dummy)
+	    }
+	case GKI_POLYLINE:
+	    kp = dd[GKI_POLYLINE]
+	    if (kp != 0) {
+		n = gki[GKI_POLYLINE_N]
+		call zcall2 (kp, gki[GKI_POLYLINE_P], n)
+	    }
+	case GKI_POLYMARKER:
+	    kp = dd[GKI_POLYMARKER]
+	    if (kp != 0) {
+		n = gki[GKI_POLYMARKER_N]
+		call zcall2 (kp, gki[GKI_POLYMARKER_P], n)
+	    }
+	case GKI_TEXT:
+	    kp = dd[GKI_TEXT]
+	    if (kp != NULL) {
+		x = gki[GKI_TEXT_P]
+		y = gki[GKI_TEXT_P+1]
+		n = gki[GKI_TEXT_N]
+		call zcall4 (kp, x, y, gki[GKI_TEXT_T], n)
+	    }
+	case GKI_FILLAREA:
+	    kp = dd[GKI_FILLAREA]
+	    if (kp != 0) {
+		n = gki[GKI_FILLAREA_N]
+		call zcall2 (kp, gki[GKI_FILLAREA_P], n)
+	    }
+	case GKI_PUTCELLARRAY:
+	    kp = dd[GKI_PUTCELLARRAY]
+	    if (kp != NULL) {
+		x1 = gki[GKI_PUTCELLARRAY_LL]
+		y1 = gki[GKI_PUTCELLARRAY_LL+1]
+		x2 = gki[GKI_PUTCELLARRAY_UR]
+		y2 = gki[GKI_PUTCELLARRAY_UR+1]
+		m  = gki[GKI_PUTCELLARRAY_NC]
+		n  = gki[GKI_PUTCELLARRAY_NL]
+		call zcall7 (kp, gki[GKI_PUTCELLARRAY_P], m, n, x1,y1, x2,y2)
+	    }
+	case GKI_SETCURSOR:
+	    kp = dd[GKI_SETCURSOR]
+	    if (kp != NULL) {
+		cn = gki[GKI_SETCURSOR_CN]
+		x  = gki[GKI_SETCURSOR_POS]
+		y  = gki[GKI_SETCURSOR_POS+1]
+		call zcall3 (kp, x, y, cn)
+	    }
+	case GKI_PLSET:
+	    kp = dd[GKI_PLSET]
+	    if (kp != NULL) {
+		call zcall1 (kp, gki)
+	    }
+	case GKI_PMSET:
+	    kp = dd[GKI_PMSET]
+	    if (kp != NULL) {
+		call zcall1 (kp, gki)
+	    }
+	case GKI_TXSET:
+	    kp = dd[GKI_TXSET]
+	    if (kp != NULL) {
+		call zcall1 (kp, gki)
+	    }
+	case GKI_FASET:
+	    kp = dd[GKI_FASET]
+	    if (kp != NULL) {
+		call zcall1 (kp, gki)
+	    }
+	case GKI_GETCURSOR:
+	    kp = dd[GKI_GETCURSOR]
+	    if (kp != NULL) {
+		cn = gki[GKI_GETCURSOR_CN]
+		call zcall1 (kp, cn)
+	    }
+	case GKI_GETCELLARRAY:
+	    kp = dd[GKI_GETCELLARRAY]
+	    if (kp != NULL) {
+		x1 = gki[GKI_GETCELLARRAY_LL]
+		y1 = gki[GKI_GETCELLARRAY_LL+1]
+		x2 = gki[GKI_GETCELLARRAY_UR]
+		y2 = gki[GKI_GETCELLARRAY_UR+1]
+		m  = gki[GKI_GETCELLARRAY_NC]
+		n  = gki[GKI_GETCELLARRAY_NL]
+		call zcall6 (kp, m, n, x1,y1, x2,y2)
+	    }
+	case GKI_ESCAPE:
+	    kp = dd[GKI_ESCAPE]
+	    if (kp != NULL) {
+		fn = gki[GKI_ESCAPE_FN]
+		n  = gki[GKI_ESCAPE_N]
+		call zcall3 (kp, fn, gki[GKI_ESCAPE_DC], n)
+	    }
+	case GKI_SETWCS:
+	    kp = dd[GKI_SETWCS]
+	    if (kp != NULL) {
+		n = gki[GKI_SETWCS_N]
+		call zcall2 (kp, gki[GKI_SETWCS_WCS], n)
+	    }
+	case GKI_GETWCS:
+	    kp = dd[GKI_SETWCS]
+	    if (kp != NULL) {
+		n = gki[GKI_SETWCS_N]
+		call zcall2 (kp, gki[GKI_SETWCS_WCS], n)
+	    }
+	default:
+	    kp = dd[GKI_UNKNOWN]
+	    if (kp != NULL)
+		call zcall1 (kp, gki)
+	}
+end