32767	END
2	!EXTEND!								!
6	 !   EDIT DATE FOR SCREEN FUNCTIONS IS 23-Jun-79    .D.A.M.	       &
	!*******************************************************************   &
	!								       &
	!		Copyright (c) 1979				       &
	!		F.W.Woolworth Co.				       &
	!								       &
	!		Author:  Darrel A. Mazzari			       &
	!								       &
	!								       &
	!	The purpose of these routines is to simulate the	       &
	!	IBM 3277 screen functions for input and output.		       &
	!								       &
	!*******************************************************************   &
	!
50	DIM BF.3277%(1920%),  BF.ATTRIB%(100%), ORD.NEXT%(4%),		       &
			MOVE.CURS%(2%,4%), MOD.DATA%(550%)		       &
	!								       &
	!*******************************************************************   &
	!	An in core array of integers is used to store the display      &
	!	3277 screen because certain attributes must also be stored     &
	!	with the data and is used during read modified operations.     &
	!	The 3277 is a block mode, polled CRT.			       &
	!*******************************************************************   &
	!
51	BF.LINE.SZ%=550%	\  BF.PROT%=0%	\  MOD.DATA.SZ%=300%	       &
	   \  MOD.DATA%(0%)=MOD.DATA.SZ%   \	PT.PREVIOUS%=0%		\      &
						 BF.ATTRIB%(0%)=100%	       &
		\	RTA.ASCII% = ASCII("~")				       &
		\	SBA.ASCII% = ASCII("[")				       &
		\	EUA.ASCII% = ASCII(CHR$(18%))			       &
		\	PTB.ASCII% = ASCII(CHR$(5%))			       &
		\	CURS.ASCII% = ASCII(CHR$(19%))			       &
		\	SF.ASCII% = ASCII("]")				       &
		\	REV.FIELD$=""					       &
		\	MDT.ON$  =  "AEI(JNR)/VZ_159'"			       &
		\	MDT.OFF$ =  " DH<&MQ*-UY%048@"			       &
		\	MDT.ON2$ =  "CG.!LP$^TW,?37#"+'"' + MDT.ON$	       &
	!								       &
	!*******************************************************************   &
	!  SBA.ASCII% is set buffer address (X'11')			       &
	!  RTA.ASCII% is repeat to address  (X'7E')			       &
	!  EUA.ASCII% is erase unprotected to address (X'12')		       &
	!  PTB.ASCII% is program tab to next unprotected field (X'05')	       &
	!  CURS.ASCII% means set cursor address to buffer address (X'13') (^S) &
	!  SF.ASCII% means next character is an attribute byte		       &
	!  MDT.$ is the 7 bit of the EBCDIC character			       &
	!  REV.FIELD$ is a VT100 option					       &
	!								       &
	!								       &
	!	Refresh of the screen is accomplished by rewriting each	       &
	!	screen line that had at least one character modified in it.    &
	!	The line buffer must be more than 80 because it must also      &
	!	hold the VT100 attributes such as bolding (AVO only.)	       &
	!*******************************************************************   &
	!
52	FG%=256%  ! VT52  DEFAULT      =1024 *				       &
!
53									       &
	   BFY%=0% \BFX%=0% \CURSY%=0% \CURSX%=0% \BF.P%=1%		       &
	\	BF.REV.NONP$=""  \  BF.REV.NONP%=0%			       &
	\	BF.BOLD$=""	\					       &
		BF.CNG%=0%	\					       &
		NO.OUT%=0%	\					       &
		ESC.155$ = CHR$(155%)		\			       &
		ESC.ANSI$ = ESC.155$+"<"	\			       &
		ESC.VT52$ = ESC.155$+"[?2l"	\			       &
		ESC.EQ$ = CHR$(61%) + CHR$(27%)	\			       &
		ESC.PA1$ = "%" + ESC.EQ$	\			       &
		ESC.PA2$ = ">" + ESC.EQ$	\			       &
		ESC.PA3$ = "," + ESC.EQ$	\			       &
		MOVE.CURS%(1%,1%)=5%		\			       &
		MOVE.CURS%(1%,2%)=24%		\			       &
		MOVE.CURS%(1%,3%)=6%		\			       &
		MOVE.CURS%(1%,4%)=1%		\			       &
		MOVE.CURS%(2%,I%)=I%+64%  FOR I%=1% TO 4%		       &
	!								       &
	!*******************************************************************   &
	!	BF.REV.NONP$ is the non-display field shown reversed video     &
	!	BF.BOLD$ is the bold field indicator			       &
	!	BF.CNG% is the video change indicator to output vt100 attrib.  &
	!		(assuming FG%=256%+2048%)			       &
	!	IBMGO.BUF$ is one of the IBM input data buffers		       &
	!	The rest are various escape sequences.			       &
	!*******************************************************************   &
	!
113	PRINT ' 3277  with PF and PA keys  ... [PFxx]          V3'	       &

126	X=FNSCREEN.CLEAR						       &
	\	X=FNINIT.SCREEN.MODE  !INITALIZE CURSOR ADDRESS ARRAY	       &
									       &

9000	DEF* FNPOSXY(Y%,X%)						       &
 \		A$=CHR$(142%)+CHR$(78%)+CHR$(NOT X%)+CHR$(NOT Y%)	       &
			IF (FG% AND 1024%)				       &
 \		A$=CHR$(155%)+CHR$(91%)+NUM1$(Y%+1%)+CHR$(59%)+		       &
			NUM1$(X%+1%)+CHR$(72%) IF (FG% AND 512%)	       &
 \		A$=CHR$(155%)+CHR$(89%)+CHR$(32%+Y%)+CHR$(32%+X%)	       &
			IF (FG% AND 256%)				       &
 \		X=FNPRINT.1(A$)						       &
 \				FNEND					       &
	!*******************************************************************   &
	!	This function positions the cursor on the VT screen	       &
	!	at line Y% and column X%  (counting from zero)		       &
	!*******************************************************************   &
	!								       &

9001	!	FG%=256% IS VT52					       &
	!	FG%=256%+2048% IS VT100					       &
	!	FG%=512% IS						       &
	!	FG%=1024% IS DELTA DATA 5000				       &
	!
9010									       &
	DEF* FNHEX% (H$)		\					       &
			H1%=ASCII(H$)-48%  \				       &
			H2%=ASCII(MID(H$,2%,1%))-48% \			       &
		IF (H1%>16%)  THEN H1%=H1%-7%
9012		IF (H2%>16%)  THEN H2%=H2%-7%
9014			FNHEX% = H1%*16% + H2%  \			       &
	FNEND								       &
	!*******************************************************************   &
	!	This function converts the 2 digit ascii string		       &
	!	to the hexadecimal integer equivalent  eq. FF=255%	       &
	!*******************************************************************   &
	!								       &
	!
9020	DEF* FNINIT.SCREEN.MODE						       &
									       &
	\ X=FNP3277A							       &
	\ X=FNSCREEN.WIDTH(100%)					       &
	\ X$=SYS(CHR$(6%)+CHR$(16%)+CHR$(1%)+CHR$(255%)+		       &
		STRING$(13%,0%)+					       &
		CHR$(255%)+						       &
		STRING$(3%,0%)+						       &
		CHR$(255%)+						       &
		CHR$(128%+13%) )					       &
	\ X$=SYS(CHR$(6%)+CHR$(16%)+CHR$(1%)+CHR$(255%)+		       &
		CHR$(0%) + CHR$(128%) )    IF (FG%=(256%+2048%))	\      &
		PRINT #1%,ESC.155$+"=";					\      &
	FNEND								       &
	!*******************************************************************   &
		!INITIALIZE						       &
		! WIDTH 100						       &
		! NO UPARROW						       &
		! DELIMITER CR						       &
		! ESC SEQ						       &
		! TAB  if VT100						       &
		! Alternate keypad mode					       &
	!*******************************************************************   &
									       &

9030									       &
	DEF* FNP3277A		\					       &
		DIM CURHEX%(126%), CURHEX$(64%), PF$(24%,2%),PA$(3%)	\      &
		CURHEX%(I%)=0%  FOR I%=1% TO 126%	\		       &
		READ CURHEX$(I%)  FOR I%=1% TO 64%	\		       &
		READ PF$(I%,1%)   FOR I%=1% TO 24%	\		       &
		READ PA$(I%)  FOR I%=1% TO 3%	\			       &
		READ PF$(I%,2%)   FOR I%=1% TO 24%	\		       &
		CURHEX%(FNHEX%(CURHEX$(I%)))=I%  FOR I%=1% TO 64%	\      &
	FNEND								       &

9031!	DATA   20,41,42,43,44,45,46,47,48,49,5B,2E,3C,28,2B,21,26,4A,4B
9032	DATA 20,41,42,43,44,45,46,47,48,49,7B,2E,3C,28,2B,7C,26,4A,4B
9033!	DATA 4C,4D,4E,4F,50,51,52,5D,24,2A,29,3B,5E,2D,2F,53,54,55,56
9034	DATA 4C,4D,4E,4F,50,51,52,21,24,2A,29,3B,5E,2D,2F,53,54,55,56
9035!	DATA 57,58,59,5A,7C,2C,25,5F,3E,3F,30,31,32,33,34,35,36,37,38
9036	DATA 57,58,59,5A,7D,2C,25,5F,3E,3F,30,31,32,33,34,35,36,37,38
9037	DATA 39,3A,23,40,27,3D,22
9038	DATA 1,2,3,4,5,6,7,8,9,:,#,"@",A,B,C,D,E,F,G,H,I,"{",".","<"
9039	DATA "%",">",","
9040	DATA P,Q,R,"w","x","y","t","u","v","q","r","s","p","n",M
9041	DATA "l","m",X,X,X,X,X,X,S
9043									       &
	!*******************************************************************   &
	!	This function initializes the IBM cursor address array	       &
	!	for quick and easy conversion.  The 3277 uses a 2 character    &
	!	cursor address representing the character (buffer) position    &
	!	of the entire screen memory. (what you see is what you have.)  &
	!	There is no coordinate location, just absolute.		       &
	!*******************************************************************   &
	!								       &
	!
9045									       &
	DEF* FNP3277 (P$)		\				       &
									       &
				PY%=CURHEX%(ASCII(P$)) \		       &
			PX%=CURHEX%(ASCII(MID(P$,2%,1%)))  \		       &
	  X%=FNK3277%((PY%-1%)*64% + PX%-1%)	\			       &
			PYH%=PY% \ PXH%=PX% \				       &
	FNEND								       &

9046	DEF* FNQ3277 (P$)						       &
		\ X=FNP3277(P$)						       &
		\ BF.P%=FNL3277%(FNBPOSXY%(PYH%,PXH%))			       &
	\ FNEND								       &
									       &

9047	DEF* FNK3277% (BUFFADD%)						       &
	\	  IF (BUFFADD%<0%)  THEN	PY%,PX%=0%		       &
		ELSE   	PY%=((BUFFADD%)/80%)				       &
	\		PX%= BUFFADD% - PY%*80%
9048	FNEND								       &
									       &

9049	DEF* FNL3277% (BPADD%)						       &
	\		X%=FNK3277%(BPADD%-1%) \ BFY%=PY% \ BFX%=PX%	       &
	\	FNL3277% = BPADD%					       &
	\ FNEND								       &
	!								       &
	!*******************************************************************   &
	!	These functions return the DEC VT52/100 coordinates	       &
	!	(PY%=line,PX%=column --counting from zero) given	       &
	!	the 3277 buffer address as a 2 hex character string.	       &
	!	(which is how it comes from IBM)			       &
	!*******************************************************************   &
	!								       &
	!
9050									       &
	DEF* FNJ3277$ (CSY%,CSX%)			\		       &
		LOC% = 80%*CSY% + CSX%		\			       &
		PJY% = LOC%/64%			\			       &
		PJX% = LOC% - PJY%*64%		\			       &
    FNJ3277$=CHR$(FNHEX%(CURHEX$(PJY%+1%)))+CHR$(FNHEX%(CURHEX$(PJX%+1%)))\    &
									       &
	FNEND								       &
	!*******************************************************************   &
	!	This function in the inverse of FNP3277.  It returns the 2     &
	!	character string (hex) address for the 3277 given the	       &
	!	x,y vt52 location.					       &
	!*******************************************************************   &
	!								       &
	!								       &

9060	DEF* FNSCREEN.CLEAR						       &
 \		A$=CHR$(142%)+CHR$(82%) IF (FG% AND 1024%)		       &
 \		A$=CHR$(155%)+CHR$(91%)+CHR$(155%)+CHR$(91%)+		       &
			CHR$(50%)+CHR$(74%) IF (FG% AND 512%)		       &
 \		A$=CHR$(155%)+CHR$(72%)+CHR$(155%)+CHR$(74%)		       &
			IF (FG% AND 256%)				       &
 \		X=FNPRINT.1(A$)						       &
 \		X=FNPOSXY(CURSY%,CURSX%)				       &
 \	FNEND								       &
	!*******************************************************************   &
	!	This function clears the screen of the local crt	       &
	!	as determined by the type code FG%.  It then repositions       &
	!	the cursor on the screen at the stored cursor location.	       &
	!*******************************************************************   &
	!								       &
	!								       &

9065		X=FNSCREEN.WIDTH(80%)	\				       &
	X$=SYS(CHR$(6%)+CHR$(16%)+CHR$(1%)+CHR$(255%)+			       &
		STRING$(13%,0%)+					       &
		CHR$(128%)+						       &
		STRING$(3%,0%)+						       &
		CHR$(128%)+						       &
		CHR$(128%) )						       &
		\							       &
				PRINT #1%,ESC.155$+">";		\	       &
		X=FNSCREEN.CLEAR				\	       &
	RETURN								       &
	!*******************************************************************   &
		!  TURN SCREEN BACK					       &
		!  WIDTH 80						       &
		! NO DELIMITER						       &
		! NO ESC SEQ						       &
		! No Alternate keypad					       &
		! Clear screen						       &
	!*******************************************************************   &

9070									       &
	DEF* FNSCREEN.WIDTH (WDD%)					       &
									       &
	\	X$=SYS(CHR$(6%)+CHR$(16%)+CHR$(1%)+CHR$(255%)+		       &
			CHR$(WDD%+1%))					       &
	\	FNEND							       &
	!*******************************************************************   &
	!		This function changes the RSTS tty width	       &
	!		setting the WDD%				       &
	!*******************************************************************   &
	!								       &
	!								       &
	!								       &
	!								       &
									       &
									       &
10200									       &
	MOD.OFFSET%=1%	\						       &
	SCAN%=1%	\  MOVE%=1%  ! WAS	MOVE%=0%		       &
	!								       &
	!*******************************************************************   &
	!******************************************************		       &
	! SUBROUTINE to process the IBM data for the 3278		       &
	!******************************************************		       &
	!*******************************************************************   &
	!								       &
	!		(input analyzer)				       &
	!								       &
	!
10203		X=FNSCREEN.WIDTH(100%)					       &
	!*******************************************************************   &
	!				set width wider than screen	       &
	!				to prevent wrap-around scrolling       &
	!*******************************************************************   &
	!
10205	INDATA.BUF$=RIGHT(INDATA$,4%)					       &
		\	WRITE.COM% = INSTR(1%,"?5",MID(INDATA$,2%,1%))	       &
		\   IF  (WRITE.COM%=0%)  GOTO 10210			       &
		      ELSE						       &
				BF.P%=1%	\ BFY%=0% \ BFX%=0%	       &
		\	IF (WRITE.COM%=2%)  THEN			       &
				BF.3277%(I%)=8192%	IF (BF.3277%(I%)<>0%)  &
					  FOR I%=1% TO 1920%		       &
			  ELSE						       &
				X%=FNERASE.UNP.TO.ADDRESS%(23%,79%)	       &
		\		BF.P%=1%	\ BFY%=0% \ BFX%=0%	       &

10207		IF (INSTR(1%,MDT.ON2$,WCC$)<>0%)  THEN X%=FNRESET.MDT%	       &
	!								       &
	!*******************************************************************   &
	!				the first three characters are not     &
	!				needed (AID,write,WCC) (except write)  &
	!*******************************************************************   &
	!								       &
									       &

10210	BF.P% =FNBPOSXY%(BFY%,BFX%)	! GET BACK TO BUFFER ADDRESS	       &
					!
10214!  10213 is reserved						       &

10220	GOTO 10520     IF (INDATA.BUF$ == "")				       &
		\ MOD.BUF$ =  LEFT(INDATA.BUF$,MOD.DATA.SZ%)		       &
		\ 	IF (LEN(MOD.BUF$)>5%)  THEN			       &
				 MOD.END% = LEN(MOD.BUF$) - 5%		       &
			  ELSE	 MOD.END% = LEN(MOD.BUF$)
10221		  CHANGE MOD.BUF$ TO MOD.DATA%				       &
		\ INDATA.BUF$=RIGHT(INDATA.BUF$,MOD.END%+1%)		       &
		\ MOD.DATA%(0%)=MOD.DATA.SZ%				       &
		\ LAST.ORDER%=0%					       &
		\ MOD.IN%=MOD.OFFSET%	\	MOD.OFFSET%=1%		       &

10222	MOD.DAT%=MOD.DATA%(MOD.IN%)					       &
		\	GOTO 10230	IF (MOD.DAT%=RTA.ASCII%)	       &
		\	GOTO 10240	IF (MOD.DAT%=SBA.ASCII%)	       &
		\	GOTO 10250	IF (MOD.DAT%=EUA.ASCII%)	       &
		\	GOTO 10260	IF (MOD.DAT%=PTB.ASCII%)	       &
		\	GOTO 10270	IF (MOD.DAT%=CURS.ASCII%)	       &
		\	GOTO 10280	IF (MOD.DAT%=SF.ASCII%)		       &
		\	LAST.ORDER%=0%					       &
	\	  IF							       &
		    (BF.3277%(BF.P%)<>MOD.DAT%)  THEN			       &
			BF.3277%(FNBFINC%)=MOD.DAT% +8192%		       &
		   ELSE							       &
			X%=FNBFINC%					       &
	!								       &
	!*******************************************************************   &
	!		look for 3277 device order...			       &
	!								       &
	!  SBA.ASCII% is set buffer address (X'11')			       &
	!  RTA.ASCII% is repeat to address  (X'7E')			       &
	!  EUA.ASCII% is erase unprotected to address (X'12')		       &
	!  PTB.ASCII% is program tab to next unprotected field (X'05')	       &
	!  CURS.ASCII% means set cursor address to buffer address (X'13') (^S) &
	!  SF.ASCII% means next character is an attribute byte		       &
	!*******************************************************************   &
	!								       &
	!								       &

10225	MOD.IN%=MOD.IN% + 1%						       &
	\			IF (MOD.IN%>MOD.END%)   GOTO 10220	       &
				  ELSE  GOTO 10222			       &
									       &

10227	DEF* FNMOD.ADDR$							       &
			\ FNMOD.ADDR$ =					       &
				CHR$(MOD.DATA%(MOD.IN%+1%)) +		       &
				CHR$(MOD.DATA%(MOD.IN%+2%))		       &
	\ FNEND								       &
	!*******************************************************************   &
			!  decode the 3277 address			       &
	!*******************************************************************   &
									       &
									       &

10230	!*******************************************************************   &
	!	Repeat to address ....					       &
	!*******************************************************************
10231									       &
		X  =  FNP3277(FNMOD.ADDR$)				       &
	\	X% =  FNL3277%(BF.P%)					       &
						! decode the address	       &

10234									       &
	IF ((PYH%<BFY%) OR ((PYH%=BFY%) AND (PXH%<=BFX%)))  THEN	       &
		X%=FNREPEAT.TO.ADDRESS%(23%,79%)	\		       &
		BF.P%=1%  \  BFY%=0%  \ BFX%=0%				       &

10235									       &
	X% = FNREPEAT.TO.ADDRESS% (PYH%,PXH%)				       &

10237		LAST.ORDER%=1%
10238				MOD.IN%=MOD.IN%+3%			       &
			\	GOTO 10290				       &
									       &
									       &

10240	!*******************************************************************   &
	! Set buffer address order					       &
	!*******************************************************************   &

10242		X=FNQ3277 (FNMOD.ADDR$)					       &
	\	LAST.ORDER%=2%						       &
	\	MOD.IN%=MOD.IN%+2%					       &
	\	GOTO 10290						       &
									       &

10250	!*******************************************************************   &
	!		EUA   erase unprotected to address		       &
	!*******************************************************************   &

10252		X  =  FNP3277(FNMOD.ADDR$)				       &
	\	X% =  FNL3277%(BF.P%)					       &
	!						decode 3277 address    &
	!					and set attributes	       &

10254									       &
	IF ((PYH%<BFY%) OR ((PYH%=BFY%) AND (PXH%<=BFX%)))  THEN	       &
		X%=FNERASE.UNP.TO.ADDRESS%(23%,79%)	\		       &
		BF.P%=1%  \  BFY%=0%  \ BFX%=0%				       &

10255									       &
	X% = FNERASE.UNP.TO.ADDRESS% (PYH%,PXH%)			       &

10257		LAST.ORDER%=3%
10258				GOTO 10238				       &
									       &
									       &

10260	!*******************************************************************   &
	!	Program tab function					       &
	!*******************************************************************   &
									       &

10264	    IF (LAST.ORDER%<>0%)  THEN					       &
			PT.ZERO%=1%  ELSE  PT.ZERO%=0%			       &
		!							       &
	!*******************************************************************   &
		! should we zero (null) the present field if we		       &
		! are at the start of one or not?			       &
		! We do if the PTB does not immediately follow a	       &
		! control command,order, or order sequence such as a	       &
		! WCC,IC, or RA (3-character sequence)			       &
	!*******************************************************************   &
		!							       &

10266		X% = FNPROGRAM.TAB%(PT.ZERO%)				       &

10267			LAST.ORDER%=4%
10268					GOTO 10225			       &
									       &
									       &

10270	!*******************************************************************   &
	! Set 3277 cursor address to 3277 buffer address		       &
	!*******************************************************************   &

10272		    X% = FNCURSOR.TO.BP%				       &
		 		\ GOTO 10225				       &
									       &
									       &

10280	!*******************************************************************   &
	!	Set field						       &
	!*******************************************************************   &

10282	MOD.IN%=MOD.IN%+1%						       &
	\	MOD.DAT%=MOD.DATA%(MOD.IN%)+9216%			       &
	\		IF (BF.3277%(BF.P%)<>MOD.DAT%)  THEN		       &
					BF.3277%(FNBFINC%)=MOD.DAT%	       &
			 ELSE	X%=FNBFINC%				       &
						! attribute character	       &
									       &
									       &

10290	  IF (MOD.IN%<MOD.END%)  GOTO 10225				       &
		ELSE							       &
			MOD.OFFSET% = MOD.IN% - MOD.END% + 1%		       &
		\ GOTO 10220						       &
									       &
									       &
									       &
									       &

10500	!*******************************************************************   &
	!		Done... let's update the VT screen		       &
	!*******************************************************************
10520									       &
		X = FNBF.REFRESH					       &
					! UPDATE CHANGE CHAR.		       &

10528!  10529 is reserved						       &

10530			X=FNPOSXY(3%,79%)				       &
	\		PRINT #1%					       &
	\		X=FNPOSXY(CURSY%,79%)				       &
	\		PRINT #1%, STRING$(80%,32%);			       &
	\		PRINT #1%, STRING$(79%-CURSX%,8%);  IF CURSX%<79%      &
	!								       &
	!*******************************************************************   &
	!	fake out the RSTS column counter because we use direct	       &
	!	cursor addressing					       &
	!*******************************************************************   &
	!								       &
									       &

10535	X=FNPOSXY(CURSY%,CURSX%)					       &
	!*******************************************************************   &
	!				get cursor back to correct position    &
	!				on screen			       &
	!*******************************************************************   &
	!								       &

10540	X=FNSCREEN.WIDTH(80%)	! return to RSTS width 80 for input wrap       &

10550	X% = FNCHECK.ECHO%(1%)	! turn off echo if at the beginning of a       &
				! non-display field			       &

10599									       &
		RETURN							       &
									       &
	! ********************************************************	       &
	!*******************************************************************   &
	!*******************************************************************   &
	!								       &
									       &
10600									       &
	!*******************************************************************   &
	!*******************************************************************   &
	! PA AND PF KEYS  and other KB input analysis			       &
	!*******************************************************************   &
	!*******************************************************************   &
	!								       &
	!
10602	IF (NO.OUT%<>1%)  THEN IBMGO.BUF$=""
10603		 NO.OUT%=0%	\	AID$ = "'"	! ENTER is the default &
									       &

10610!
10620	IF (LEFT(IBMGO$,3%)="[PF")  THEN				       &
		RBRK%=INSTR(4%,IBMGO$,"]")  \				       &
	  IF (RBRK%=0%)  THEN GOTO 10630  ELSE				       &
		IBMGO$=PF$(VAL(MID(IBMGO$,4%,RBRK%-4%)),1%)		       &
			\	NO.OUT%=2%				       &
			\	GOTO 10690				       &
	!*******************************************************************   &
							! This is the alter-   &
							! PF entry  [PFxx]     &
	!*******************************************************************   &

10630	IF (LEFT(IBMGO$,3%)="[PA")  THEN				       &
		RBRK%=INSTR(4%,IBMGO$,"]")  \				       &
	  IF (RBRK%=0%)  THEN GOTO 10635  ELSE				       &
		IBMGO$=PA$(VAL(MID(IBMGO$,4%,RBRK%-4%)))		       &
			\	NO.OUT%=1%				       &
			\	GOTO 10690				       &
	!*******************************************************************   &
							! Alternate PA entry.  &
							! Short read.	       &
	!*******************************************************************   &
									       &

10635	IF ((LEFT(IBMGO$,1%)<>CHR$(9%)) AND				       &
		(LEFT(IBMGO$,2%)<>"-"+CHR$(9%)))   GOTO 10640		       &
	!*******************************************************************   &
				!  check for tab			       &
	!*******************************************************************   &
				!					       &
	! found one...
10637		NO.OUT%=1%						       &
	\	BF.PH% = BF.P%						       &
	\	BF.P% = FNBPOSXY%(CURSY%,CURSX%)			       &
	\   IF (INSTR(1%,LEFT(IBMGO$,3%),"-")=0%)  THEN			       &
		X%=FNPROGRAM.TAB%(1%)					       &
	  ELSE	X%=FNBACK.TAB%
10638		X%=FNCURSOR.TO.BP%					       &
	\	BF.P% = BF.PH%						       &
	\	IBMGO$=""						       &
	\	GOTO 10660						       &
	!*******************************************************************   &
	!			tab to the next unprotected field	       &
	!			and set the cursor. Ignore any other	       &
	!			text on that input because it is against       &
	!			the rules. (one tab only at a time)	       &
	!*******************************************************************   &
	!								       &

10640	IF (INSTR(1%,IBMGO$,"[]")<>0%)  THEN				       &
		IBMGO$="_"						       &
	\	 IBMCT%=1%						       &
	\	CURSY%=0%  \  CURSX%=0%					       &
	\  X=FNSCREEN.CLEAR						       &
	\	BFX%=0% \  BFY%=0%					       &
	\	BF.3277%(BF.P%) = 0%    FOR BF.P%=1% TO 1920%		       &
	\	BF.P%=1%						       &
	\	IBMGO.TEXT$=""						       &
	\	NO.OUT%=1%						       &
	\ GOTO 10690							       &
	!*******************************************************************   &
	!		Clear the screen and memory buffer and send	       &
	!		clear screen to IBM				       &
	!*******************************************************************   &
	!								       &

10645		IF (INSTR(1%,IBMGO$,ESC.PA1$) +				       &
		    INSTR(1%,IBMGO$,ESC.PA2$) +				       &
		    INSTR(1%,IBMGO$,ESC.PA3$)   <>  0%)			       &
		THEN							       &
		    IBMGO$ = LEFT(CVT$$(IBMGO$,255%),1%)	\	       &
			NO.OUT%=1%	\				       &
		    GOTO 10690						       &
	!*******************************************************************   &
	!		Check for PA keying				       &
	!*******************************************************************   &
	!								       &

10647			ALEFT.EUP.FRIGHT.XDOWN% = ASCII(MID(IBMGO$,1%,1%))     &
	\	FOR I%=1% TO 4%						       &
	\	 IF (ALEFT.EUP.FRIGHT.XDOWN%=MOVE.CURS%(1%,I%))  THEN	       &
			NO.OUT%=1%					       &
	\		IBMGO$=""					       &
	\		ESC.CHR%=MOVE.CURS%(2%,I%)			       &
	\		GOTO 10652
10648		NEXT I%							       &
	!*******************************************************************   &
	!		This is the alternate arrow keying.		       &
	!			1.) Cntl/E is up			       &
	!			2.) Cntl/A is left			       &
	!			3.) Cntl/F is right			       &
	!			4.) Cntl/X is down			       &
	!*******************************************************************   &
	!								       &
									       &
									       &

10650									       &
			ESC.POS% = INSTR(1%,IBMGO$,CHR$(155%))		\      &
		IF (ESC.POS% = 0%)   THEN GOTO 10690			       &
	ELSE								       &
			ESC.CHR%=ASCII(MID(IBMGO$,ESC.POS%-1%,1%))	\      &
			IBMGO.BUF$ =					       &
			 FNFILL.IBMGO$(LEFT(IBMGO$,			       &
				INSTR(1%,IBMGO$,CHR$(128%))-1%))	\      &
			GOTO 10637  IF (INSTR(1%,IBMGO$,CHR$(9%))<>0%)	\      &
			NO.OUT%=1%					\      &
			IBMGO$ =  ""					       &
	!*******************************************************************   &
	!			Check for the escape sequences		       &
	!*******************************************************************   &
	!								       &
									       &

10652		IF (ESC.CHR% <> 65%)  THEN   GOTO 10654
10653			CURSY%=CURSY%-1%				       &
		\ CURSY% = 23%  IF CURSY% < 0%				       &
		\ GOTO 10660				! up  ^		       &

10654		IF (ESC.CHR% <> 66%)  THEN  GOTO 10656			       &
		ELSE X=FNY.BUMP  \  GOTO 10660
10655  	DEF* FNY.BUMP	\	CURSY%=CURSY%+1%			       &
		\ CURSY% = 0%   IF CURSY% > 23%				       &
		\ FNEND					! down   v	       &

10656		IF (ESC.CHR% <> 67%)  THEN  GOTO 10658			       &
		ELSE  X=FNX.BUMP  \  GOTO 10660
10657	DEF* FNX.BUMP	\	CURSX%=CURSX%+1%	\		       &
		  X=FNY.BUMP   IF CURSX% > 79%	\			       &
		  CURSX% = 0%  IF CURSX% > 79%	\			       &
		FNEND					! right  >	       &
									       &

10658		IF (ESC.CHR% = 68%)  THEN				       &
			CURSX%=CURSX%-1%	\			       &
		   IF (CURSX% > -1%)   THEN	GOTO 10660		       &
		    ELSE   CURSX% = 79%    \    GOTO 10653	! left   <     &

10659		ESC.CH$ = CHR$(ESC.CHR%)  			\	       &
		GOTO 10637   IF (ESC.CH$="M")			\	       &
		IBMGO$ = ESC.CH$				\	       &
	FOR PFI%=1% TO 24%					\	       &
	   IBMGO$ = PF$(PFI%,1%)   IF (ESC.CH$=PF$(PFI%,2%))	\	       &
	NEXT PFI%						\	       &
			NO.OUT%=2%				\	       &
			GOTO 10690		! PF key.		       &

10660	!								       &
	!	10661 is reserved for my3278				       &
									       &

10662		X  = FNPOSXY(CURSY%,CURSX%)				       &
	\	X% = FNCHECK.ECHO%(0%)		!  MOVE CURSOR ON SCREEN       &

10690		IF  (NO.OUT%=0%)  THEN IBMGO$ = "'"+FNJ3277$(CURSY%,CURSX%)+   &
					RIGHT(FNFILL.IBMGO$(IBMGO$),4%)	       &
			ELSE   IF (NO.OUT%=1%)  GOTO 10695		       &
			 ELSE   IF (NO.OUT%=2%)  THEN			       &
					AID$ = IBMGO$			       &
				\	IBMGO$ = IBMGO.BUF$		       &
		!							       &
	!*******************************************************************   &
		!	Build up the output record in case it would be needed  &
		!	Set the AID character (PF or enter)		       &
	!*******************************************************************   &
		!							       &

10692	IBMGO$ = LEFT(FNREAD.MODIFIED$(IBMGO$,AID$),256%)		       &
	!*******************************************************************   &
					!	Fill in the rest of the	       &
					! modified field as though it were     &
					! just entered ***		       &
	!*******************************************************************
10695	RETURN								       &
			! Go back and output......			       &
	!*******************************************************************   &
	! *********************************************			       &
			!						       &
									       &
									       &

10697	DEF* FNFILL.IBMGO$ (IBMGO.INTEXT$)				       &
		\	IBMGO.TEXT$= CVT$$(IBMGO.INTEXT$,5%)		       &
		\FNFILL.IBMGO$ = IBMGO.BUF$ + FNCAD$(IBMGO.TEXT$)	       &
		\	IBMGO.TEXT.LENGTH% =  LEN(IBMGO.TEXT$)		       &
		\  IF               (IBMGO.TEXT.LENGTH% > 0%)  THEN	       &
			BF.P% =FNBPOSXY%(CURSY%,CURSX%) 		\      &
			X=FNBF.FILL(IBMGO.TEXT$)			       &
	!	\	X=FNX.BUMP  FOR X%=1% TO IBMGO.TEXT.LENGTH%	       &

10698	FNEND								       &
	!*******************************************************************   &
			! This fills in the in core screen buffer with the     &
			! new input data.				       &
	!*******************************************************************   &
	!								       &
									       &
									       &
									       &

10700									       &
	DEF* FNREPEAT.TO.ADDRESS% (TOY%,TOX%)				       &

10710	RTA.CHR% = MOD.DATA%(MOD.IN% +3%)	\			       &
	RTA.CHR.8192% = RTA.CHR%+8192%		\			       &
									       &
		FOR IX%=1% TO						       &
		   80%-BFX%  + (TOY%-BFY%-1%)*80%  + TOX%		       &
									       &
	\	  IF (BF.3277%(BF.P%)<>RTA.CHR%) THEN			       &
	  BF.3277%(FNBFINC%)=RTA.CHR.8192%				       &
				ELSE X%=FNBFINC%
10711		NEXT IX%						       &

10713 !		BFY%=TOY%	\	BFX%=TOX%
10715	FNEND								       &
	!*******************************************************************   &
			! This function loads the in core buffer from the      &
			! current address to DEC TOY%,TOX% with RTA.CHR$       &
	!*******************************************************************   &
			!						       &
									       &

10720	DEF* FNBFINC%							       &
			\  FNBFINC%=BF.P%				       &
			\	BF.P%=BF.P%+1%				       &
			\	BF.P%=1%  IF BF.P%>1920%		       &
			\	X%=FNL3277%(BF.P%)			       &
		\ FNEND							       &

10725	DEF* FNBDECR%							       &
			\ FNBDECR%=BF.P%				       &
			\	BF.P%=BF.P%-1%				       &
			\	BF.P%=1920%   IF BF.P%=0%		       &
			\	X%=FNL3277%(BF.P%)			       &
		\ FNEND							       &
	!*******************************************************************   &
					! These functions increment and	       &
					! decrement the buffer pointer	       &
	!*******************************************************************   &
					!				       &

10730									       &
	DEF* FNBF.FILL (BF.DATA$)					       &
	\	BF.XDATA$ = BF.DATA$+""					       &
	\	GOTO 10737  IF (LEN(BF.XDATA$)=0%)			       &
	\	ATTR.IND%=0%						       &
	\   FOR  BF.P0% = 1% TO LEN(BF.XDATA$)				       &
	\    BF.CHR$ = MID(BF.XDATA$,BF.P0%,1%)				       &
	\	IF ((BF.CHR$="]") AND (ATTR.IND%<>1%))	 THEN	ATTR.IND%=1%   &
	\							GOTO 10736     &

10731	     BF.CHR% = ASCII(BF.CHR$)					       &
	\	BF3277%=BF.3277%(BF.P%)					       &
	\	 IF (ATTR.IND%=0%) THEN					       &
	    BF.CHR% = BF.CHR% + 8192%	IF (BF3277%<>BF.CHR%)		       &
		 ELSE    BF.CHR% = BF.CHR% + 9216%			       &
	\		ATTR.IND%=0%					       &

10733	   ON.ATTR% = FNPROT.ATTR%(BF3277%)				       &
	\  IF (ON.ATTR% <= 0%)   GOTO 10734    ELSE			       &
						    X% = FNBFINC%	       &
	\					    X% = FNPROGRAM.TAB%(1%)    &
	\	IF (ON.ATTR%<9%)  THEN					       &
	X=FNPRINT.1( ESC.ANSI$ + ESC.155$+"[2q"+ESC.VT52$)  IF (FG%=VT100%)    &
	!								       &
	!*******************************************************************   &
		!  turn on LED 2 for  INPUT ERROR (ON PROT FIELD)	       &
		!  or tab to next unprotected field			       &
	!*******************************************************************   &
		!							       &
									       &

10734		IF ((BF.CHR%<>8211%) AND ((BF.3277%(BF.P%) AND 1024%)=0%))     &
		  THEN							       &
		     BF.3277%(FNBFINC%) = BF.CHR%			       &
		  ELSE							       &
		     X% = FNBFINC%					       &
		\    GOTO 10734						       &
					! can not type on attribute	       &
									       &

10736			X% = FNCURSOR.TO.BP%				\      &
	   NEXT BF.P0%							       &

10737	 FNEND								       &
	!								       &
	!*******************************************************************   &
		!	This function put the string BF.DATA$ in the in core   &
		!	3277 integer array buffer and updates pointers.	       &
		!	8192 is added to character to indicate new refresh.    &
	!*******************************************************************   &
		!							       &
		!							       &

10738	DEF* FNPROT.ATTR% (TEST.CH%)					       &
		\  TEST.CHR% = TEST.CH% AND 8191%			       &
		\  OT.ATTR% = INSTR(1%,"-/UVYZ%_014589@'",		       &
						CHR$(TEST.CHR%-1024%))	       &
		\  OT.ATTR% = 0%    IF (TEST.CHR%<1024%)		       &
		\ FNPROT.ATTR% = OT.ATTR%				       &
	\ FNEND								       &
	!*******************************************************************   &
	!		see if this attribute character means protected field  &
	!*******************************************************************   &
	!								       &
	!								       &

10740									       &
	DEF* FNBF.REFRESH						       &
	\		BF.REV.NONP$="" \ BF.REV.NONP%=0%		       &
	\		BF.BOLD$=""					       &
	\	BF.LP%=-1%						       &
	\	BF.CNG%=0%
10741	BF.3277%(1920%)=0%	! PREVENT SCROLLING			       &
	!*******************************************************************   &
	!	bit 1024% means a 3277 attribute byte			       &
	!	bit 8192% means this is new data that has not		       &
	!	been refreshed on the VT screen				       &
	!*******************************************************************   &
	!
10742	  FOR IBF% = 0% TO 1919% STEP 80%				       &

10743		BF.OUT%=0% \ BF.LP%=BF.LP%+1%				       &
	\	LBF1%=1%						       &
	\	GOTO 10745						       &

10744			BF.OUT%=1%   ! This line has to go out...	       &

10745	   		FOR LBF%=1% TO 80%				       &

10746	BF.LIN% = BF.3277%(IBF%+LBF%)					       &
	\	IF ((BF.LIN% AND 8192%)<>0%)  THEN			       &
			GOTO 10744  IF (BF.OUT%=0%)			       &
		\	BF.LIN%=BF.LIN%-8192%				       &
		\	BF.3277%(IBF%+LBF%)=BF.LIN%			       &
		\	GOTO 10748					       &

10747	IF (BF.OUT%=0%)  GOTO 10750					       &

10748		BF.ATTRIB$=""						       &
	\	BF.ATTRIB$ = FNATTRIB$    IF (BF.LIN% AND 1024%)	       &
	\	BF.LIN%=32%    IF (BF.LIN%=0%) OR ((BF.LIN% AND 1024%)<>0%)    &
					OR (BF.REV.NONP%=1%)		       &
	\	MOD.DATA%(LBF1%) = BF.LIN%				       &
	\	LBF1%=LBF1%+1%						       &
	\    IF  ((BF.ATTRIB$<>"") AND (FG% AND 2048%))   THEN		       &
			CHANGE BF.ATTRIB$ TO BF.ATTRIB%			       &
	\	FOR LBF2%=1% TO LEN(BF.ATTRIB$)				       &
	\		MOD.DATA%(LBF1%)=BF.ATTRIB%(LBF2%)		       &
	\		LBF1%=LBF1%+1%					       &
	\	NEXT LBF2%						       &

10750	NEXT LBF%							       &
									       &

10754		IF (BF.OUT%>0%)  THEN					       &
			X=FNPOSXY(BF.LP%,0%)				       &
	\		MOD.DATA%(0%) = LBF1% -1%			       &
	\		CHANGE MOD.DATA% TO A$				       &
	\		X=FNPRINT.1(CVT$$(A$,4%))			       &
	!								       &
	!*******************************************************************   &
	!	put out the line of refresh				       &
	!*******************************************************************   &
	!								       &

10757	NEXT IBF%
10759			FNEND						       &
	!*******************************************************************   &
	!				This function updates the DEC screen   &
	!				with newly received data from IBM      &
	!*******************************************************************   &
	!								       &

10760	DEF* FNPRINT.1(X$)						       &
	\	FIELD #1%, LEN(X$) AS A1$				       &
	\	LSET A1$=X$						       &
	\	PUT #1%, COUNT LEN(X$)					       &
	\	FNEND							       &
	!*******************************************************************   &
	!				This is a PRINT function using PUT's   &
	!*******************************************************************   &
	!								       &

10770	DEF*  FNBPOSXY%(BBFY%,BBFX%)					       &
		 \FNBPOSXY% = (BBFY%)*80%+BBFX%+1%  \ FNEND		       &

10780	DEF* FNCAD$(DATT$)						       &
	\		FNCAD$ = "[" + FNJ3277$(CURSY%,CURSX%) + DATT$	       &
	\	FNEND							       &

10790	DEF* FNATTRIB$							       &
	\		BF.CNG%=0%					       &
	\		ATTR$=""					       &
	\  X1%=FNREV.VID% (INSTR(1%,"<(*)%_@'",CHR$(BF.LIN% AND 1023%)))       &
	\  X2%=FNBOLD.VID%(INSTR(1%,"HIQRYZ89",CHR$(BF.LIN% AND 1023%)))       &
	\	ATTR$= ESC.ANSI$          +ESC.155$+"[0"+		       &
			BF.REV.NONP$+BF.BOLD$				       &
						+"m"+ ESC.VT52$		       &
				IF (BF.CNG%<>0%)			       &
	\	FNATTRIB$=ATTR$						       &
	\ FNEND								       &

10810	DEF* FNREV.VID%(BITF1%)						       &
	\			IF (BITF1%<>0%)  THEN			       &
			IF (BF.REV.NONP%=0%)  THEN			       &
		BF.REV.NONP$=REV.FIELD$ \  BF.REV.NONP%=1% \	BF.CNG%=1%     &
	!	BF.REV.NONP$=";7"\	BF.CNG%=1%			       &

10812				IF (BITF1%=0%)  THEN			       &
			IF (BF.REV.NONP%=1%)  THEN			       &
		BF.REV.NONP$=""    	\  BF.REV.NONP%=0% \	BF.CNG%=1%     &

10819		FNREV.VID% = BITF1%					       &
	\ FNEND								       &

10820	DEF* FNBOLD.VID%(BITF2%)						       &
	\			IF (BITF2%<>0%)  THEN			       &
			IF (BF.BOLD$="")  THEN				       &
		BF.BOLD$=";1"\	BF.CNG%=1%				       &

10822				IF (BITF2%=0%)  THEN			       &
			IF (BF.BOLD$<>"")  THEN				       &
		BF.BOLD$=""	\	BF.CNG%=1%			       &

10829		FNBOLD.VID% = BITF2%					       &
	\ FNEND								       &
									       &

10830	DEF* FNCHECK.ECHO% (CHK.DIST%)					       &
	\			ATT.NOW% = FNBPOSXY%(CURSY%,CURSX%)-1%	       &
	\			ATT.TO% = 1%				       &
	\			ATT.TO% = ATT.NOW%   IF (CHK.DIST%=0%)	       &
	\	FOR ATT.PT% = ATT.NOW% TO ATT.TO%  STEP -1%		       &
	\		ATTR.ECHO% = BF.3277%(ATT.PT%)			       &
	\	GOTO 10834  IF  (ATTR.ECHO%<1024%)			       &
	\    IF (INSTR(1%, "<(*)%_@'",					       &
				CHR$(ATTR.ECHO%-1024%) ) <> 0%)  THEN	       &
			X$=SYS(CHR$(3%)+CHR$(1%))			       &
		ELSE 	X$=SYS(CHR$(2%)+CHR$(1%))
10832				GOTO 10838
10834		NEXT ATT.PT%
10838	FNEND								       &
	!*******************************************************************   &
	!						turn echo off or on    &
	!					depending upon type of field   &
	!*******************************************************************   &
	!								       &

10850									       &
	DEF* FNERASE.UNP.TO.ADDRESS% (TOY%,TOX%)				       &
			!						       &
	!*******************************************************************   &
			! store nulls in all unprotected field locations       &
			! to address TOY%,TOX%				       &
	!*******************************************************************   &

10852		FOR  IX% = 1%  TO					       &
				   80%-BFX%  + (TOY%-BFY%-1%)*80%  + TOX%
10853									       &
		BF.PROT% = FNPROT.ATTR%(BF.3277%(BF.P%))		       &
	\   IF (BF.PROT%=0%)	THEN					       &
		  BF.3277%(FNBFINC%) = 8192%    IF (BF.3277%(BF.P%)<>0%)       &
				ELSE  X%=FNBFINC%
10854		NEXT IX%
10856 !				BFY%=TOY%	\	BFX%=TOX%
10858	FNEND								       &
									       &
									       &
									       &
									       &

10870	DEF* FNPROGRAM.TAB% (PT.NO.ERAS%)				       &
						\    PT.NO.ERASE%=PT.NO.ERAS%  &
						\    BF.PROT%=-1%
10872	  IF ((BF.3277%(BF.P%) AND 1024%)<>0%)  THEN			       &
			BF.PROT% = FNPROT.ATTR%(BF.3277%(FNBFINC%))	       &
		ELSE	X% = FNBFINC%   IF (PT.NO.ERASE%=1%)		       &

10873	    IF ((BF.PROT%=0%) AND (PT.NO.ERASE%=1%))  THEN  GOTO 10879	       &
	     ELSE							       &
			GOTO 10874  IF (PT.NO.ERASE%=1%)		       &
					OR  ((BF.3277%(BF.P%) AND 1024%)>0%)   &
		\	BF.3277%(FNBFINC%) =  8192%  UNTIL		       &
				(((BF.3277%(BF.P%) AND 1024%)<>0%) OR	       &
								(BF.P%=1%))    &
		\	IF (BF.P%=1%) THEN  	GOTO 10879		       &

10874		PT.NO.ERASE%=1%						       &

10876	  IF ((BF.PROT%<>0%) AND (BF.P%<>1%))   THEN GOTO 10872		       &

10879	FNEND								       &
	!*******************************************************************   &
		! This function is the forward tab to the next unprotected     &
		! field.						       &
		! should we zero (null) the present field if we		       &
		! are at the start of one or not?			       &
		! We do if the PTB does not immediately follow a	       &
		! control command,order, or order sequence such as a	       &
		! WCC,IC, or RA (3-character sequence)			       &
	!*******************************************************************   &
		!							       &
									       &
									       &

10880	DEF* FNBACK.TAB%							       &
		\	X%=FNBDECR%  UNTIL ((BF.3277%(BF.P%) AND 1024%)>0%)    &
		\	X%=FNBDECR%					       &
	!*******************************************************************   &
		!		find beginning of current field		       &
	!*******************************************************************   &

10882	  IF ((BF.3277%(FNBDECR%) AND 1024%)=0%)  THEN  GOTO 10882	       &
		ELSE							       &
			X%=FNBFINC%					       &
		\	BF.PROT% = FNPROT.ATTR%(BF.3277%(BF.P%))	       &
		\  IF	(BF.PROT%=0%) THEN				       &
				X%=FNBFINC%				       &
			ELSE	X%=FNBDECR%	\	GOTO 10882	       &

10889	FNEND								       &
	!*******************************************************************   &
			! This is a special back tab function.		       &
			!  It locates the buffer			       &
			! pointer at the previous unprotected field.	       &
	!*******************************************************************   &
			!						       &
									       &

10890	DEF* FNCURSOR.TO.BP%						       &
	\	X%=FNK3277%(BF.P%-1%)					       &
	\	CURSY%=PY%						       &
	\	CURSX%=PX%						       &
	\ FNEND								       &
	!*******************************************************************   &
	!		Point the cursor to the current buffer pointer	       &
	!*******************************************************************   &
	!								       &
									       &

10900	DEF* FNREAD.MODIFIED$ (OLD.DATA$,AID.CH$)			       &

10902		   MOD.F%=0% \ BF.AT.1%=0%				       &
				\ MOD.DATA$ = AID.CH$+FNJ3277$(CURSY%,CURSX%)  &

10904		FOR BF.RM%=1% TO 1920%
10906			BF3277% = BF.3277%(BF.RM%)			       &
	\	   IF ((BF3277% AND 1024%)=0%) THEN			       &
		 MOD.F%=1%	IF ((BF3277% AND 8192%)<>0%)		       &
			ELSE						       &
				ATT.X$=CHR$(BF3277% AND 255%)		       &
			     \	GOSUB 10925
10910		NEXT BF.RM%						       &

10912			IF ((MOD.F%=0%)  AND  (BF.AT.1%<>0%))   GOTO 10919     &
				ELSE					       &
					BF.RM%=1921%			       &
			\		MOD.F% = 1%	IF (BF.AT.1%=0%)       &
			\		ATT.X$ = LEFT(MDT.OFF$,1%)	       &
			\		GOSUB 10925			       &
			\		GOTO 10919			       &
									       &

10918 !			MOD.DATA$=OLD.DATA$	IF (BF.AT.1%=0%)	       &

10919		FNREAD.MODIFIED$ = CVT$$(MOD.DATA$,5%)			       &
	\ FNEND								       &
	!*******************************************************************   &
			! This is THE read modified code to allow us	       &
			! to simulate a block mode terminal like the 3278      &
	!*******************************************************************   &
			!						       &
									       &
									       &
									       &
									       &
									       &
									       &

10925	   IF (MOD.F%=0%) THEN GOTO 10926				       &
	    ELSE							       &
		X%=FNK3277%(BF.AT.1% )					       &
	\	GOTO 10926	IF ((BF.RM%-BF.AT.1%) < 2%)		       &
	\  MOD.DATA$ = MOD.DATA$ + "[" + FNJ3277$(PY%,PX%)		       &
						IF (BF.AT.1%<>0%)	       &
	\	INDX% = 1%						       &
	\  MOD.DATA%(FNINC%(MOD.DATA.SZ%)) = BF.3277%(BF.MOD%) AND 255%	       &
				FOR BF.MOD%=BF.AT.1%+1% TO BF.RM%-1%	       &
	\  MOD.DATA%(0%) = INDX% -1%					       &
	\  MOD.F%=0%							       &
	\	CHANGE MOD.DATA% TO MOD.DATA.TMP$			       &
	\  MOD.DATA$ = MOD.DATA$ +  MOD.DATA.TMP$			       &

10926	 MOD.F%=1%   IF (INSTR(1%,MDT.ON$,ATT.X$)<>0%)  \		       &
				BF.AT.1%=BF.RM%				       &
	\		RETURN						       &
	!*******************************************************************   &
				! This subroutine extracts a field from	       &
				! the in core screen buffer.		       &
	!*******************************************************************   &
									       &
									       &
									       &

10930	DEF* FNINC% (MAX.INDX%)						       &
		\	FNINC% =  INDX%					       &
		\		INDX%=INDX% + 1%    IF (INDX% < MAX.INDX%)     &
	\ FNEND								       &
	!*******************************************************************   &
		! This is an auto index function for loops		       &
	!*******************************************************************   &
		!							       &
									       &
									       &

10940	DEF* FNRESET.MDT%						       &
	\		FOR BF.MDT% = 1% TO 1920%			       &
	\			ATT.X% = BF.3277%(BF.MDT%)		       &
	\		   IF (ATT.X% AND 1024%)  THEN			       &
			ATT.MDT% = INSTR(1%,MDT.ON$,CHR$(ATT.X% AND 255%))     &
	\	BF.3277%(BF.MDT%) = ASCII(MID(MDT.OFF$,ATT.MDT%,1%)) + 1024%   &
					IF (ATT.MDT%<>0%)
10942			NEXT BF.MDT%					       &
	\ FNEND								       &
				! This function resets the Modified Data Tag   &
				! (MDT) bits of the attribute bytes set on     &
				! the input data stream from IBM.	       &
									       &
									       &
									       &
									       &

32767	END