Repatch (from linux) of OSX IRAF

1 files changed, 399 insertions, 0 deletions

diff --git a/sys/gio/nsppkern/README b/sys/gio/nsppkern/README
new file mode 100644
index 00000000..0990eac0
--- /dev/null
+++ b/sys/gio/nsppkern/README
@@ -0,0 +1,399 @@
+This directory contains the source for the NSPP/GIO kernel, the interface
+between GIO and the old Ncar system plot package and associated metacode
+translators.
+
+Special graphcap entries used by this kernel:
+
+	MF		maximum frame count per metafile
+	FS		frame advance req'd at start of metafile
+	FE		frame advance req'd at end of metafile
+
+Rev 1.0 installed in March 1985.
+----------------------------------------------------------------------------
+
+Differences between Rev 1.0 and Rev 1.1 of the NSPP/GIO kernel.
+Collated at installation of Rev 1.1 on 24 April 1985.
+----------------------------------------------------------------------------
+
+gktclose.x
++ diff gktclose.x ../nsppkern.old/gktclose.x 
+12,13d11
+< 	call frame
+< 	call gkt_flush
++ echo gktclosews.x 
+gktinit.x
++ diff gktinit.x ../nsppkern.old/gktinit.x 
+49a50,59
+> 	# get the window offsets
+> 
+> 	g_xoff = ttygeti (tty, "XO")
+> 	if (g_xoff < 0)
+> 	    g_xoff = 0
+> 	g_yoff = ttygeti (tty, "YO")
+> 	if (g_yoff < 0)
+> 	    g_yoff = 0
+> 
+> 
+112d121
+< 	GKT_PIXREP(g_kt)     = btoi (ttygetb (tty, "pr"))
+gktopenws.x
++ diff gktopenws.x ../nsppkern.old/gktopenws.x 
+98,104c98,99
+< 	if (mode == NEW_FILE) {
+< 	    # Frame call only if NEW_FILE and not first time open with
+< 	    # this device.  This prevents frame before first data.
+< 	    if (!need_open)
+< 	        call frame
+< 	    call gkt_reset
+< 	}
+---
+> 	if (mode == NEW_FILE)
+> 	    call frame()
++ echo gktpcell.x 
+gktpcell.x
++ diff gktpcell.x ../nsppkern.old/gktpcell.x 
+8a9
+> 
+12c13
+< procedure gkt_putcellarray (m, nc, nr, ax1,ay1, ax2,ay2)
+---
+> procedure gkt_putcellarray (m, nc, nr, x1,y1, x2,y2)
+17,18c18,19
+< int	ax1, ay1		# lower left corner of output window
+< int	ax2, ay2		# upper right corner of output window
+---
+> int	x1, y1			# lower left corner of output window
+> int	x2, y2			# upper right corner of output window
+20d20
+< int	x1,y1,x2,y2		# device coordinates
+22c22
+< int	nx, ny, y
+---
+> int	nx, ny
+28c28
+< bool	ca, use_orig, new_row, pr
+---
+> bool	ca, use_orig, new_row
+31,32d30
+< real	delta_y
+< int	xrep, yrep
+43c41
+< 	# Determine if can do real cell array.  If not, use character
+---
+> 	# determine if can do real cell array.  If not, use character
+49d46
+< 	pr = false
+53d49
+< 	    pr = (GKT_PIXREP(g_kt) != 0)
+65,66c61
+< 	# Input arguments (ax, ay) refer to corners of put cell array;
+< 	# we need corners of the corresponding device array.
+---
+> 	# find out how many real pixels we have to fill
+68,73c63,66
+< 	x1 = ax1
+< 	x2 = ax2
+< 	y1 = ay1
+< 	y2 = ay2
+< 	call adjust(x1,x2,xres)
+< 	call adjust(y1,y2,yres)
+---
+> 	px1 = real(x1)/GKI_MAXNDC
+> 	py1 = real(y1)/GKI_MAXNDC
+> 	px2 = real(x2)/GKI_MAXNDC
+> 	py2 = real(y2)/GKI_MAXNDC
+75,79c68,69
+< 	# Find out how many real pixels we have to fill
+< 	px1 = real(x1)/(GKI_MAXNDC+1)
+< 	py1 = real(y1)/(GKI_MAXNDC+1)
+< 	px2 = real(x2)/(GKI_MAXNDC+1)
+< 	py2 = real(y2)/(GKI_MAXNDC+1)
+---
+> 	nx = int( (px2 - px1) * (xres-1.0) + 1.5 )
+> 	ny = int( (py2 - py1) * (yres-1.0) + 1.5 )
+81,90c71
+< 	nx = int( px2 * xres ) - int( px1 * xres ) + 1
+< 	ny = int( py2 * yres ) - int( py1 * yres ) + 1
+< 
+< 	if ( ny > 1)
+< 	     delta_y = (real(y2) - real(y1))/ny
+< 	else {
+< 	     delta_y = 0.
+< 	}
+< 
+< 	# If too many data points in input, set skip.  If skip is close
+---
+> 	# if too many data points in input, set skip.  If skip is close
+92,93c73,74
+< 	# Set block replication factors - will be > 1.0 if too few input points.
+< 	# Cannot set to 1.0 if "close" enough, since, if > 1.0, we don't have
+---
+> 	# set block replication factors - will be > 1.0 if too few input points.
+> 	# cannot set to 1.0 if "close" enough, since, if > 1.0, we don't have
+110c91,101
+< 	# Allocate storage for a row of pixels.  This is quite inefficient
+---
+> 
+> 	# try for the simplest case: 1:1 match with input data
+> 
+> 	if ( ca && (nx == nc) && (ny == nr) ) {
+> 	    call pixels( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
+> 		nx, ny, m)
+> 	    call sfree(sp)
+> 	    return
+> 	}
+> 
+> 	# allocate storage for a row of pixels.  This is quite inefficient
+113d103
+< 	# need nx+1 in case nx odd ... pixels() wants to pad output.
+115,116c105
+< 	call salloc ( cell, nx+1, TY_SHORT)
+< 	Mems[cell + nx] = 0
+---
+> 	call salloc ( cell, nx, TY_SHORT)
+118c107
+< 	# Initialize counters
+---
+> 	# initialize counters
+125c114
+< 	# See if we can use original data ... no massaging
+---
+> 	# see if we can use original data ... no massaging
+128c117
+< 	# Note that if blockx > 1.0, skip_x must be 1.0, and vv
+---
+> 	# note that if blockx > 1.0, skip_x must be 1.0, and vv
+138,152c127
+< 	# If device can pixel replicate, use that feature where we can
+< 	if( pr) {
+< 	    if( (skip_x == 1.0) && ( int(blockx) == blockx) ) {
+< 		 xrep = int(blockx)
+< 		 use_orig = true
+< 		 nx = nc
+< 	    } else
+< 		 xrep = 1
+< 	    if( (skip_y == 1.0) && ( int(blocky) == blocky) ) {
+< 		 yrep = int(blocky)
+< 		 ny = 1
+< 	    } else
+< 		 yrep = 1
+< 	}
+< 	call pixel0(1,0,xrep,0,1,yrep)
+---
+> 	# do it
+154c129
+< 	# Do it
+---
+> 	for (i = 1;  i <= ny;  i = i + 1) {
+156c131
+< 	for ( i = 1; i <= ny ; i = i + 1) {
+---
+> 	    # Build the row data.
+158,159d132
+< 	    # Build the row data
+< 
+161c134
+< 		if ( skip_x == 1.0) {
+---
+> 		if ( skip_x == 1.0)
+163c136
+< 		} else {
+---
+> 		else {
+181d153
+< 		y = y1 + ((i - 1)*delta_y + 0.5)
+183,184c155,159
+< 		        call pixels( px1, real(y)/GKI_MAXNDC,
+< 			    nx, 1, m[element])
+---
+> 		    if ( i == 1 )
+> 		        call pixelr( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
+> 			    nx, ny, m[element])
+> 		    else
+> 		        call pixeli( 0., 0., nx, 1, m[element])
+186c161,165
+< 		        call pixels( px1, real(y)/GKI_MAXNDC, nx, 1, Mems[cell])
+---
+> 		    if ( i == 1 )
+> 		        call pixelr( real(x1)/GKI_MAXNDC, real(y1)/GKI_MAXNDC,
+> 			    nx, ny, Mems[cell])
+> 		    else
+> 		        call pixeli( 0., 0., nx, 1, Mems[cell])
+188,189c167
+< 	    }   
+< 	    else
+---
+> 	    } else
+192c170
+< 	    # Advance a row
+---
+> 	    # Advance a row.
+206c184
+< 	# All done, restore text parameters and release storage
+---
+> 	# all done, restore text parameters and release storage
+209c187
+< 	    call restoretx (txsave,tx)
+---
+> 	    call restoretx(txsave,tx)
+212a191
+> 
+218d196
+< pointer savep, txp
+219a198
+> pointer savep, txp
+254a234
+> 
+258d237
+< pointer savep, txp
+259a239
+> pointer savep, txp
+263c243
+< 	# Restore values
+---
+> 	# restore values
+283a264
+> 
+287c268,269
+< procedure fakepc (indata, outdata, nx,  scale)
+---
+> procedure fakepc( indata, outdata, nx,  scale)
+> 
+298c280
+< data cdata /' ', '.', ':', '|', 'i', 'l', 'J', 'm', '#', 'S', 'B', EOS/
+---
+> data	cdata /' ', '.', ':', '|', 'i', 'l', 'J', 'm', '#', 'S', 'B', EOS/
+330,374d311
+< end
+< 
+< # ADJUST -- round/truncate putcell array corners to device coordinates
+< # move up lower bound if it is above center point of device cell,
+< # move down upper bound if below.  Don't allow bounds to go beyond
+< # resolution or below zero.  Do not allow bounds to cross.  Part of the
+< # assumptions behind all this is that putcells will be continguous and
+< # rows/columns must not be plotted twice.
+< 
+< procedure adjust ( lower, upper, res)
+< 
+< int	lower, upper
+< real	res
+< 
+< real	factor
+< real	low, up
+< 
+< begin
+< 	factor = res/(GKI_MAXNDC+1)
+< 	low = real(lower) * factor
+< 	up  = real(upper) * factor
+< 
+< 	# if boundaries result in same row, return
+< 	if ( int(low) == int(up) )
+< 	    return
+< 
+< 	# if low is in upper half of device pixel, round up
+< 	if ( (low - int(low)) >= 0.5 ) {
+< 	    low = int(low) + 1
+< 	    # don't go to or beyond upper bound
+< 	    if ( low < up ) {
+< 	        # ... 0.2 just for "rounding protection";
+< 		lower = (low + 0.2)/factor
+< 	        # if now reference same cell, return
+< 		if ( int(low) == int(up) )
+< 		    return
+< 	    }
+< 	}
+< 
+< 	# if "up" in bottom half of pixel, drop down one.  Note that
+< 	# due to two "==" tests above, upper will not drop below lower.
+< 	# 0.2 means drop partway down into pixel below; calling code will
+< 	# truncate.
+< 	if ( (up - int(up)) < 0.5 )
+< 	    upper = real(int(up) - 0.2)/factor
++ echo gktpl.x 
+gktpl.x
++ diff gktpl.x ../nsppkern.old/gktpl.x 
+51,52c51,52
+< 	x = p[1]
+< 	y = p[2]
+---
+> 	x = p[1] + g_xoff
+> 	y = p[2] + g_yoff
+58,59c58,59
+< 	    x = p[i]
+< 	    y = p[i+1]
+---
+> 	    x = p[i] + g_xoff
+> 	    y = p[i+1] + g_yoff
+gktpm.x
++ diff gktpm.x ../nsppkern.old/gktpm.x 
+48,49c48,49
+< 	x = p[1]
+< 	y = p[2]
+---
+> 	x = p[1] + g_xoff
+> 	y = p[2] + g_yoff
+63,64c63,64
+< 	    x = p[i]
+< 	    y = p[i+1]
+---
+> 	    x = p[i] + g_xoff
+> 	    y = p[i+1] + g_yoff
++ echo gktpmset.x 
+gkttx.x
++ diff gkttx.x ../nsppkern.old/gkttx.x 
+109,110c109,110
+< 		call pwrity (real(x)/GKI_MAXNDC,
+< 			real(y)/GKI_MAXNDC, Memc[pstring], seglen,
+---
+> 		call pwrity (real(x+g_xoff)/GKI_MAXNDC,
+> 			real(y+g_yoff)/GKI_MAXNDC, Memc[pstring], seglen,
+_____________________________________________________________________________
+
+25Apr85	gktpl.x
+	Call to optn to set line width changed to set option "inten" instead
+	of "spot size", which was not changing the line width.
+
+26Apr85 gktpm.x
+	Same change as one to gktpl.x
+
+	Character size as used in gkttx.x is a floating point number, but
+	NCAR pwry.f uses an integer value -- the conversion was causing
+	centering errors as gkttx.x would calculate a "path length" for
+	the text based on one size, and pwry.f would use a different size
+	to generate the text.  Changed pwry.f to use a floating point
+	size as an input variable, changed gkttx.x to send same.
+
+	gktpcell.x
+	Moved pixel0 call inside the "if (pr) {" statment, where it should
+	have been.
+
+	graphcap
+	Added  "pr" capablility flag to dicomed entry.  Changed character
+	height to reflect the 9 to 8 ratio that pwry uses.
+
+
+---------------------------------------------------------------------------
+Rev 1.2 10 May 1985 Dct.
+
+Fairly extensive modifications made to minimize the number of frame calls
+and metafiles generated.  Redundant CLEAR calls or clear calls immediately
+after open workstation are ignored.  Multiple frames are permitted in a
+metafile (formerly the metafile was disposed after each frame).  Graphcap
+parameters were added to control automatic frame advances at the beginning
+and end of metafiles.
+
+---------------------------------------------------------------------------
+Rev 1.3 1 June 1985 Dct.
+
+[1] Fixed a bug in polymarker; was drawing polylines.
+
+[2] Replaced the old character generation code by all new code, using the stroke
+table from the NCAR/GKS code.  Replaced "pwry.f" by the much simpler
+"gktdrawch.x".  Largely copied the stdgraph "stgtx.x", including the clipping
+logic therein.
+
+17-Aug-85 Dct.
+	Added support for the new DD graphcap parameter, used to pass device
+	dependent information to the device driver.  This information was
+	formerly encoded in a table at compile time, with the table defined
+	in <libc/kernel.h>.