Google
 

Trailing-Edge - PDP-10 Archives - bb-j939f-bm - bliss/six12.b36
Click bliss/six12.b36 to see without markup as text/plain
There are 6 other files named six12.b36 in the archive. Click here to see a list.
MODULE SIX36( IDENT='2-17', ADDRESSING_MODE(NOINDIRECT),
    %TITLE %STRING('Bliss-36 Language Debugger TOPS-',	! 
		    %IF %SWITCHES(TOPS10) %THEN '10 I/O' %ELSE '20 I/O' %FI)
%IF %VARIANT EQL 10
%THEN
	    LINKAGE(BLISS10), ENVIRONMENT(BLISS10_OTS)
%ELSE
	    LINKAGE(BLISS36C), ENVIRONMENT(BLISS36C_OTS)
%FI,
		NODEBUG, ENTRY(SIX36,SIX12,SIXXEQ))=
BEGIN
!
! Copyright (C) 1981, 1982, 1983, 1984
! Digital Equipment Corporation,  Maynard, Massachusetts  01754
!
! This software is furnished under a license for use only on  a
! single computer system and may be copied only with the inclu-
! sion of the above copyright notice.  This  software,  or  any
! other  copies  thereof, may not be provided or otherwise made
! available to any other person except for use on  such  system
! and  to  one who agrees to these license terms.  Title to and
! ownership of the software shall at all times remain in DEC.
!
! The information in this software is subject to change without
! notice and should not be construed as a commitment by Digital
! Equipment Corporation.
!
! DEC assumes no responsibility for the use or  reliability  of
! its software on equipment which is not supplied by DEC.
!
!
!
! MODULE DESCRIPTION
!
!	This module implements SIX36, the BLISS-36 debugger.  Considerable
!	credit is due to
!
!		CMU	- Weinstock, Wulf, Lane and Johnsson; for the
!				Debugging Control Module, 1974
!
!		DEC	- Ghanta, Lupton, et al; Enhancements in B10 support
!			- Brender, R.; Initial work for supporting B36 and the
!				TOPS-10/-20 support.
!
!		CMU	- Newcomer, J.; Considerable enhancements, particularly
!				SIGNAL|UNWIND support, qualified symbols and
!				all sorts of other goodies.
!
!
! REVISION HISTORY
!
!	30-Mar-81	AL	Translated from B10 with CVT10.  Major surgery
!				removing junk, attempting to rationally format
!				and comment. [Its own mother wouldn't recognize
!				it now!]
!
!	9-Apr-81	AL	Beginning to approach working code.  Most B10
!				and B36C stuff has been removed
!
!	9-Jul-81	AL	Fix problem with GETNAMEOP involving ^-6.  The
!				^ operator in B36 is signed, not so with B10!
!
!	13-Jul-81	AL	Added /VARIANT control for Bliss-10 Linkages
!
!       24-Jul-81       AL      Fix problems with TOPS-10 ideas about byte
!                               pointers vs. address.
!
!	14-Aug-81	AL	Work on fixing behavior of RETURN command and
!				faking a "call-frame" in CALLEM and UUOH.
!
!       1-Sep-81        AL      TOPS-10 problem in TTOUTC routine.  Also fixed
!				to avoid looking for HISEG symbol-table when
!				running with TOPS-20.
!
!	15-Oct-81	AL	n%A notation was bombing out due to wrong
!				frame being passed to GETARGCNT from
!				GETARGADR
!
!	26-Oct-81	AL	PRCALL incorrectly determined ID of condition
!				being signalled.
!
!	16-Nov-81	AL	Remove references to .EXT.0 and insert dummy
!				".BREG" as a new module at tail of this module.
!
!	22-Dec-81	AL	Make "@" issue "RESERVED for FUTURE use" msg.
!
!       28-Dec-81       AL      Dynamic mapping of DDT broken, as MJSYS wasn't
!                               used to define GET or SEVEC.
!
!	 8-Jun-82	TT	Move Maps to routine headers where possible.
!
!	18-Jun-82	AL	Implement support for extended addressing.
!
!	30-Jun-82	AL	Found out what "BGOBASE" does.
!
!
! END V3.1 BUG FIXES
!
! BLISS V4 DEVELOPMENT
!
!       22-Jul-82       AL      For TOPS-10, we must define $ARxxx symbols
!                               locally.
!
!	25-Jul-83	TT	Merge Bugs line into Main line.
!
!	13-Sep-83	LD	$JBxxx becomes EXTERNAL for TOPS-10
!				since it is now part of UUOSYM.
!
!	 9-Jan-84	MEA	UUOH was smashing AC2 and AC4 while doing Load
!				 Byte and Deposit Byte for field references.
!				 Fix is to save/restore those registers in OWN's
!				 when necessary.
!
!	 2-Feb-84	MEA	Fix to change of 9-Jan-84.  For BLISS-10 version
!				 of SIX12, AC1 is used instead of AC2.
!
! END OF REVISION HISTORY
!--
LITERAL
    EXTENDED = %VARIANT EQL 30,	! 30-bit addressing?
    TOPS10 = %SWITCHES(TOPS10),
    TOPS20 = %SWITCHES(TOPS20),

%IF EXTENDED
%THEN
    AddrMask = %O'37777777'
%ELSE
    AddrMask = %O'0777777'
%FI;

BIND VERSION = UPLIT (%ASCIZ 'V8-7') 	:VECTOR;

MACRO
    S1036(X,Y) = %IF %VARIANT EQL 10 %THEN X %ELSE Y %FI %,

    NPREGS=	%IF %VARIANT EQL 10
		%THEN
		    1,3,4,5,6,7,8,9,10
		%ELSE
		    2,3,4,5
		%FI %,

    PRREGS=	%IF %VARIANT EQL 10
		%THEN
		    11,12,13,14,15
		%ELSE
		    0,6,7,8,9,10,11,12,14
		%FI %;


GLOBAL BIND
    SREG	= S1036( 0,%o'17'),	! Default SP for B36 linkages
    FREG	= S1036( 2,%o'15'),	! Default FP
    VREG	= S1036( 3,%o'1');	! Default value-return register

LITERAL
    TRUE = 1,
    FALSE = 0,
    SIXUNW = %O'7170',		! Random number used to signal a POP

    SLOWDELETE=0;		! 1 to purge symbols, 0 to clobber them
				! Must be 0 until some detailed fixing of
				! the code is done; currently the purge
				! code is commented out

! These Binds control size of problem
! -----------------------------------

LITERAL
    BGOBASE=20,			! I haven't the foggiest notion what this
				! does! -jmn 6-Jan-81
				! Ans:
				!	It controls the number of DEBUG UUOs
				!	executed before checking for typeahead.

    BUFFERSIZE= CH$ALLOCATION(132),	! Size of input buffer in words
    EXTRAOPS= 20,		! Number of permitted user-defined
				!  operators
    LEVELS=10,			! Maximum nesting depth of SIX12 calls
    MONITCNT=50,		! Number of locations we can MONITOR/WATCH
    NMACROS=500,
    OPSIZE=5,			! Size of the dispatch op table entry
    ROUTSCNT=50,		! Number of routines we can attach actions
				!  to
    ROUTSIZE=5,			! Size of the routine-action table
    SCRATCHSIZE=20,		! Size of SIXPAT area
    STACKSIZE=50;		! Maximum depth of parse stack


LITERAL					! Useful initial values
    BIGNUMBER = %O'377777777777',	! Biggest positive number
    IWDBASE = %O'1000';			! Initial offset of WDBase

BUILTIN
    FIRSTONE,
    LSH,
    POINT,
    REPLACEN,
    SCANN,
    MACHOP,
    MACHSKIP,
    UUO,
    ROT;

MACRO				    ! Random useful machine opcodes we need
    AOS[] = MACHSKIP(%O'350', %REMAINING) %,
    BLT[] = MACHOP(%O'251', %REMAINING) %,
    EXCH[] = MACHOP(%O'250', %REMAINING) %,
    JRST[] = MACHOP(%O'254', %REMAINING) %,
    IBP[] =	MACHOP(%o'133', 0, %REMAINING) %,
    MUL[] = MACHOP(%O'224', %REMAINING) %,
    POP[] = MACHOP(%O'262', %REMAINING) %,
    POPJ[] = MACHOP(%O'263', %REMAINING) %,
    PUSH[] = MACHOP(%O'261', %REMAINING) %,
    XCT[] = MACHOP(%O'256', %REMAINING) %;

LITERAL			    ! These are values of machops which we need as
			    ! literals
    ADDOP=%O'270',
    ADJSPOP= %O'105',
    CAIOP=%O'300',
    JFCLOP=%O'255',
    JRSTOP=%O'254',
    JSPOP = %O'265',
    POPJOP = %O'263',
    PUSHJOP = %O'260',
    PUSHOP = %O'261',
    SUBOP=	%O'274';

%IF TOPS10
%THEN
LIBRARY 'BLI:UUOSYM';


UNDECLARE
    %QUOTE CLOSE,
    %QUOTE ENTER,
    %QUOTE IN,
    %QUOTE INBUF,
    %QUOTE INPUT,
    %QUOTE LOOKUP,
    %QUOTE OPEN,
    %QUOTE OUT,
    %QUOTE OUTBUF,
    %QUOTE RESET,
    %QUOTE SETUWP,
    %QUOTE STATO,
    %QUOTE STATZ,
    %QUOTE SKPINL,
    %QUOTE WHERE,
    %QUOTE OUTCHR,
    %QUOTE INCHRS,
    %QUOTE OUTSTR,
    %QUOTE INCHWL,
    %QUOTE INCHSL,
    %QUOTE GETLCH,
    %QUOTE SETLCH,
    %QUOTE SKPINC;


MACRO
    CALLI[] = MACHOP(%O'47', %REMAINING) %,
    CLOSE[] = MACHSKIP(%O'70', %REMAINING) %,
    ENTER[] = MACHSKIP(%O'77', %REMAINING) %,
    IN[] = MACHSKIP(%O'56', %REMAINING) %,
    INBUF[] = MACHOP(%O'64', %REMAINING) %,
    LOOKUP[] = MACHSKIP(%O'76', %REMAINING) %,
    OPEN[]   = MACHSKIP(%O'50', %REMAINING) %,
    OUT[] = MACHSKIP(%O'57', %REMAINING) %,
    OUTBUF[] = MACHSKIP(%O'65', %REMAINING) %,
    RELEASE[]= MACHSKIP(%O'71', %REMAINING) %,
    SETUWP(A)=  MACHSKIP(%O'47', A, %O'36') %,
    STATO[] =  MACHSKIP(%O'61', %REMAINING) %,
    STATZ[] =  MACHSKIP(%O'63', %REMAINING) %,
    TTCALL[] = MACHOP(%O'51', %REMAINING) %,
    SKPINL(D) = MACHSKIP(%O'51',%o'14') %,
    OUTCHR[] = TTCALL(1, %REMAINING) %,
    INCHRS[] = TTCALL(2, %REMAINING) %,
    OUTSTR[] = TTCALL(3, %REMAINING) %,
    INCHWL(D) = TTCALL(4, D) %,
    INCHSL(D) = MACHSKIP(%O'51',5,D) %,
    GETLCH[] = TTCALL(6, %REMAINING) %,
    SETLCH[] = TTCALL(7, %REMAINING) %,
    SKPINC(D) = MACHSKIP(%O'51',%o'13',D) %;

LITERAL
       $AROPC   = 0,
       $ARPFL   = 1,
       $AREFA   = 2,
       $ARNPC   = 3;

EXTERNAL

	$JBDA,
	$JBDDT,			! DDT start address
	$JBFF :  VOLATILE,	! Start of free storage
	$JBHRL,			! Vestigial (hiseg) .JBREL
	$JBREL,			! Physical end of lowseg
	$JBSYM,			! Pointer to DDT symbol table
	$JBUSY			! Undefined symbol chain
%IF NOT EXTENDED
%THEN
	,$JBOPC,		! Old PC
	$JB41,			! UUO location
	$JBUUO			! Location where last UUO was stored
%FI
	    ;
%FI

%IF TOPS20
%THEN
LIBRARY 'BLI:MONSYM';

MACRO
    MJSYS(NAME,SKIPCNT,INREG,OUTREG)=
	%ASSIGN(JSYSNO,NAME)
	UNDECLARE NAME;

	LINKAGE %NAME('L_',NAME) = JSYS (
		%IF NOT %NULL(INREG) %THEN RPLIST( %REMOVE(INREG) ) %FI
		%IF NOT %NULL(OUTREG) %THEN ; RPLIST( %REMOVE(OUTREG) ) %FI
			)
		:SKIP(SKIPCNT);

	BIND ROUTINE NAME = JSYSNO: %NAME('L_',NAME); %,

    RPLIST(A)[] = REGISTER=A %IF %LENGTH GTR 1 %THEN ,RPLIST(%REMAINING) %FI %;


COMPILETIME
    JSYSNO=0;

!   JSYS Name  Skips	Inputs		Outputs
!
MJSYS(  AIC, 	0,	(1,2),			)	! activate specific software interrupt channels
MJSYS(  ATI,	0,	(1),			)	! assign terminal code CTRL/CHARACTER
MJSYS(	BIN,	-1,	(1),		(2)	)	! Byte IN
MJSYS(	BKJFN,	1,	(1),		(1)	)	! BacK up source JFN
MJSYS(	BOUT,	0,	(1,2),			)
MJSYS(	CHFDB,	-1,	(1,2,3),		)	! change file block
MJSYS(	CLOSF,	1,	(1),		(1)	)
MJSYS(	CRLNM,	1,	(1,2,3),	(1)	)	!Create logical name
MJSYS(  DELDF,  -1,     (1,2),		  )       ! Expunge deleted files
MJSYS(	DELNF,	1,	(1,2),		(1,2)	)	!Delete given number of versions
MJSYS(  DIC,	0,	(1,2),			)	! deactivates a specified interrupt channel
MJSYS(	DIRST,	1,	(1,2),		(1)	)	!Get user directory name
MJSYS(	DISMS,	0,	(1),			)	!Dismiss process for specified time
MJSYS(	DVCHR,	0,	(1),		(1,2,3)	)
MJSYS(  EIR,	0,	(1),			)	! enable software interrupt system
MJSYS(	ERSTR,	2,	(1,2,3),		)	!Translate error code
MJSYS(  GET,    -1,     (1,2),                  )       !Map image into process
MJSYS(	GETER,	-1,	(1),		(2)	)	!Get error code
MJSYS(	GETJI,	1,	(1,2,3),		)	!Get job information
MJSYS(	GEVEC,	0,	(1),		(2)	)	!Get Entry Vector
MJSYS(	GNJFN,	1,	(1),		(1)	)	!Get next JFN in group
MJSYS(	GTAD,	0,	,		(1)	)	!Get date, time in internal form
MJSYS(	GTJFN,	1,	(1,2),		(1)	)
MJSYS(	GTFDB,	-1,	(1,2,3),		)
MJSYS(	HALTF,	0,	,			)	!Exit to monitor
MJSYS(  IDTIM,  1,      (1,2),	  (1,2)   )       !translate text into interal date-time format
MJSYS(	JFNS,	0,	(1,2,3,4),	(1)	)
MJSYS(	LNMST,	1,	(1,2,3),	(1,3)	)	!Translate logical name
MJSYS(	ODTIM,	0,	(1,2,3),	(1)	)	!Get date and time
MJSYS(	OPENF,	1,	(1,2),		(1)	)
MJSYS(	PBOUT,	0,	(1),			)
MJSYS(	PSOUT,	0,	(1),		(1)	)
MJSYS(	RCDIR,	-1,	(1,2,3),	(1,2,3)	)	!Get directory info
MJSYS(	RDTTY,	1,	(1,2,3),	(1,2)	)	!Read from primary input
MJSYS(	RESET,	0,	,			)	! Init current process
MJSYS(	RFMOD,	0,	(1),		(2)	)
MJSYS(  RLJFN,  1,      (1),	    (1)     )       ! Release JFN
MJSYS(	RPACS,	0,	(1),		(2)	)	! Page Accessibility
MJSYS(	RSCAN,	1,	(1),			)	!get string from rescan buffer
MJSYS(	RUNTM,	0,	(1),		(1,2,3)	)
MJSYS(  SEVEC,  -1,     (1,2),                  )
MJSYS(	SFMOD,	0,	(1,2),			)
MJSYS(	SFPTR,	1,	(1,2),		(1)	)
MJSYS(	SIBE,	1,	(1),		(2)	)	! Skip if input empty
MJSYS(	SIN,	-1,	(1,2,3,4),	(1,2,3)	)
MJSYS(  SIR,	0,	(1,2),			)	! set channel and priority table addresses
MJSYS(	SOUT,	0,	(1,2,3,4),	(1,2,3)	)
MJSYS(	SPACS,	0,	(1,2),			)	! Set page accessability
MJSYS(	SWTRP_, 0,	(1,2,3),		)	! Software Trap Set

MJSYS(	TEXTI,	1,	(1),		(1)	)
MJSYS(	TIME,	0,	,		(1,2)	)

UNDECLARE
    JSYSNO,
    %QUOTE MJSYS,
    %QUOTE RPLIST;

MACRO
    JBDEF[N]=	EXTERNAL %NAME('.',N); BIND %NAME('$',N)=%NAME('.',N); %;

JBDEF(			! Conspicuous by their absence: .JBHGH, .JBHSM, .HIGH.

	JBDA,
	JBDDT,			! DDT start address
	JBFF,			! Start of free storage
	JBHRL,			! Vestigial (hiseg) .JBREL
	JBREL,			! Physical end of lowseg
	JBSYM,			! Pointer to DDT symbol table
	JBUSY			! Undefined symbol chain
%IF NOT EXTENDED
%THEN
	,JBOPC,			! Old PC
	JB41,			! UUO location
	JBUUO			! Location where last UUO was stored
%FI
	);

MAP
    $JBFF	: VOLATILE;
%FI

EXTERNAL
	%NAME('EFPNT.'),	! BLISS Enable Frame pointer
	%NAME('SIGND.');	! Marks end of condition-handling code in OTS

EXTERNAL ROUTINE
	%NAME('SIGST.'),
	%NAME('SIGNA.');

BIND
    EFPNT$	= %NAME('EFPNT.'),
    SIGND$	= %NAME('SIGND.');

BIND ROUTINE
    SIGST$	= %NAME('SIGST.'),
    SIGNA$	= %NAME('SIGNA.');
! Storage Declarations
! --------------------

GLOBAL
    SIXPAT:	VECTOR[SCRATCHSIZE+1],		! PATCH AREA
    SIXHDR,			! User parameter printer handler
    SIXRP	: REF VECTOR,	! Pointer to right operand vector
    SIXLP	: REF VECTOR,	! Pointer to left operand vector
    SIXVP	: REF VECTOR,	! Pointer to value-return vector
    SIXRC,			! Count of right operands
    SIXLC,			! Count of left operands
    SIXVC,			! Count of values returned
    SIXREF,			! Means "use ref-structure" if true
    SIXVREG,			! User readable/writable VREG value
    SIXCH,	! LG change	! Communicates with SIXLG interface in LG support
    SIXSTK,			! Initial stack pointer value
    SIXACS:	VECTOR[16];	! Saved acs when calling DDT


BIND
    SIXUNWSIGNAL = SIXUNW,	! random number---signals a POP
    CHAR = SIXCH;		! LG change

GLOBAL BIND
	SIXSP = SREG;		! Stack pointer register number

EXTERNAL LITERAL		! Refers to globals defined in inner block.
				! In this way, they may be changed at Link time
    SIXLSF,			! Delete SIX12 local symbols flag value
    SIXSTF,			! Initial start flag value
    SIXENF,			! Initial enable flag value
    SIXPOL;			! Initial polling flag value


OWN
    STARTFLAG:	INITIAL(SIXSTF),	! This must be the VERY FIRST own!
    ENABFLAG:	INITIAL(SIXENF),	!on/off	! This must be the VERY SECOND own!
    NOPOLLFLAG:	INITIAL(SIXPOL),	! This must be the VERY THIRD own!
    COPQFLAG,				!on/off	! This must be the VERY FOURTH own

!----------------------
!	Remaining own variables in alphabetical order

%IF EXTENDED
%THEN
    $JBOPC,					! Dummy .JBOPC to reenter SIX12
    $JBUUO,					! Dummy holding copy of LUUO
    $JB41,					! Dummy holding LUUO dispatch
%FI

    BUFF:	VECTOR[BUFFERSIZE],		! Input buffer for text line
    DBGSTK:	VECTOR[STACKSIZE],		! Parse/evaluation stack
    DCNT,					! Controls DEBUG. sampling rate
						!  for type-ahead.
    DEFOPTAB:	VECTOR[OPSIZE*EXTRAOPS],	! User defined operator table
    DEPTH,					! Current nesting depth for n& prompt
    DISKIFLAG,			!on/off	! Disk character input flag (RECALL)
    DISKOFLAG,			!on/off	! Disk character output flag (STORE)
    DSKHDR:	VECTOR[3],		! Buffer header for disk (TOPS-10)
    ENTERPNT,				! Saved FP at entry to SIX12
    ENTERSP,				! Saved SP relative to ENTERPNT
    ERRORFLAG,			!on/off	! Error seen during evaluation
    ERRORPARM,				! Used to pass information to Error(n)
    GOFLAG,				! Controls resumption after command
					! 0 => no prompt, get more commands
					! 1 => resume processing
					! 2 => prompt, get more commands
    GQUALIFIER,				! global (default) name qualifier
    HCACHE:	INITIAL(0),		! cache of hiseg symbols
    HIGH:	INITIAL(0),		! value of .HIGH. if found
    HQUALIFIER,				! symbol table (.?.JBSYM or 
					! .(?.JBHGH+?.JBHSM)) in which
					! Qualifier is defined
    HSYM,				! Condition of highseg symbols:
					!   0 - unknown
					!   1 - must recompute hiseg symbol table
					!  
    INSIXHDR,				! Used to detect and ignore recursive
					! call on SIX12 caused by calling the
					! routine defined in SIXHDR
    IOBASE,				! base for number conversion
    IJOBSYM:	INITIAL(0),		! initial .JBSYM
    IJOBHSM:	INITIAL(0),		! initial .JBHSM
    ILLMEM,				! Value which caused ill mem ref
    JOBHGH:	INITIAL(0),		! value of .JBHGH, if found
    LGCHAR,				! LG change
    LPTBUF:	VECTOR[%O'203'],	! Output buffer for LPT output
    LPTFLAG,				! Line printer output flag
					! >0 => LPTDUP
					! =0 => no LPT
					! <0 => LPTON
    LPTHDR:	VECTOR[3],		! Header for line printer buffer chain
    LPTOPENFLAG,		!on/off	! Line print file open flag
    MODEFLAG,				! Used to aid parsing of multiword
					! operators, e.g., TRACE AFTER
    NCHAR,
    NEWOPS,				! Number of new operators via SIXOP or
					! DEFINE
    NNAMES,
    NPCHAR,
    NROUTS,				! Index of last entry in debug interest
					! table (ROUTS)
    NVALS,				! Index of last entry in MONITOR table
    OPQCNT,				! Tracks number of OPAQUEs
    OUTERSIGNAL:	VECTOR[4],	! Signal frame for outermost handler (B36 only)
    PCHAR:	VECTOR[LEVELS],		! Current character being scanned
    PARSEDEBUG,				
    PTEXT,				
    QUOTFLG,				! Should next symbol be evaluated or
					!  delivered as radix50?
    REPORTED,				! Indicates trace output has already
					!  occurred, additional printout not
					!  required
    RTNLVL,				! Routine POSITION:
					! 1 => AT Routine EXIT,
					! 0 => AT Routine ENTRY,
					! -1 => OTHERWISE.

    SAWCR,			! Indicates parser saw CR on this line
    SAWEOF,			! EOF on disk input during RECALL
    SIXTOG,
    STEPFLAG,				! true if in single-step mode
    SWT		: BLOCK[$ARNPC+1],	! Data-block for LUUO fault data
    TEXTAREA:	VECTOR[2*NMACROS],	! Allowing avg. 9 chars/Macro; Change routine 'GetText' if changed
    TOPOP,
    TOPSTK,				! index of top of evaluation stack
    TRACEFLAG,				! global tracing is enabled
    TRCCNT,
    UNWINDVALUE:	INITIAL(0),	! The value of SS$UNW, obtained from DDT symbol table
    VTEMP,
    WDBASE:	INITIAL(IWDBASE),	! Maximum offset for symbolic printout
    WHACKING,				! doing simultaneous UNWIND with Whacking
    WHACKS;				! number of SIX12 incarnations to Whack off


GLOBAL BIND
	SIXSTA = STARTFLAG,
	SIXENB = ENABFLAG,
	SIXNPL = NOPOLLFLAG;
! Macro Table Entry Format
! ------------------------

!   +-----------------------------------------------------------------------+
! 0 |			       MACRO_NAME				    |
!   +-----------------------------------------------------------------------+
! 1 |   			    RAD50NAME				    |
!   +-----------------------------------------------------------------------+

FIELD
    MACRO_FIELDS=
	SET
	MACRO_NAME=     [0, 0,36,0],	    ! Macro name in SIXBIT
	MACRO_BODY=     [1, 0,36,0]	     ! CH$ pointer to body string
	TES;

OWN
    SIXNAMES:	BLOCKVECTOR[NMACROS,2] FIELD(MACRO_FIELDS);	! Storage for MACRO names, etc.

LITERAL
	QUALPREFIX = 1,
	QUALSUFFIX = 0,

	DORESUME=0,
	DORESIGNAL=1;
! Some useful macros
! ------------------

MACRO
	RNAME=	$JBUUO<RH> %,
	RH=0,18  %,
	LH=18,18 %,
	FW=0,36, 0 %,
	WATCHFLAG=23,1,0 %,

	BITFIELD(N)=N,1,0 %,
	BITVAL(N)=1^(N) %,
	MASK_[] = (0 OR XMASK_[%REMAINING]) %,
	XMASK_[N] = (1^N) %,
	DECRTOG=(SIXTOG = .SIXTOG-BGOBASE) %,
	INCRTOG=(SIXTOG = .SIXTOG+BGOBASE) %,

	SETON(U)=(U = -1) %,
	SETOFF(U)=(U = 0) %,
	ISON(U)=(.U NEQ 0) %,
	ISOFF(U)=(.U EQL 0) %,


	SETINTERNAL(DUMMY)=(RTNLVL = -1) %,
	SETISEXIT(DUMMY)=(RTNLVL = ISEXIT) %,
	OUTFLAG(DUMMY)=OUTFLAGRTN() %,

	DDTEND	= (.$JBDDT<LH>) %;


MACRO OPRETURN(X)=
	!+
	! Forms fullword encoding of OPERATOR
	!-
	(  .X + 1
	 + ((((.(.X+1) NEQ 0) ^1
	    + (.(.X+2) NEQ 0))^1
	    + (.(.X+3) NEQ 0))^1
	    + (.(.X+4) NEQ 0))   ^  18) %;

MACRO
    DBG_ON_INST =
	%IF EXTENDED %THEN
		(JRSTOP^27+ UUOH)
	%ELSE
		(PUSHJOP^27 OR SREG^23 OR UUOH)
	%FI %,

    DBG_OFF_INST =
	%IF EXTENDED %THEN
		(JRSTOP^27 OR 2^23 OR 1^22 OR SWT[$AROPC,FW])
	%ELSE
		(JFCLOP^27)
	%FI %;

MACRO	BUGCHECK(CODE,ACTION)=
	IF .$JB41 EQL DBG_OFF_INST THEN (ERROR(CODE); ACTION) %;
! Machine Instruction Format
! ---------------------------


!   35		   27 26    23   21   18 17				    0
!   +----------------+--------+-+-------+-----------------------------------+
!   |    M_OPCODE    | M_REGF |*|M_INDEX|	    M_OFFSET		    |
!   +----------------+--------+-+-------+-----------------------------------+
!
!	*	- M_INDIRECT
!

FIELD
    INSTRUCTION_FIELDS=
	SET
	M_OPCODE=	[0,27,9,0],		! Op-code field
	M_REGF=		[0,23,4,0],		! AC field
	M_INDIRECT=	[0,22,1,0],		! Indirect bit
	M_INDEX=	[0,18,4,0],		! Index register
	M_OFFSET=	[0, 0,18,0],		!
	M_LHALF=	[0,18,18,0],		! All opcode, AC and indirect
	M_IMMEDIATE=	[0,0,18,1]		! Signed immediate value
	TES;

MACRO
    $INSTRUCTION=	BLOCK[1] FIELD(INSTRUCTION_FIELDS) %;

! Byte Pointer Format
!
!   35	    30 29    24 23 22 21     18 17				   0
!   +---------+--------+--+--+---------+-----------------------------------+
!   | P_POS   | P_SIZE |  | %| P_INDEX |	    P_OFFSET		   |
!   +---------+--------+--+--+---------+-----------------------------------+
!
!  % - P_INDIRECT

FIELD
    BYTEPOINTER_FIELDS=
	SET
	P_LHALF=	[0, 18,18,0],		! Left half of pointer
	P_POS=		[0, 30,6,0],		! Field position
	P_SIZE=		[0, 24,6,0],		!  and size
	P_POS_SIZE=	[0, 24,12,0],		! Combination for <0,36> checks
	P_INDIRECT=	[0, 22,1,0],		! Indirect bit
	P_INDEX=	[0, 18,4,0],		! Index Register
	P_OFFSET=	[0, 0,18,0],		! Displacement Value
	P_FWORD=	[0, 0,36,0]		! Entire pointer value
	TES;

MACRO
    $BYTE_POINTER=	BLOCK[1] FIELD(BYTEPOINTER_FIELDS) %;
! Symbol Table Data Structures
! ----------------------------


!   +--+----+---------------------------+-----------------------------------+
! 0 |* |  & |			    RAD50NAME				    |
!   +-----------------------------------+-----------------------------------+
! 1 |		SYMBOLCNT		|	    SYMBOLVAL		    |
!   +-----------------------------------+-----------------------------------+
!
!	*	- INVALIDFLAG
!	&	- RAD50FLAG
!

STRUCTURE
    !+
    ! This is a REF BLOCK structure which uses only an 18-bit offset to
    ! deal with indirection.  Typically the left-half will be a negative
    ! count (or trash).
    !-
    HBLOCK[OFF, P,S,E; SIZE=1] = [SIZE] ( (.HBLOCK<RH>)+OFF)<P,S,E>;

MACRO
    SYMBOL=	HBLOCK[1] FIELD(DDT_FIELDS) %;

FIELD
    DDT_FIELDS=
	SET
	NAMEWRD=	[0,0,36,0],
	VALUEWRD=	[1,0,36,0],
	ADDRWRD=	[1,0, %IF EXTENDED %THEN 30 %ELSE 18 %FI, 0],

	INVALIDFLAG=	[0,35,1,0],		! Symbol is purged from symtab
	RAD50FLAG=	[0,32,2,0],
	RAD50NAME=	[0,0,32,0],
	SYMBOLVAL=	[1,0,18,0],		! "Address" value (18-bits)
	SYMBOLCNT=	[1,18,18,1]		! # of symbols in module when
						!  ste is DDT$_MODULE type.
	TES;

LITERAL
    DDT$_MODULE	= 0,		! RAD50FLAG values
    DDT$_GLOBAL = 1,		! Defined as GLOBAL symbol
    DDT$_OWN=	  2;		! Defined as non-global

! MODULE_PTR
!
!   +-----------------------------------+-----------------------------------+
! 0 |	    MODSYMCNT			|	    MODSYMPTR		    |
!   +-----------------------------------+-----------------------------------+

FIELD
    MODULE_FIELDS=
	SET
	MODSYMPTR = [ 0, 0,18,0],
	MODSYMCNT = [ 0,18,18,1]
	TES;

MACRO
    MODULEPTR = BLOCK[1] FIELD(MODULE_FIELDS) %;
FORWARD ROUTINE
	ACTBIT2NAM,
	ACTNAM2BIT,
	ADVANCE	 : NOVALUE,
	B36ISUB		: NOVALUE,
	BEGINSIX12	: NOVALUE,
	BOOBOO		: NOVALUE,
	CALL1		: NOVALUE,
	CALL2		: NOVALUE,
	CALLENABLED,
	CFINDR,
	CHKCOND,
	CINSERT,
	CKVALS		: NOVALUE,
	CLOSELPT	: NOVALUE,
	CLRSTEP		: NOVALUE,
	COLON		: NOVALUE,
	CONTENTS	: NOVALUE,
	COPYR		: NOVALUE,
	CREMOVE		: NOVALUE,
	DABREAK		: NOVALUE,
	DBLEQL		: NOVALUE,
	DBREAK		: NOVALUE,
	DISAB		: NOVALUE,
	DOMON		: NOVALUE,
	DOPAQUE		: NOVALUE,
	DOTVREG,
	DSTABREAK	: NOVALUE,
	DTRACE,
	ENDSIX12	: NOVALUE,
	EQUALS		: NOVALUE,
	EQUALS0,
	ERROR,
	EXECUTE		: NOVALUE,
	EXITHANDLER	: NOVALUE,
	EXITSIGNAL	: NOVALUE,
	F50TO6,
	F50TO7,
	F7TO50,
	FIELDSPEC	: NOVALUE,
	FILEOPEN,
	FINDMODULE,
	FNDDBGUUO,
	GETARGADR,
	GETARGBASE,
	GETARGCNT,
	GETCALLFROM,
	GETLCLCNT,
	GETLCLADR,
	GETNAMEOP,
	GETNUMBER,
	GETOP,
	GETSTRING	: NOVALUE,
	GETSYMBOL,
	GETTEXT		: NOVALUE,
	GOER		: NOVALUE,
	GQUAL,
	INCHARS,
	INITSIX12	: NOVALUE,
	INPUT,
	INTEXT		: NOVALUE,
	INWORD,
	ISADDRESS,
	ISREADABLE,
	ISROUTINE,
	ISUB,
	ISUBSIG,
	ISWRITABLE,
	JOIN		: NOVALUE,
	KILLSYMBOL	: NOVALUE,
	LGFLD		: NOVALUE,
	LGVEC		: NOVALUE,
	LPAREN,
	LPTDUP		: NOVALUE,
	LPTOFF		: NOVALUE,
	LPTON		: NOVALUE,
	LPTOUT		: NOVALUE,
	MODDDT,
	NOSIX12		: NOVALUE,
	NOSIXSYMS	: NOVALUE,
	NSDDTFA,
	NSDDTW,
	OPAQUE		: NOVALUE,
	OPENLPT		: NOVALUE,
	OPERATE		: NOVALUE,
	OUTC		: NOVALUE,
	OUTCRLF		: NOVALUE,
	OUTERHANDLER,
	OUTFLAGRTN	: NOVALUE,
	OUTN,
	OUTQUAL		: NOVALUE,
	OUTSA		: NOVALUE,
	OUTTEXT		: NOVALUE,
	OUTVALUE	: NOVALUE,
	OUTWORD		: NOVALUE,
	PDEBUG,
	PPSYM		: NOVALUE,
	PR1ACTION       : NOVALUE,
	PR1MACRO	: NOVALUE,
	PRBPTR		: NOVALUE,
	PRCALL,
	PRCOUNTEDVECTOR	: NOVALUE,
	PRDISP		: NOVALUE,
	PRG		: NOVALUE,
	PRHANDLER,
	PRHPARMS	: NOVALUE,
	PRM		: NOVALUE,
	PRMVALSNAM	: NOVALUE,
	PROP		: NOVALUE,
	PRQ50,
	PRQUAL		: NOVALUE,
	PRQUALBP	: NOVALUE,
	PRS		: NOVALUE,
	PRSTK		: NOVALUE,
	PRSYM50,
	PRSYM6,
	PRXDISP		: NOVALUE,
	PSTK		: NOVALUE,
	PUSHITEM	: NOVALUE,
	PUSHOPER	: NOVALUE,
	RABREAK		: NOVALUE,
	RBREAK		: NOVALUE,
	RET612		: NOVALUE,
	ROPQAFT		: NOVALUE,
	ROPQAT		: NOVALUE,
	RTABREAK	: NOVALUE,
	RTRCAFT		: NOVALUE,
	RTRCAT		: NOVALUE,
	SDDTFS,
	SETAFTER	: NOVALUE,
	SETBIT		: NOVALUE,
	SETFROM		: NOVALUE,
	SETTBLBIT	: NOVALUE,
	SIX12A,
	SIX36,
	SIXDD2		: NOVALUE,
	SIXDDT		: NOVALUE,
	SIXDPY		: NOVALUE,	! global
	SIXID		: NOVALUE,
	SIXOP,				! global
	SIXXEQ,				! global
	SLASH		: NOVALUE,
	STABREAK	: NOVALUE,
	STOPIT		: NOVALUE,
	STRUCT		: NOVALUE,
	SYNTAX,
	TTOUTN		: NOVALUE,
	TYPE,
	UNSETBIT,
	UUOH		: NOVALUE,
	XABREAK		: NOVALUE,
	XADD		: NOVALUE,
	XAND		: NOVALUE,
	XASSIGN		: NOVALUE,
	XBACKTO		: NOVALUE,
	XBASE		: NOVALUE,
	XBIND		: NOVALUE,
	XBREAK		: NOVALUE,
	XCALL		: NOVALUE,
	XCLRTRACE	: NOVALUE,
	XCOPAQUE	: NOVALUE,
	XDDT		: NOVALUE,
	XDEBUG		: NOVALUE,
	XDEFINE		: NOVALUE,
	X2DEFINE	: NOVALUE,
	XDEL1		: NOVALUE,
	XDEL2		: NOVALUE,
	XDIV		: NOVALUE,
	XDMONITOR	: NOVALUE,
	XEQL		: NOVALUE,
	XEQOR		: NOVALUE,
	XGEQ		: NOVALUE,
	XGO		: NOVALUE,
	XGOCLR		: NOVALUE,
	XGOTRACE	: NOVALUE,
	XGTR		: NOVALUE,
	XHELP		: NOVALUE,
	XLOAD		: NOVALUE,
	XMACRO		: NOVALUE,
	XMONITOR	: NOVALUE,
	XNOCOPAQUE	: NOVALUE,
	XNOT		: NOVALUE,
	XOK		: NOVALUE,
	XLCALL		: NOVALUE,
	XLEQ		: NOVALUE,
	XLSS		: NOVALUE,
	XNEQ		: NOVALUE,
	XNOPOLLOFF	: NOVALUE,
	XNOPOLLON	: NOVALUE,
	XPOP		: NOVALUE,
	XPRINT,
	XPRINT0,
	XPRINTACT       : NOVALUE,
	XPRINTMACRO	: NOVALUE,
	XPRINTMON	: NOVALUE,
	XPRINTOPER	: NOVALUE,
	XPRM		: NOVALUE,
	XPRS		: NOVALUE,
	XRECALL		: NOVALUE,
	XRESET		: NOVALUE,
	XRESIGNAL	: NOVALUE,
	XRESUME		: NOVALUE,
	XRETURN		: NOVALUE,
	XSAVE		: NOVALUE,
	XSEARCH		: NOVALUE,
	XSET1		: NOVALUE,
	XSET2		: NOVALUE,
	XSET3		: NOVALUE,
	XSHIFT		: NOVALUE,
	XSIGNAL		: NOVALUE,
	XSTEP		: NOVALUE,
	XSTORE		: NOVALUE,
	XSTRACE		: NOVALUE,
	XSUBTRACT	: NOVALUE,
	XTIMES		: NOVALUE,
	XTRACE		: NOVALUE,
	XWATCH		: NOVALUE,
	XWBASE		: NOVALUE,
	XWHERE		: NOVALUE;
! Character codes

LITERAL
	TAB=		 %O'11',
	LF=		 %O'12',
	CR=		 %O'15',
	ESCAPE=		 %O'33',
	DQUOTE=		 %O'42',		! "
	SQUOTE=		 %O'47',		! '
	LEFTPAREN=	 %O'50',		! (
	RPAREN=		 %O'51',		! )
	LPOINTY=	 %O'74',		! <
	RPOINTY=	 %O'76',		! >
	LSQUARE=	%O'133',		! [
	RSQUARE=	%O'135',		! ]
	LBRACE=		%O'173',		! {	! LG change
	BAR=		%O'174',		! |	subst for escape!
	RBRACE=		%O'175';		! }	! LG change
ROUTINE BEGINSIX12: NOVALUE=
!+
! FUNCTION
!	First code address within SIX12 debugger
!-
    BEGIN
    GLOBAL LITERAL
	SIXLSF=	-1,		! Delete local symbols 
	SIXPOL=	0,		! Default is terminal polling
	SIXSTF=	-1,		! Come up in SIX12
	SIXENF=	-1;		! DEBUG UUO's will be honored, not JFCL-ed
    0
    END;
ROUTINE STOPIT: NOVALUE=
    BEGIN
    SETON(ENABFLAG);
    IF ISON(TRACEFLAG) THEN INCRTOG;
    LPTOFF();
    GOFLAG = 2;				! Indicates prompt for more commands
    SETOFF(WHACKING)
    END;
! Declarations for UUO entry to SIX12
! -----------------------------------

LITERAL
	DEBUGUUO=%O'037',
	TBLPOS=24,		! This bit is DEBUG 2,rtn or DEBUG 3,rtn
				! and indicates the routine is "interesting"
	EXITPOS=23,		! This bit means it is DEBUG 1,rtn
	NOVALUEPOS=25,		! Means the routine (Bliss-36) is
				! a NoValue routine (DEBUG 5,rtn or
				! DEBUG 15,rtn)
	UNWINDPOS=26;		! The special DEBUG after a stack unwind
				! (DEBUG 11,rtn or DEBUG 15,rtn)

MACRO
	TBLBIT=BITFIELD(TBLPOS) %,
	EXITBIT=BITFIELD(EXITPOS) %,
	NOVALUEBIT=BITFIELD(NOVALUEPOS) %,
	UNWINDBIT=BITFIELD(UNWINDPOS) %,

	ISINTBL=.$JBUUO<TBLBIT> %,
	ISEXIT=.$JBUUO<EXITBIT> %,
	ISNOVALUE=.$JBUUO<NOVALUEBIT> %,
	ISUNWOUND=.$JBUUO<UNWINDBIT> %,

	CHKUWP(ACTION,ADDRESS)=
	    BEGIN
%IF TOPS10
%THEN
	    REGISTER
		RUWP;

	    RUWP = 0;
	    SETUWP(RUWP);		! Clear and save previous protection
	    (ACTION);
	    SETUWP(RUWP);		! Restore to previous state
%ELSE
	    IF NOT ISWRITABLE(ADDRESS)
	    THEN
		SPACS( $FHSLF^18 +			! This process,
		    (((ADDRESS) AND %O'777777') ^ (-9)),! specific page
		      PA_CPY);				! Copy on write

	    IF ISWRITABLE(ADDRESS) THEN (ACTION)
%FI
	    END %;
! TTY and LPT I/O support
! -----------------------

! Items beginning with 'TT' always write to the TTY.  They
! will also write to LPT in LPTDUP mode.   Others
! write either to TTY or LPT-FILE, or both, depending on state of
! switch 'LPTFlag'  (set by LPTON, LPTDUP, and LPToff). Routines
! OpenLPT and CloseLPT must be called before and after one
! complete set of LPT output.

BIND
	CRLFSTR=CH$PTR(UPLIT (%ASCIZ %STRING(%CHAR(13,10)))),	! STRING FOR CRLF Macro
	VALSTR=CH$PTR(UPLIT (%ASCIZ %STRING(%CHAR(9),'Value: '))): VECTOR;		! FOR OUTVALUE

MACRO
	MSG[]= CH$PTR( UPLIT (%ASCIZ %STRING(%REMAINING) ) ) %,

 	INC=
	    %IF TOPS10
	    %THEN
		BEGIN
		REGISTER
		    C;
		INCHWL(C);
		.C
		END
	    %FI %,

	OUTS[]=	OUTSA( MSG(%REMAINING) ) %,

	TTOUTS[]=	TTOUTSA( MSG(%REMAINING) ) %,

	TTOUTSH(Z)=
	    BEGIN
%IF TOPS10
%THEN
	    OUTSTR(Z);
%ELSE
	    PSOUT( Z )
%FI
	    END %,

	OUTM(C,N)=
	    (DECR QQ FROM (N)-1 TO 0 DO OUTC(C)) %,
	TTOUTM(C,N)=
	    (DECR QQ FROM (N)-1 TO 0 DO TTOUTC(C)) %,
	TTOUTDEC(N)=
	    TTOUTN(N,10,1) %,
	CRLF=
	    OUTCRLF() %,
	TTCRLF=
	    BEGIN
		TTOUTSA(CRLFSTR)
	    END %,
	PUTTAB=
	    OUTC(TAB) %,
	OUTDEFAULT(Z)=
	    OUTN((Z),.IOBASE,1) %,
	OUTRDEF(Z,R)=
	    OUTN((Z),.IOBASE,(R)) %,
	OUTD(Z)=
	    OUTN((Z),10,1) %,
	OUTDR(Z,N)=
	    OUTN((Z),10,(N)) %;
ROUTINE OUTFLAGRTN : NOVALUE=
    BEGIN
    CASE .RTNLVL FROM 0 TO 1 OF
	SET
	[0]:    OUTS('B:');
	[1]:    OUTS('A:');
	[OUTRANGE]:	0	! Routine level can be -1 (which would loop)
	TES;
    END;
ROUTINE OUTCRLF : NOVALUE = OUTSA(CRLFSTR);	! OUTPUT NEWLINE

ROUTINE DBLEQL: NOVALUE = OUTS('  ==  ');	! Output equivalency symbols
! SUPPORT of LPT and SAVE/LOAD I/O
! --------------------------------

LITERAL
	SLCHN=%O'16',
	LPTCHN=%O'17';

MACRO
	LPTCNT=LPTHDR[2] %,
	LPTPTR=LPTHDR[1] %,
	DSKCNT=DSKHDR[2] %,
	DSKPTR=DSKHDR[1] %,
	STATUS=OPENBLOCK[0] %,
	LDEV=OPENBLOCK[1] %,
	BUFW=OPENBLOCK[2] %,
	FNAME=BLOCK[0] %,
	FEXT=BLOCK[1] %,
	JUNK=BLOCK[2] %,
	PPN=BLOCK[3] %;

MACRO
	ANYLPT(DUMMY) = BEGIN .LPTFLAG NEQ 0 END %,
	NOLPT(DUMMY) = BEGIN .LPTFLAG EQL 0 END %,
	LPTDUPPING(DUMMY) = BEGIN .LPTFLAG GTR 0 END %,
	ANYTERMINALOUTPUT(DUMMY) = BEGIN .LPTFLAG GEQ 0 END %,
	LPTOUTTING(DUMMY) = BEGIN .LPTFLAG LSS 0 END %;
ROUTINE OPENLPT : NOVALUE=
!+
! FUNCTION
!	Set up for copying output to hard-copy
!-
    BEGIN
%IF TOPS10
%THEN
    LOCAL
	SAVFF,
	OPENBLOCK:	VECTOR[4],
	BLOCK:		VECTOR[4];

    STATUS = 1;
    LDEV = %SIXBIT 'SIX12';
    BUFW = LPTHDR^18;
    IF NOT OPEN(LPTCHN,OPENBLOCK)
    THEN
	BEGIN
	LDEV = %SIXBIT 'LPT';
	IF NOT OPEN(LPTCHN,OPENBLOCK)
	THEN
	    RETURN ERROR(10)
	END;

    FNAME = %SIXBIT 'SIX12';
    FEXT = %SIXBIT 'LPT';
    JUNK = 0;
    PPN = 0;

    IF NOT ENTER(LPTCHN,BLOCK) THEN RETURN ERROR(10);

    SAVFF = .$JBFF;
    $JBFF = LPTBUF;
    OUTBUF(LPTCHN,1);
    $JBFF = .SAVFF;
    OUT(LPTCHN,0);
%ELSE
    LOCAL
	JFN;

    IF GTJFN( GJ_FOU+GJ_NEW+GJ_SHT,		! New output file, short form
		  MSG('SIX12:')                 ! file spec, first try
		; JFN ) OR                      ! Returned JFN
       GTJFN( GJ_FOU+GJ_NEW+GJ_SHT,             ! Second, try for "real" LPT
                  MSG('LPT:SIX12.LPT')          !  and random filespec
                ; JFN )
    THEN
	BEGIN
	LPTHDR = .JFN<RH>;				! SAVE JFN

	IF NOT OPENF( .JFN, (7^30)+OF_WR )		! 7-bit bytes, write access
	THEN
	    RETURN ERROR(10)
	END
    ELSE
	RETURN ERROR(10);
%FI

    SETON(LPTOPENFLAG)				! Set line printer file open
    END;
ROUTINE LPTOUT(CHAR): NOVALUE=
    BEGIN
    IF NOLPT() THEN RETURN;

%IF TOPS10
%THEN
    IF (LPTCNT = .LPTCNT-1) LEQ 0 THEN OUT(LPTCHN,0);
    CH$WCHAR_A( .CHAR, LPTPTR )
%ELSE
    BOUT(.LPTHDR, .CHAR)
%FI
END;
ROUTINE OUTC(CHAR): NOVALUE=
!+
! FUNCTION
!	Output single character to all relevant output devices
!
! INPUTS
!	CHAR	- 7-bit ASCII character (right-justified)
!-
    BEGIN
    IF ISON(DISKOFLAG) THEN RETURN(OUTWORD(.CHAR));
    IF ANYTERMINALOUTPUT() 
    THEN
%IF TOPS10
%THEN
	OUTCHR(CHAR);
%ELSE
	PBOUT( .CHAR );
%FI

    IF ANYLPT() THEN LPTOUT(.CHAR)

    END;

GLOBAL BIND SIXOCH=OUTC;
ROUTINE OUTSA(STR) : NOVALUE=
!+
! INPUTS
!	STR	- CH$PTR to an ASCIZ string to be printed
!-
    BEGIN
    IF ISON(DISKOFLAG)
    THEN
	BEGIN
	LOCAL
	    PTR;
	REGISTER
	    C;

	PTR = .STR;

	WHILE (C=CH$RCHAR_A(PTR)) NEQ 0 DO OUTC(.C);
	RETURN
	END;

    IF ANYTERMINALOUTPUT()
    THEN
	BEGIN
%IF TOPS10
%THEN
	IBP( STR );
	OUTSTR(.STR<RH>)
%ELSE
	PSOUT( .STR )
%FI
	END;

    IF ANYLPT()
    THEN
	BEGIN
%IF TOPS10
%THEN
	REGISTER
	    PTR,
	    C;

	PTR = .STR;
	WHILE (C = CH$RCHAR_A(PTR)) NEQ 0 DO
	    BEGIN
	    IF (LPTCNT = .LPTCNT-1) LEQ 0 THEN OUT(LPTCHN,0);
	    CH$WCHAR_A(.C, LPTPTR)
	    END
%ELSE
	SOUT( .LPTHDR, .STR, 0 )
%FI
	END
    END;
GLOBAL ROUTINE SIXOSA(P)=
!+
! FUNCTION
!	Print string addressed by P, if it is accessible.
! INPUT
!	P	- Byte-pointer to a string
! OUTPUTS
!	TRUE	- Addressable value
!	FALSE	- Bad address
!-
    BEGIN
    IF ISREADABLE(.P<RH>)
    THEN
	BEGIN
	OUTSA(.P);
	RETURN 1
	END
    ELSE
	RETURN 0
    END;
ROUTINE INWORD=
!+
! FUNCTION
!	Fetch next word from SAVE/LOAD channel or when reading an
!	indirect command file (RESTORE command)
! INPUTS
!	None
! OUTPUTS
!	-1	EOF encountered on input
!	Other	Data value
!-
    BEGIN
    IF ISON(ERRORFLAG) THEN RETURN -1;

%IF TOPS10
%THEN
    IF (DSKCNT = .DSKCNT-1) LEQ 0
    THEN
	IF IN(SLCHN,0)
	THEN				! An I/O error occurred
	    BEGIN
	    IF STATZ(SLCHN,IO$EOF)
	    THEN			! Was NOT EOF, so must have been
		SETON(ERRORFLAG);  	!  for real.  Flag this as "BAD"
	    RETURN -1			! Return all errors as EOF
	    END;
    RETURN CH$RCHAR_A( DSKPTR )
%ELSE
    BEGIN
    LOCAL
	RESLT;

    IF BIN( .DSKHDR ; RESLT )
    THEN
	RETURN .RESLT;			! Return word read in

    -1					! ERROR ----
    END
%FI
    END;
ROUTINE INCHARS=
!+
! Return next "real" character from input disk file
!-
    BEGIN
    LOCAL
	C;

    DO
	BEGIN
	C = INWORD();
	IF CH$RCHAR(.DSKPTR)		! Low bit says line-sequenced
	THEN
	    DECR I FROM 5 TO 0 DO C = INWORD();	! skip line no.
	END
    UNTIL .C NEQ 0;

    .C
    END;
ROUTINE OUTFD(VALUE,WID): NOVALUE=
    BEGIN
    IF .IOBASE EQL 8 AND ABS(.VALUE) GTR 7 THEN OUTC(%C'#');
    OUTDR(.VALUE,.WID)
    END;
ROUTINE OUTWORD(WRD):NOVALUE=
!+
! FUNCTION
!	Write a word to the disk output
!-
    BEGIN
    IF ISON(ERRORFLAG) THEN RETURN;

%IF TOPS10
%THEN
    IF (DSKCNT = .DSKCNT-1) LEQ 0		! When the ring-buffer is full
    THEN					!  write it out to the device
	IF OUT(SLCHN,0)
	THEN
	    (SETON(ERRORFLAG);  RETURN );

    CH$WCHAR_A(.WRD, DSKPTR)
%FI

%IF TOPS20
%THEN
    BOUT( .DSKHDR, .WRD )
%FI
    END;
ROUTINE CLOSELPT: NOVALUE=
    BEGIN
    LPTFLAG = 0;

%IF TOPS10
%THEN
    CLOSE(LPTCHN,0);
    RELEASE(LPTCHN,0);
%FI

%IF TOPS20
%THEN
    CLOSF( .LPTHDR );
%FI
    SETOFF(LPTOPENFLAG)
    END;
ROUTINE LPTON:NOVALUE= IF ISON(LPTOPENFLAG) THEN LPTFLAG = -1 ELSE ERROR(19);

ROUTINE LPTDUP:NOVALUE= IF ISON(LPTOPENFLAG) THEN LPTFLAG =  1 ELSE ERROR(19);

ROUTINE LPTOFF:NOVALUE= LPTFLAG = 0;
ROUTINE XRESET: NOVALUE=
    BEGIN
    IF ISON(LPTOPENFLAG) THEN RETURN ERROR(20);

%IF TOPS10 %THEN CALLI(0,0) %FI

%IF TOPS20 %THEN RESET() %FI

    END;
! General purpose number output Routine
! -------------------------------------

ROUTINE OUTN(N,B,RD)=
! Returns the number of positions printed
    BEGIN
    OWN
	NUM,
	NUMNP,
	BASE,
	REQD,
	WRIT,
	COUNT;

    ROUTINE XN:NOVALUE=
	BEGIN
	REGISTER
	    R;
	IF .NUM EQL 0
	THEN
	    BEGIN
	    OUTM(%C' ',WRIT = .REQD-.COUNT);
	    IF ISON(NUMNP) THEN (OUTC(%C'-'); WRIT = .WRIT + 1);
	    RETURN
	    END;
	R = .NUM MOD .BASE;
	NUM = .NUM/.BASE;
	COUNT = .COUNT+1;
	XN();
	OUTC(R = .R+%C'0');
	WRIT = .WRIT + 1
	END;

    NUMNP = COUNT = (.N LSS 0);
    BASE = .B;
    REQD = .RD;
    WRIT = 0;

    IF (NUM = ABS(.N) AND NOT 1^35) NEQ 0 THEN RETURN (XN(); .WRIT);

    OUTM(%C' ',.REQD-1-.NUMNP);
    IF .NUMNP NEQ 0 THEN OUTC(%C'-');
    OUTC(%C'0');
    .REQD    
    END;
ROUTINE TTOUTN(B,D,R):NOVALUE=
    BEGIN
    LOCAL
	OLDLPT;

    OLDLPT=.LPTFLAG;
    LPTOFF();
    OUTN(.B,.D,.R);
    LPTFLAG = .OLDLPT
    END;
ROUTINE TTOUTC(CH): NOVALUE=
!+
! FUNCTION
!	Write a single character to the terminal, duplicating (if necessary)
!	into the "log" file.
! INPUTS
!	CH	- The ASCII character value to print
! OUTPUTS
!	None
!-
    BEGIN
    IF LPTDUPPING() THEN LPTOUT(.CH);
%IF TOPS10
%THEN
    OUTCHR( CH )
%ELSE
    PBOUT( .CH )
%FI
    END;
ROUTINE TTOUTSA(STR): NOVALUE=
    BEGIN
    IF LPTDUPPING() THEN RETURN OUTSA(.STR);
    TTOUTSH(.STR<RH>+1)
    END;
ROUTINE OUTVALUE(X): NOVALUE=
!+
! FUNCTION
!	Print routine return value.  Use user-supplied routine, if
!	it is present.
! INPUT
!	X	- The value passed back from a ABREAK-ed or TRACE-d routine
!-
    BEGIN
    OUTSA(VALSTR);
    IF .SIXHDR NEQ 0
    THEN			! A user-written routine is present.
	BEGIN %(user routine)%
	LOCAL
	    OLDRNAME;

	OLDRNAME = .RNAME;
	INSIXHDR=1;

	IF (.SIXHDR)(.RNAME,F50TO6(.SDDTFS(.RNAME)),X,1,0)
	THEN
	    BEGIN
	    INSIXHDR=0;
	    RNAME = .OLDRNAME;
	    CRLF;
	    RETURN
	    END;

	INSIXHDR=0;
	RNAME = .OLDRNAME
	END %(user routine)%;

    OUTDEFAULT(.X);
    DBLEQL();
    PRDISP(.X);
    CRLF
    END;
ROUTINE SHOWNOVALUE: NOVALUE=
	BEGIN
	OUTS(' :NoValue');
	CRLF
	END;
ROUTINE ISHIGHSYMBOLTABLE=
!+
! FUNCTION
!	Returns "true" if there is a separate hiseg symbol table, false
!	if only one symbol table.
!-
    BEGIN
    ! if the symbol ".JBHGH+.JBHSM" is not defined, there isn't even a hiseg:
    !

    IF .IJOBHSM EQL 0 THEN RETURN 0;

    ! there may be a hiseg, but it may be absent:
    !

    IF NOT ISREADABLE(.IJOBHSM) THEN RETURN 0;

    ! if HCache is nonzero, we have already set it up on this SIX12 entry
    ! since HCache is reset on every SIX12 entry or return from a user
    ! procedure (since the user can obviously do a call to switch segments)
    ! we know it must be valid
    !

    IF .HCACHE NEQ 0 THEN RETURN 1;

    IF .(.IJOBHSM) NEQ 0 AND .(.IJOBHSM) NEQ .$JBSYM
    THEN
	BEGIN					%(have two)%
	HSYM = 1;
	HCACHE = .(.IJOBHSM);
	RETURN 1
	END;

    RETURN 0       
    END;
ROUTINE NSDDTW(X,V,SYM: MODULEPTR)=
!+
! FUNCTION
!	Given a symbol search for the address of its next occurrence in
!	table SYM
! INPUTS
!	X	- RAD50_10 value of symbol to look up
!	V	- If non-zero, where to start looking in the symbol table
!	SYM	- If V is zero, the address of a symbol-table to look in
! OUTPUT
!	<cnt,,adr> of found symbol
!-
    BEGIN
    LOCAL
	R	: SYMBOL;

    IF .V EQL 0
    THEN
	BEGIN
	R = - .SYM[MODSYMCNT];			! Symboltable count
	R = .R^18 + .R + .SYM[MODSYMPTR];	! Compute "end" address
	END
    ELSE
	R = .V;

    ! Walk backwards thru the symbol-table looking for a name-match
    !

    WHILE (R = .R-%O'2000002') GEQ 0 DO
	IF .R[RAD50NAME] EQL .X THEN RETURN .R;		! Found it

    0
    END;
ROUTINE NSDDTFA(X,V)=
!+
! FUNCTION
!	Given a symbol, search for the address of its next occurrence
!	First use .JBHSM, then .JBSYM; this means that we always check
!	the overlay first.  If .JBHSM is zero or the same as .JBSYM,
!	use only .JBSYM
! INPUT
!	X	- RAD50 Symbol name to look up
!	V	- If non-zero, where to begin searching
!-
    BEGIN
    LOCAL
	T	: SYMBOL;

    IF NOT ISHIGHSYMBOLTABLE()
    THEN
	RETURN NSDDTW(.X,.V,.$JBSYM);

    IF (T =NSDDTW(.X,.V,.HCACHE)) EQL 0 
    THEN
	NSDDTW(.X,.V,.$JBSYM)
    ELSE
	.T
    END;
!	Routine SDDTFA(X) =
!	    ! Given a symbol, search ddt symbol-table for its value
!	    ! return the value
!	    begin
!	    Register R;
!	    If (R = NSDDTFA(.X,0)) neq 0 then Return @(.R+1);
!	    Error(0)
!	    end;
ROUTINE FINDMODULE(X)=
!+
! FUNCTION
!	Returns a pointer to the module which can be passed to
!	NSDDTFA and which restricts the search to that module
!	This is used for qualified-name search algorithm
! INPUT
!	X	- RADIX50 name of module
! OUTPUT
!	0 => no such module
!	cnt,,start of module symbol table
!-
    BEGIN
    LOCAL
	S	: SYMBOL,
	MODPTR;

    S = NSDDTFA(.X,0);				! Search entire DDT symboltable
						!  for particular module name

    IF .S EQL 0 THEN RETURN 0;			! module not found!

    MODPTR<RH> = .S;				! Starting address of module
						!  symbol table
    MODPTR<LH> = - .S[SYMBOLCNT];		! # of symbols in module

    .MODPTR
    END;
ROUTINE HSDDTFS (X, SYM : SYMBOL)=
!+
! FUNCTION
!	Given an address, search table for the symbol most nearly matching it
! INPUT
!	X	- a value (address) whose symbol is to be searched for
!	SYM	- Symbol table to search
! OUTPUT
!	A pointer to the DDT symbol table entry for the symbol found
!-
    BEGIN
    LOCAL
	R	: SYMBOL,
	BEST	: SYMBOL;

    BIND
	DMY=UPLIT(0,0);			! Dummy ste for "no-match"

    BEST = DMY;				! Assume no match found

    R = - .SYM<LH,1>;
    R = .R^18 + .R + .SYM<RH>;

    WHILE (R = .R-%O'2000002') GEQ 0 DO
	IF NOT .R[INVALIDFLAG]			! Symbol not deleted...
	THEN
	    SELECTONE .R[VALUEWRD] OF
		SET
		[.X]:				RETURN .R<RH>;	! Exact match
		[.BEST[VALUEWRD] TO .X]:	BEST = .R<RH>	! Better match
		TES;

    .BEST
    END;
ROUTINE SDDTFS(X)=
!+
! FUNCTION
!	Search symbol-tables for a symbolic name, given a value.  Follows
!	the same "rules" as NSDDTFA, by first looking for a HISEG symbol
!	table and then searching the LOWSEG symbol-table.
! INPUTS
!	X	- Numeric value
! OUTPUTS
!	Address of symbol-table entry or ZERO
!-
    BEGIN
    LOCAL
	T;

    IF NOT ISHIGHSYMBOLTABLE()
    THEN
	RETURN HSDDTFS(.X,.$JBSYM);

    IF (T=HSDDTFS(.X,.HCACHE)) EQL 0 
    THEN
	HSDDTFS(.X,.$JBSYM)
    ELSE
	.T
    END;
ROUTINE KILLSYMBOL(SYMREF: SYMBOL):NOVALUE=
!+
! FUNCTION
!	SymRef is a modified symbol table pointer, where the RH is the address
!	of the symbol to be deleted, and the LH is the count of symbols
!	left (including the one to be deleted)
! INPUTS
!	SYMREF	- Symbol table pointer (LH is special)
!-
    BEGIN

    !+
    ! Mark the symbol as a suppressed local with an "illegal" name
    ! to keep it from matching with any interesting symbols.
    !-
    SYMREF[NAMEWRD] = 1^35 + DDT$_OWN^32 + (%RAD50_10 '%%%%%%'+1);
    SYMREF[VALUEWRD] = -1
    END;
ROUTINE DSIXSYMS(SYM):NOVALUE=
!+
! FUNCTION
!	Delete SIX36's local symbols from DDT symbol table(s)
!-
    BEGIN
    LOCAL
	R	: SYMBOL;
    BIND
	SIXMODNAME = %RAD50_10 'SIX36';

    R = -.SYM<LH,1>;
    R = .R^18 + .R + .SYM<RH>;

    WHILE (R = .R - %O'2000002') GEQ 0 DO		! Find SIX36 module
	BEGIN
	IF .R[RAD50FLAG] EQL DDT$_MODULE AND .R[RAD50NAME] EQL SIXMODNAME
	THEN
	    EXITLOOP
	END;

    WHILE (R = .R - %O'2000002') GEQ 0 DO		! DELETE LOCALS
	BEGIN
	IF .R[RAD50FLAG] EQL DDT$_MODULE THEN EXITLOOP;	! Next MODULE
	IF .R[RAD50FLAG] EQL DDT$_OWN			! Local
	    AND .R[RAD50NAME] NEQ %RAD50_10 'STARTF'
	    AND .R[RAD50NAME] NEQ %RAD50_10 'ENABFL'
	    AND .R[RAD50NAME] NEQ %RAD50_10 'NOPOLL'
	THEN
	    KILLSYMBOL(.R)
	END
    END;
ROUTINE NOSIXSYMS: NOVALUE=
    BEGIN
    IF ISHIGHSYMBOLTABLE()
    THEN
	DSIXSYMS(.HCACHE);
    DSIXSYMS(.$JBSYM)
    END;
ROUTINE FNDDBGUUO(STRT,ISITEXIT)=
!+
! FUNCTION
!	Starting at given address (STRT), scan forward looking
!	for DEBUG UUO.
! INPUTS
!	STRT	- Starting address
!	ISITEXIT- Are we looking for routine-entry or exit UUO?
! OUTPUTS
!	-1	No DEBUG UUO could be found
!	0:...	Address of the DEBUG UUO found
!-
    BEGIN
    LOCAL
	CORELIM,
	MATCH;
    BIND
	BITS = %O'777000777777' OR 1^EXITPOS;

    MATCH = DEBUGUUO^27 OR .ISITEXIT^EXITPOS OR .STRT<RH>;

    IF	.STRT<RH> GEQ $JBDA AND
	.STRT<RH> LEQ .$JBREL<RH>
    THEN
	CORELIM = .$JBREL<RH>
    ELSE
	IF .STRT<RH> GEQ ((.$JBHRL<RH>-.$JBHRL<LH>) AND %O'777000') AND
	    .STRT<RH> LEQ .$JBHRL<RH>
	THEN
	    CORELIM = .$JBHRL<RH>
	ELSE
	    RETURN -1;

    INCRA J FROM .STRT<RH> TO .CORELIM DO
	IF (..J AND BITS) EQL .MATCH
	THEN
	    RETURN .J;
    -1
    END;
ROUTINE HMODNAME(X, SYM: SYMBOL)=
!+
! FUNCTION
!	Given a start address X (in DDT symbol table), finds entry for
!	a module name
! INPUT
!	X	- DDT Symbol Table Entry
!	SYM	- Pointer to module record in DDT Symbol Table
!-
    BEGIN
    REGISTER
	R	: SYMBOL;

    R = .X + (.SYM<LH>^18);

    WHILE (R = .R+%O'2000002') LSS 0 DO
	IF  .R[RAD50FLAG] EQL DDT$_MODULE AND	! Seek a module definition
	    .R[NAMEWRD] NEQ %O'637777'^18	! Don't stop on deleted symbol
	THEN
	    RETURN .R<RH>;

    0						! No module
    END;
ROUTINE MODNAME(X)=
    BEGIN
    IF ISHIGHSYMBOLTABLE() AND .X<RH> GEQ .HCACHE<RH> 
    THEN 
	HMODNAME(.X,.HCACHE)
    ELSE
	HMODNAME(.X,.$JBSYM)
    END;
ROUTINE MODDDT(X)=
!+
! FUNCTION
!	Given a start address X in DDT symbol table, returns
!	Radix50 Module name
!-
    BEGIN
    LOCAL
	R	: SYMBOL;

    R = MODNAME(.X);			! Do the lookup

    IF .R EQL 0 THEN RETURN .R;		! Not found, return null string

    .R[RAD50NAME]			! Give back a good name
    END;
ROUTINE F50TO7(X)=
!+
! FUNCTION
!	Convert base 50 character to Ascii character
!-
    BEGIN
    SELECTONE .X OF
	SET
	[0]:		0;		! Blank
	[0 TO %o'12']:	.X + %o'57';	! "0".."9"
	[0 TO %o'44']:	.X + %o'66';	! "A".."Z"
	[%o'45']:	%C'.';		! period
	[%o'47']:	%C'_';		! % or "_"
	[%o'46']:	%C'$';		! "$"
	TES
    END;
ROUTINE F50TO6(X)=
!+
! FUNCTION
!	convert Base 50 symbol to SIXBIT symbol
!-
    BEGIN
    LOCAL
	R,
	OLD;

    R = 0;

    WHILE .X NEQ 0 DO
	BEGIN
	OLD = .X MOD %O'50';
	X = .X / %O'50';
	R = .R + (F50TO7(.OLD)-%O'40');
	R = ROT(.R, -6)
	END;
    .R
    END;
ROUTINE F7TO50(X)=
!+
! FUNCTION
!	Convert ASCII character to RAD50_10 character
    BEGIN
    SELECTONE .X OF
	SET
	[0]:			0;		! Ignore
	[%C'.', %C'&']:		%O'45';		! Map to same code
	[%C'$']:		%O'46';		!
	[%C'_', %C'%']:		%O'47';		!  "   "   "    "
	[%C'0' TO %C'9']:	.X - %O'57';
	[%C'A' TO %C'Z']:	.X - %O'66';
	[OTHERWISE]:		.X - %O'126';	! Lower-case alphabetics
	TES
    END;
ROUTINE PRQ50(X)=
BEGIN
	
    ROUTINE PRQA50 (X : BLOCK FIELD(DDT_FIELDS), F)=
	BEGIN
	LOCAL
	    R;

	IF (X = .X[RAD50NAME]) NEQ 0
	    THEN
		BEGIN
		R = .X MOD %O'50';
		F = .F OR (.R EQL %RAD50_10 '.');
		F = PRQA50(.X/%O'50',.F);
		OUTC(F50TO7(.R));
		RETURN .F
		END
	    ELSE
		BEGIN
		IF .F THEN OUTC(%C'?');
		RETURN .F
		END;
	END;
	
    PRQA50(.X,0)
END;
ROUTINE PRSYM50(X)=
    ! PRINT NAME GIVEN IN BASE 50
    ! Returns the number of characters printed
    BEGIN
    ROUTINE PSYM5 (X : BLOCK FIELD(DDT_FIELDS), Y)=
	BEGIN
	LOCAL
	    VAL,
	    R;

	IF (VAL = .X[RAD50NAME]) NEQ 0
	THEN
	    BEGIN
	    LOCAL
		V;
	    R = .VAL MOD %O'50';
	    V = PSYM5(.VAL/%O'50',.Y+1);
	    OUTC(F50TO7(.R));
	    RETURN .V
	    END;
	.Y
	END;
    PSYM5(.X,0)
    END;
ROUTINE PRSYM6(X)=
!+
! FUNCTION
!	Print a SIXBIT symbolic value
! INPUTS
!	X	- SIXBIT value
! OUTPUT
!	Returns the number of characters actually printed
!-
    BEGIN
    LOCAL
	P,
	C,
	V;

    V = 0;
    P = CH$PTR( X, 0, 6 );		! SIXBIT string pointer

    WHILE (C = CH$RCHAR_A(P)) NEQ 0 DO
	BEGIN
	V = .V + 1;
	OUTC(.C+%O'40');
	IF .V EQL 6 THEN EXITLOOP	! Certainly no more than 6 chars
	END;
    .V
    END;
ROUTINE PROP(X):NOVALUE=
!+
! FUNCTION
!	Print an operator from the table. Operators come in two flavors,
!	SIXBIT (left-justified) and 1-character ASCII (stored in <18,7>)
! INPUT
!	X	- "print-name" of operator.
!-
    BEGIN
    IF (.X AND %O'777600777777') EQL 0
    THEN
	OUTC(.X<LH>)
    ELSE
	PRSYM6(.X)
    END;
ROUTINE PRDISP(X):NOVALUE=
!+
! FUNCTION
!	Print both halves of .X in "BASE+DISP" form
!-
    BEGIN
    LOCAL
	BP	: $BYTE_POINTER;
    LABEL
	LB;
    BIND
	FWPTR = POINT(0, FW) ^(-18) AND %O'777777',
	LHPTR =	POINT(0,LH) ^(-18) AND %O'777777',
	RHPTR = POINT(0, RH) ^(-18) AND %O'777777';

    ! Check to see if value looks like a byte-pointer, in which case it
    ! will have position,size in LH.
    !

    BP = (IF .X<LH> EQL LHPTR
	 OR .X<LH> EQL FWPTR
	 OR .X<LH> EQL RHPTR
	 OR .X<24,6> EQL 7		! Char string?
	 OR .X<24,6> EQL 8		! Bliss-16 likes 8-bit bytes
	 OR .X<24,6> EQL 9		! APLSF uses 9-bit bytes
	THEN
	    .X 
	ELSE
	    0);

    DECR I FROM 1 TO 0 DO
LB:	BEGIN
	LOCAL
	    Z;

	Z = ( IF .I THEN .X<LH> ELSE .X<RH> );

	IF .Z LSS $JBDA				! JOBDAT areas shouldn't be
	THEN					!  printed symbolically?
	    BEGIN
	    IF .I AND .Z EQL 0 THEN LEAVE LB;
	    OUTDEFAULT(.Z)
	    END
	ELSE
	    BEGIN
	    LOCAL
		L	: SYMBOL,
		M;

	    L = SDDTFS(.Z);
	    M = .Z-.L[VALUEWRD];
	    IF (.WDBASE GEQ 0) AND (.M GTR .WDBASE)	! Value is too far from
	    THEN					!  symbolic name to be
		OUTDEFAULT(.Z)				!  printed as B+offset
	    ELSE
		BEGIN
		LOCAL
		    Q,		! Qualification information
		    F;

		Q=GQUAL(.L,.L[VALUEWRD]);
		OUTQUAL(.Q,0,QUALPREFIX);
		F=PRQ50(.L[RAD50NAME]);
		OUTQUAL(.Q,.F,QUALSUFFIX);
		IF .M NEQ 0 THEN (OUTC(%C'+');  OUTDEFAULT(.M))
		END;
	    END;
	IF .I THEN OUTS(',,')
	END;

    IF .BP NEQ 0
    THEN
	BEGIN
	OUTC(%C'<');
	OUTFD(.BP[P_POS],0);
	OUTC(%C',');
	OUTFD(.BP[P_SIZE],0);
	OUTC(%C'>')
	END

    END;
ROUTINE PRXDISP(X): NOVALUE=
!+
! FUNCTION
!	Print only base of .X<RH>
! INPUTS
!	X	- Fullword with Effective address(?) in RH.
!-
    PRQUAL( .X<RH> , 0);
! Routines to parse and display the stack
!

MACRO
	WITHINSIX12(PC) =
		((PC) GTR BEGINSIX12 AND (PC) LSS ENDSIX12) %,

	WITHINSIGNALHANDLER(PC)=
		BEGIN
		(PC) GEQA SIGNA$ AND (PC) LSSA SIGND$
		END %;
ROUTINE OUTQUAL (Q : SYMBOL, F, CODE): NOVALUE=
!+
! FUNCTION
!	Output a (possibly) qualified name
! INPUTS
!	Q	- Qualifying name (DDT symbol table entry) or numeric value
!	F	- Formatting flag?
!	CODE	- Indicates prefix or postfix qualification
! OUTPUTS
!	None
!-
    BEGIN
    IF .CODE EQL QUALPREFIX
    THEN
	IF .Q EQL -1
	THEN
	    RETURN			! No qualification present
	ELSE
	    IF  .Q LSS 0
	    THEN
		BEGIN
		IF .Q<RH> NEQ .GQUALIFIER<RH> THEN PRQ50(.Q[RAD50NAME]);
		OUTC(%C'\');
		RETURN
		END
	    ELSE
		RETURN;

    IF .CODE EQL QUALSUFFIX AND .Q LSS 0 THEN RETURN;	! Ignorable %n suffix

    IF .F THEN OUTC(%C' ');
    OUTC(%C'%');
    OUTDEFAULT(.Q)
    END;
ROUTINE GQUAL(S: SYMBOL,V)=
!+
! FUNCTION
!	???
! Inputs:
!	S - Radix50 symbol
!	V - value of the symbol
!
!	Returns one of three conditions:
!	-1 => no qualification required
!	-1,,x => x is DDT symbol table address of module qualifier
!	n => %n qualification
!
!	Use is to call GQUAL to get qualification code, then
!	call OutQual, which decodes it.  OutQual also looks at
!	Qualifier to decide if name is to be printed at all
!-
    BEGIN
    LOCAL
	P	: SYMBOL,
	LJ,
	J,
	LP	: SYMBOL;

    P = 0;
    J = 0;

    WHILE 1 DO
	BEGIN						%(global search)%
	J = .J + 1;
	IF (P=NSDDTFA(.S[RAD50NAME],.P)) EQL 0
	THEN
	    BEGIN %(found all)%
	    ! if 0 on second try, symbol is unique
	    IF .J EQL 2 THEN EXITLOOP %(global search)%;
	    ! symbol is not unique if .J gtr 2
	    IF .J GTR 2 THEN
		BEGIN %(not unique so far)%
		LOCAL
		    P1	: SYMBOL,
		    MN	: SYMBOL;

		MN = MODNAME(.LP);
		P1 = (-.MN[SYMBOLCNT] ^18) OR .MN<RH>;

		INCR K FROM 1 DO
		    BEGIN			%(see if unique in module)%
		    IF (P1=NSDDTFA(.S[RAD50NAME],.P1)) EQL 0
		    THEN
			BEGIN %(local failure)%
			! if local failure on second try,
			! module qualification makes it unique
			IF .K EQL 2 THEN RETURN -1^18 OR .MN;
			IF .K GTR 2 THEN EXITLOOP %(see if unique in module)%;
			END %(local failure)%;
		    END %(see if unique in module)%;
		END %(not unique so far)%;
		! if we get here,the local search was also
		! ambiguous, so we return the numeric qualifier
		RETURN .LJ;
	    END %(found all)%
	ELSE
	    BEGIN %(found it)%
	    ! is this symbol the value we want?
	    !
	    IF .P[RAD50FLAG] EQL DDT$_MODULE
	    THEN
		J = .J - 1
	    ELSE
		IF .P[SYMBOLVAL] EQL .V<RH>
		THEN
		    BEGIN %(right value)%
		    LJ = .J;
		    LP = .P
		    END %(right value)%
	    END %(found it)%
	END %(global search)%;

    RETURN -1
    END %(gqual)%;
ROUTINE PRQUAL(X,DISP):NOVALUE=
!+
! FUNCTION
!	Given an address X, print out the symbol which matches it
!	and add qualification if the name is not unique
!-
    BEGIN

    LOCAL
	S	: SYMBOL,
	P,
	D,
	V,
	F;

    IF .X<RH> LSS $JBDA
    THEN
	BEGIN
	OUTDEFAULT(.X<RH>);
	RETURN
	END;

    S = SDDTFS(.X<RH>);
    D = (IF .DISP THEN .X<RH>-.S[VALUEWRD] ELSE 0);	! compute displacement

    V = .S[VALUEWRD];				! symbol value we are using
    P = GQUAL(.S,.V);
    OUTQUAL(.P,0,QUALPREFIX);
    F = PRQ50(.S[RAD50NAME]);



    OUTQUAL(.P,.F,QUALSUFFIX);
    IF .D NEQ 0 THEN 
	BEGIN
	OUTC(%C'+');
	OUTDEFAULT(.D)
	END;
    END;
GLOBAL ROUTINE SIXDPY(A):NOVALUE=
    BEGIN
    PRQUAL(.A<RH>,1)
    END;
ROUTINE PRQUALBP(ENTRY:$BYTE_POINTER):NOVALUE=
!+
! FUNCTION
!	Print byte pointer for saving MONITOR location
! INPUTS
!	ENTRY	- Hardware Byte-pointer
!-
    BEGIN
    LOCAL
	T	: $BYTE_POINTER,
	D	: SYMBOL;

    D = SDDTFS(.ENTRY[P_OFFSET]);

    D = (.ENTRY[P_OFFSET] -.D[VALUEWRD] NEQ 0) AND .ENTRY[P_POS_SIZE] NEQ 0;
    IF .D  THEN OUTC(%C'(');
    PRQUAL(.ENTRY[P_OFFSET], 1);		! PRINT NAME
    IF .D  THEN OUTC(%C')');
    IF .ENTRY[P_POS_SIZE] NEQ %BPVAL		! Non-fullword pointers are
    THEN					!  to be qualified
	BEGIN			! PRINT <P,S>
	OUTC(%C'<');
	OUTFD(.ENTRY[P_POS],0);
	OUTC(%C',');
	OUTFD(.ENTRY[P_SIZE],0);
	IF .ENTRY[P_INDEX] NEQ 0
	THEN
	    BEGIN
	    OUTC(%C',');  OUTFD(.ENTRY[P_INDEX],0);
	    OUTC(%C',');   OUTD(.ENTRY[P_INDIRECT]);
	    END;
	OUTC(%C'>');
	END;
    END;
%SBTTL 'Stack-frame, argument-list processing'

FIELD
    FRAME_FIELDS=
	SET
	NEXT_FRAME=	[0, 0,18,0],	! Pointer to caller's frame
	RET_ADDRESS=	[-1,0,18,0],	! Saved return PC
	ARGS_BASE=	[-1,0, 0,0],	! Just before last argument
	LOCALS_BASE=	[ 1,0, 0,0],	! Base of local storage
	ENABLE_CHAIN=	[ 1,0,36,0]	! Pointer to ENABLE block
	TES;

MACRO
    $FRAME = HBLOCK FIELD(FRAME_FIELDS) %,

    !+
    ! B36 argument lists are pushed left-to-right.  Thus the first formal is
    !  deepest on the stack.  For an argument list of size LIM, this macro
    !  provides a BLOCK field-value for the "N"th actual. (Arguments are
    !  numbered 1..LIM
    !-
    ARG_N_OF_M(N,LIM)= (-(LIM+1)) + N + %FIELDEXPAND(ARGS_BASE,0),0,36,0 %;

MAP
    ENTERPNT	: $FRAME;
ROUTINE GETARGBASE(F: $FRAME,N)=
!+
! FUNCTION
!	Return address of 1st actual-parameter in a frame.
! INPUTS
!	F	- Pointer to FRAME
!	N	- Number of actual parameters in the call
!		  which "entered" this frame
! OUTPUTS
!	return the address of the first actual parameter
!-
	F[ARG_N_OF_M(1,.N)];


ROUTINE GETCALLFROM(F: $FRAME)=
!+
! FUNCTION
!	Return address of caller of the frame
! INPUTS
!	F	- Procedure call frame address
! OUTPUTS
!	Address of a PUSHJ or PJSRT instruction
!-
    .F[RET_ADDRESS] - %UPVAL;
ROUTINE GETARGCNT(F:	$FRAME)=
!+
! FUNCTION
!	GET ARG COUNT of CURRENT CALL GIVEN FRAME POINTER
!-
    BEGIN
    LOCAL
	NP,
	INSTRPC	: REF $INSTRUCTION;

    INSTRPC = .F[RET_ADDRESS];

    WHILE .INSTRPC[M_LHALF] EQL JRSTOP^9 DO	! JRST 0,-
	INSTRPC = .INSTRPC[M_OFFSET];		! Follow cross-jumping chain

    NP = 0;

    IF .INSTRPC[M_LHALF] EQL (SUBOP^9 OR SREG^5)	! SUB
    THEN
	NP = ..INSTRPC[M_OFFSET] AND %O'777777'
    ELSE
	IF .INSTRPC[M_LHALF] EQL (ADJSPOP^9 OR SREG^5)	! ADJSP
    THEN
	NP = - .INSTRPC[M_IMMEDIATE];

    IF .NP LSS 0 THEN NP = 0;

    .NP
    END;
ROUTINE GETARGADR(N,FRAME: $FRAME)=
!+
! FUNCTION
!	Get address of the n'th argument of given frame.
!	If FRAME IS ZERO then USE CURRENT FRAME.
! INPUTS
!	N	- argument index
!	FRAME	- pointer to procedure frame
! OUTPUT
!	Returns address of stack location if found, or -1 if there is no
!	actual parameter.
!-
    BEGIN
    LOCAL
	ARGLIST	: REF VECTOR,
	F	: $FRAME,
	NA;

    IF .RTNLVL LSS 0 THEN RETURN -1;

    F = (IF .FRAME EQL 0 THEN .ENTERPNT[NEXT_FRAME] ELSE .FRAME<RH>);
    NA = GETARGCNT(.F);

    IF .N LSS 1 OR .N GTR .NA THEN RETURN -1;

    ARGLIST = GETARGBASE(.F,.NA);

    ARGLIST[.N-1]		! List is zero-origined, but arguments
    END;			!  are enumerated 1..N
ROUTINE GETLCLCNT(PREVF : $FRAME)=
!+
! FUNCTION
!	Get number of locals for stack frame before given frame.
! INPUT
!	PREVF	- Pointer to a stack frame
! OUTPUT
!	Count of local parameters
!-
    BEGIN
    LOCAL
	F	: $FRAME,
	NL;

    PREVF = .PREVF<RH>;				! Clean address-pointer
    F = .PREVF[NEXT_FRAME];			! ADDRESS of FRAME of INTEREST
    IF .F EQL 0 THEN RETURN 0;			!  This is root, can't help you

    IF .PREVF NEQ .ENTERPNT<RH>
    THEN
	BEGIN
	NL = .PREVF -.F -2;			! Distance between two frames
						!  is # of locals (approx),
						!  less saved FP and return PC
	NL = .NL - GETARGCNT(.PREVF)		! Exclude actual parameters to
	END					!  later routine.
    ELSE
	! This is frame which caused us to enter SIX12.  Thus, everything
	!  between .ENTERPNT and the "saved" value of SP is a local for
	!  this routine.
	!
	IF .ENTERSP<RH> GTR .ENTERPNT<RH>
	THEN
	    NL = .ENTERSP<RH> - .ENTERPNT<RH>
	ELSE
	    NL = 0;

    IF .NL LEQ 0 THEN RETURN 0;

    .NL
    END;
ROUTINE GETLCLADR(N, PREVF : $FRAME)=
!+
! FUNCTION
!	Get address of n'th Local of frame before PREVF
! INPUTS
!	N	- Index of LOCAL
!	PREVF	- Frame pointer
! OUTPUT
!	Address of the local or -1 if out of bounds.
!-
    BEGIN
    IF .RTNLVL LSS 0 THEN RETURN -1;

    IF .N LSS 1 THEN RETURN -1;				! Bad local#, too small

    IF .PREVF EQL 0
    THEN
	BEGIN						! Use current frame
	IF .N GTR GETLCLCNT(.ENTERPNT[NEXT_FRAME])
	THEN
	    RETURN -1;	! Too large...

	.ENTERPNT<RH> + .N
	END
    ELSE
	BEGIN
	IF .N GTR GETLCLCNT(.PREVF) THEN RETURN -1;
	.PREVF[NEXT_FRAME] + .N
	END
    END;
ROUTINE PRG(B: REF VECTOR,T): NOVALUE=
!+
! FUNCTION
!	Print a contiguous set of WORDS for stack display.
! INPUTS
!	B	- Pointer to vector of words
!	T	- Number of entries to print
!-
    INCR I FROM 0 TO .T-1 DO
	BEGIN 
	OUTDEFAULT(.I+1);
	OUTC(%C':'); OUTC(%C' ');
	PRDISP(.B[.I]);
	IF .I LSS .T-1
	THEN
	    IF .I
	    THEN
		(OUTCRLF(); OUTS('		') )	! Two tabs
	    ELSE
		OUTS('		')		! spc-spc-tab
	END;
ROUTINE PRCOUNTEDVECTOR(V: REF VECTOR): NOVALUE=
    BEGIN
    OUTS(' =[');
    OUTDEFAULT(.V[0]);
    OUTS(']: ');
	
    INCR I FROM 1 TO .V[0] DO
	BEGIN
	PRDISP(.V[.I]);
	OUTC(%C' ');
	IF .I MOD 6 EQL 0 THEN OUTCRLF();
	END;
    OUTCRLF()
    END;
ROUTINE PRHPARMS(F: $FRAME) : NOVALUE=
!+
! FUNCTION
!	Print argument-lists passed to a condition-handler.
! INPUT
!	F	- Pointer to a FRAME
! OUTPUTS
!	None
!-
    BEGIN
    LOCAL
	SIGNL,
	MECH,
	ENBL;

    OUTCRLF();
    SIGNL = GETARGADR(1,.F);
    MECH  = GETARGADR(2,.F);
    ENBL  = GETARGADR(3,.F);

    OUTS('Signalv at ');		! Condition signalled
    PRDISP(..SIGNL);
    PRCOUNTEDVECTOR(..SIGNL);		!  and the whole SIGNAL arg-list

    OUTS('Mechanismv at ');		! Mechanism information
    PRDISP(..MECH);
    PRCOUNTEDVECTOR(..MECH);

    OUTS('Enablev at ');		! ENABLE stuff
    PRDISP(..ENBL);
    PRCOUNTEDVECTOR(..ENBL);
    END;
ROUTINE PRCALL(F: $FRAME,CALLED: REF $INSTRUCTION)=
!+
! FUNCTION
!	Print a single Routine call with its parameters.
! INPUTS
!	F	- Pointer to FRAME
!	CALLED	- Pointer to instruction which did the call
! OUTPUTS
!	Returns address of instruction which called the routine whose
!	frame we are examining.
! NOTES
!	The condition-handling routines are treated special.  There are several
!	"internal" routines which interact to produce a SIGNAL.  Only the
!	last routine in the OTS (which calls the handler) will end up with
!	a mention in the routine-call display.
!
!	A side-effect of the above is that when a "CALL n" command is given,
!	that fewer than "n" frames will be displayed.
!-
    BEGIN
    LOCAL
	NP,			! NUMBER of PARAMETERS
	CALLFROM;		! Who called this routine..
    LABEL
	L;

    IF (CALLFROM = GETCALLFROM(.F)) LEQ 0 THEN RETURN 0;
    NP = GETARGCNT(.F);

    IF WithinSignalHandler(.CALLED<RH>) AND
	NOT WithinSignalHandler(.CALLFROM<RH>)
    THEN
	RETURN .CALLFROM<RH>;

    IF WITHINSIGNALHANDLER(.CALLFROM<RH>)
    THEN
	! Within SIGNAL Handler.  There are several possible cases.  If
	! the called routine is ALSO inside the OTS, then suppress it.
	!
	BEGIN
	IF NOT WITHINSIGNALHANDLER(.CALLED<RH>)
	THEN
	    BEGIN				%(print signal)%
	    ! Here we would like to print out
	    !   SIGNAL(nn)
	    !   SIGNAL_STOP(nn)
	    !   Doing UNWIND
	    !
	    BIND
		SIGVAL = .(F[LOCALS_BASE])+1;	! Signalled condition value



	    IF .UNWINDVALUE NEQ 0 AND .SIGVAL EQL .UNWINDVALUE
	    THEN
		OUTS('*** Doing UNWIND ***')
	    ELSE
		BEGIN
		IF .SIGVAL<0,3> EQL 4 
		THEN
		    OUTS('*** SIGNAL_STOP(')
		ELSE
		    OUTS('*** SIGNAL(');
		OUTDEFAULT(.SIGVAL);
		OUTS(') ***')
		END
	    END;
	RETURN(.CALLFROM<RH>)
	END %(in signal handler)%;


    PRXDISP(.CALLED);
    OUTS(%CHAR(9),'from',%CHAR(9));
    IF WITHINSIX12(.CALLFROM<RH>)
    THEN
	 OUTS('"within SIX12"')
    ELSE
	PRDISP(.CALLFROM);

L:  BEGIN
    IF .NP EQL 0
    THEN
	OUTS('  ( )')
    ELSE
	BEGIN
	IF .F[NEXT_FRAME] NEQ 0
	THEN
	    BEGIN
	    IF .NP EQL 3 AND WITHINSIGNALHANDLER(GETCALLFROM(.F[NEXT_FRAME]))
	    THEN
		BEGIN
		PRHPARMS(.F);
		LEAVE L
		END
	    END;

	OUTCRLF();
	IF .SIXHDR NEQ 0
	THEN
	    BEGIN %(user handler)%
	    LOCAL
		OLDRNAME,
		ABASE,
		ROUT	: SYMBOL;

	    ABASE = GETARGBASE(.F,.NP);
	    OLDRNAME = .RNAME;
	    INSIXHDR = 1;
	    ROUT = SDDTFS(.CALLED<RH>);
	    IF NOT (.SIXHDR)(.ROUT[VALUEWRD],F50TO6(.ROUT[NAMEWRD]),.ABASE,.NP,1)
	    THEN
		BEGIN %(user punted)%
		OUTS('	Actuals	');
		PRG( .ABASE, .NP);
		END;
	    INSIXHDR = 0;
	    RNAME = .OLDRNAME;
	    END %(user handler)%
	ELSE
	    BEGIN %(standard handler)%
	    OUTS('	Actuals	');
	    PRG( GETARGBASE(.F,.NP), .NP);
	    END %(standard handler)%;
	END;
    END;


    .CALLFROM<RH>
    END;
MACRO
    $ENABLE	= HBLOCK FIELD(ENABLE_FIELDS) %;

FIELD
    ENABLE_FIELDS=
	SET
	HANDLER_PTR=	[ 0, 0, 36, 0],		! Addr of HANDLER routine
	EXIT_PTR=	[ 1, 0, 36, 0]		! Addr of exit code to clean
						!  stack for unwinds, etc.
	TES;


!
!
!	efpnt.:
!	+------------+
!	|	    |----------+
!	+------------+		|		|		|
!				|		+---------------+
!				|		| rtn addr      |
!				|		+---------------+
!				|		| parms	 |
!				|		/		/
!				|		/		/
!				|		|		|
!				|		+---------------+
!				|		|   locals      |\
!				|		/		/ |
!				|		/		/ |
!				|		+---------------+ |
!				|		| rtn addr      | |
!				|		+---------------+ |
!				|		| parms	 | |
!				|		/		/ |
!				|		/		/ |
!				|		|	       |/
!				|		+---------------+
!				|		|   locals      |\
!				|		/		/ |
!				|		/		/ |
!				|		|		| |
!				|		+---------------+ |
!				|      ...<-----| enable ptr    | |
!				|	  	+---------------+ |
!				+------->+------| efpnt chain	| |
!					 |	+---------------+ |
!					 |	| rtn addr      | |
!					 |	+---------------+ |
!					 |	| parms		| |
!					 |	/		/ |
!					 |	/		/ |
!					 |	|		|/
!					 |	+---------------+
!					 |	|		|\
!					 |	   ...		  .
!					 |	| rtn addr      | |
!					 |	+---------------+ |
!					 |	| parms	 | |
!					 |		...	. .
!					 |	|		| |
!					 |      +---------------+ |
!					 |      | enable ptr    |-+--+
!					 |	+---------------+ |  |
!					 +----->| efpnt chain   | |  |
!						+---------------+ |  |
!							...	  .  |
!		+-------------+					     |
!		| handler  ptr|<-------------------------------------+
!		+-------------+
!		| exit ptr    |
!		+-------------+
ROUTINE PRHANDLER (F: $FRAME, EFP) =
!+
! FUNCTION
!	returns an updated EFP if in fact a handler is printed
!-
    BEGIN
    IF .F[NEXT_FRAME] NEQ 0 AND
	.F[NEXT_FRAME] LSS .F<RH>
    THEN
	BEGIN
	IF .EFP GTR .F[NEXT_FRAME] AND .EFP LSS .F<RH>
	THEN
	    BEGIN %( have active handler )%
	    LOCAL
		ECODE	: REF $INSTRUCTION;	! pointer to exit code

	    ECODE = ..(.EFP+1);
	    EFP = ..EFP;
	    WHILE .ECODE[M_OPCODE] NEQ DEBUGUUO DO
		BEGIN %( scan for call )%
		IF .ECODE[M_OPCODE] EQL PUSHJOP 
		THEN
		    SELECTONE .ECODE[M_OFFSET] OF
		    SET
		    [ SIGNA$, SIGST$ ]:
			EXITLOOP;	! SIGNAL or SIGNAL_STOP

		    [OTHERWISE]:
			BEGIN
			OUTCRLF();
			OUTS('	Handler: ');
			PRXDISP(.ECODE[M_OFFSET]);
			EXITLOOP
			END
		    TES
		ELSE
		    ECODE = .ECODE + 1;
		END %( scan for call )%;
	    END %(have active handler )%;
	END;
    RETURN .EFP;
    END;
ROUTINE PSTK(FBACK: $FRAME, SHOWLOCALS, LEVEL):NOVALUE=
!+
! FUNCTION
!	Display call stack to level "Level", "ShowLocals" controls
!	locals display.
!-
    BEGIN
    LOCAL
	F	: $FRAME,
	NAME,
	NL,
	EFP	: $ENABLE;

    EFP = .EFPNT$;

    ! now go down the chain (skipping the implicit SIX12 handler)
    ! until we get to the first handler below the SIX12 entry

    WHILE .EFP<RH> GTR .ENTERPNT<RH> DO EFP = ..EFP;

    IF .RTNLVL GEQ 0
    THEN
	NAME = .RNAME
    ELSE
	BEGIN
	IF (NAME = GETCALLFROM(.FBACK)) LSS 0 THEN RETURN;
	NAME = .(.NAME)<RH>;
	END;

    F = .FBACK<RH>;

    DO
	BEGIN
	LOCAL
	    NEWEFP;

	IF (NAME = PRCALL(.F,.NAME)) EQL 0 THEN RETURN;
	NEWEFP = PRHANDLER(.FBACK<RH>,.EFP);
	IF .SHOWLOCALS
	THEN 
	    BEGIN
	    NL = GETLCLCNT(.FBACK);
	    IF .NL GTR 0		! PRINT LOCALS
	    THEN
		BEGIN
		OUTCRLF();
		OUTS('	Locals	');
		IF .NEWEFP NEQ .EFP	! We found an ENABLE in this frame
		THEN
		    PRG( F[LOCALS_BASE]+2, .NL )	! Ignore ENABLE-list
		ELSE
		    PRG( F[LOCALS_BASE], .NL)		! Ignore saved FP
		END
	    END;
	EFP = .NEWEFP;
	CRLF;
	IF (.F[NEXT_FRAME] NEQ 0) AND (.F[NEXT_FRAME] LSS .F<RH>) AND NOT WITHINSIX12(.NAME<RH>)
	THEN
	    BEGIN
	    FBACK = .F;
	    F = .F[NEXT_FRAME]
	    END
	ELSE
	    RETURN
	END
    UNTIL (LEVEL = .LEVEL-1) LEQ 0;

    END;
%SBTTL	'Debug Interest Routines'
!		DEBUG INTEREST ROUTINES
!		-----------------------

!	The table ROUTS contains information about each Routine
!	in which the debug system is 'interested'.  The variable
!	NROUTS (initialized to -1) contains the index of the last
!	valid entry in ROUTS.  The structure of each entry in ROUTS
!	is
!		!------------------+------------------!
!		! INTEREST BITS    !  Routine ADDRESS ! 0
!		!------------------+------------------!
!		! POINTERS to      ! CONDITIONAL      ! 1
!		!  bit 19 action   !  bit 18 action   !
!		!------------------+------------------!
!		! Macro		   ! TEXTS	      ! 2
!		!  bit 21 action   !  bit 20 action   !
!		!------------------+------------------!
!		!		   !		      ! 3
!		!  bit 23 action   !  bit 22 action   !
!		!------------------+------------------!
!		!		   !		      ! 4
!		!  bit 25 action   !  bit 24 action   !
!		!------------------+------------------!
!
!	(A zero Macro pointer denotes unconditional action.)
!	Two values are associated with each bit in the interest bits
!	field.  If bit (35-n) indicates an abc type interest, then
!	ABCF is a Macro for the bit position in the entry, i.e. 0,N,1.
!	ABCV is a constant with a 1 in the corresponding bit, i.e. 1^N.
!
!	The Routine SETBIT(VAL) does the following for each Routine in @SIXRP:
!		1) Insert the Routine into ROUTS if it is not already there.
!		2) Turn on the interest bits indicated by val.
!		3) Put in conditional Macro pointers as required.
!
!	The Routine UNSETBIT(VAL) does the following for each Routine in @SIXRP:
!		1) Turn off the interest bits indicated by val.
!		2) Fix up flags if active TRACE or OPAQUE is being deleted.
!		3) If the interest bit field of any entry becomes
!		   zero, remove that entry from ROUTS.
!
FIELD
    ROUT_FIELDS=
	SET
	ROUT_INFO=	[0, 0, 36, 0],	! ADDR+INFO bits
	ROUT_ADDR=	[0, 0, 18, 0],	! Routine Address
	INTEREST_BITS=	[0, 18,18, 0],	! All interest bits, lumped together
	    BREAKF=	[0, 18, 1, 0],	! Routine BREAK set
	    ABREAKF=	[0, 19, 1, 0],	! Routine ABREAK set
	    OPQATF=	[0, 20, 1, 0],	! OPAQUE
	    OPQAFTF=	[0, 21, 1, 0],	! OPAQUE After
	    TRCATF=	[0, 22, 1, 0],	! TRACE
	    TRCAFTF=	[0, 23, 1, 0],	! ATRACE
	    TABREAKF=	[0, 24, 1, 0],	! ??
	    PREVSTEPF=	[0, 32, 1, 0],
	    PREVOFFF=	[0, 33, 1, 0],
	    IDIDONF=	[0, 34, 1, 0],
	    IDIDOFFF=	[0, 35, 1, 0],
	COND_18_ACT=	[1, 0, 18, 0],	! Conditional action on break
	COND_19_ACT=	[1, 18,18, 0],	! Conditional action on ABREAK
	COND_20_ACT=	[2, 0, 18, 0],
	COND_21_ACT=	[2, 18,18, 0],
	COND_22_ACT=	[3, 0, 18, 0],
	COND_23_ACT=	[3, 18,18, 0],
	COND_24_ACT=	[4, 0, 18, 0],
	COND_25_ACT=	[4, 18,18, 0]
	TES;

MACRO
    INTEREST(J) = 0,J,1,0 %,				! The j-th interest bit
    CNDACTION(J)= 1+((J-18)/2), (J AND 1)*18,18,0 %;	! Conditional text ptr
							!  for j-th action.

OWN
	ROUTS	: BLOCKVECTOR[ROUTSCNT,ROUTSIZE] FIELD(ROUT_FIELDS);
    
LITERAL
	BREAKV=BITVAL(18),		ABREAKV=BITVAL(19),
	OPQATV=BITVAL(20),		OPQAFTV=BITVAL(21),
	TRCATV=BITVAL(22),		TRCAFTV=BITVAL(23),
	TABREAKV=BITVAL(24),

	MAXACTRTN=24,

	PREVSTEPV=BITVAL(32),
	PREVOFFV=BITVAL(33),		IDIDONV=BITVAL(34),
	IDIDOFFV=BITVAL(35);
ROUTINE CFINDR(R)=
!+
! FUNCTION
!	CONDITIONAL FIND - locate the index of Routine R IN ROUTS.
! INPUTS
!	R	- ROUTINE Address
! OUTPUT
!	Index in ROUTS of the entry
!	-1 If not found
!-
    DECR I FROM .NROUTS TO 0 DO
	IF .ROUTS[.I,ROUT_ADDR] EQL .R<RH> THEN RETURN .I;
ROUTINE CINSERT(R)=
!+
! FUNCTION
!	Conditionally insert a routine into ROUTS, if it isn't there already.
! INPUTS
!	R	- Routine address
! OUTPUT
!	Return THE INDEX of R IN ROUTS. INSERT If NECESSARY
!-
    BEGIN
    LOCAL
	L;
    IF (L = CFINDR(.R)) GEQ 0 THEN RETURN .L;

    NROUTS = .NROUTS + 1;			! Not present, add it
    ROUTS[.NROUTS,ROUT_INFO] = .R<RH>;

    .NROUTS
    END;
ROUTINE CREMOVE(R,VAL): NOVALUE=
!+
! FUNCTION
!	Conditional remove. Turn off bits specified by VAL in
!	the entry for R. Delete R if no other interest bits are set.
! INPUTS
!	R	- A routine address
!	VAL	- Mask of un-interesting bits
!-
    BEGIN
    LOCAL
	L;

    IF (L = CFINDR(.R)) LSS 0 THEN RETURN;	! No EVENTs established

    IF (VAL = .ROUTS[.L,ROUT_INFO] AND .VAL) EQL 0
    THEN				! The EVENTs we are looking at aren't
	RETURN;				!  interesting for this routine.

    IF (.VAL AND OPQAFTV) NEQ 0 AND .ROUTS[.L,IDIDOFFF]
    THEN
	BEGIN
	OPQCNT = 0;
	TRACEFLAG = -.ROUTS[.L,PREVOFFF];
	STEPFLAG = -.ROUTS[.L,PREVSTEPF];
	ROUTS[.L,ROUT_INFO] = .ROUTS[.L,ROUT_INFO] AND NOT (IDIDOFFV+PREVOFFV+PREVSTEPV)
	END;

    IF (.VAL AND TRCAFTV) NEQ 0 AND .ROUTS[.L,IDIDONF]
    THEN
	TRCCNT = TRACEFLAG = ROUTS[.L,IDIDONF] = 0;

    ROUTS[.L,ROUT_INFO] = .ROUTS[.L,ROUT_INFO] AND NOT .VAL;

    DECR IDX FROM MAXACTRTN TO 18 DO
	BEGIN
	MAP
	    VAL	: BITVECTOR;			! Count number of conditions
	IF .VAL[.IDX] THEN INCRTOG;		!  which are active?
	END;

    IF .ROUTS[.L,INTEREST_BITS] NEQ 0 THEN RETURN;	! Still some EVENTs
							!  of interest

    ! Nothing interesting remains for this routine.  Remove it from the
    ! table, by copying up the last routine in the table into the deletion
    ! slot
    !
    IF .L LSS .NROUTS
    THEN						! Fill in empty holes
	DECR J FROM ROUTSIZE-1 TO 0 DO			!  by copying down
	    ROUTS[.L,.J,FW] = .ROUTS[.NROUTS,.J,FW];

    NROUTS = .NROUTS -1
    END;
ROUTINE SETTBLBIT(ROUTN,ISITEXIT):NOVALUE=
!+
! FUNCTION
!	This routine sets a bit in the DEBUG UUO instruction itself,
!	indicating that this routine is "interesting"
! INPUT
!	ROUTN	- Routine address
!	ISITEXIT- Flag indicating if we are setting action on routine-entry
!		  or routine exit.
!-
    BEGIN
    LOCAL
	PNTR	: REF $INSTRUCTION;

    PNTR = FNDDBGUUO(.ROUTN,.ISITEXIT);

    IF .PNTR LSS 0
    THEN
	(PRDISP(.ROUTN);  ERROR(6))
    ELSE
	CHKUWP( PNTR[0,TBLBIT] = 1 , .PNTR);

    ! This may be the DEBUG UUO for the unwind exit, try again
    !
    IF .PNTR[0,UNWINDBIT]
    THEN
	BEGIN
	PNTR = FNDDBGUUO(.PNTR+1,.ISITEXIT);
	IF .PNTR LSS 0 
	THEN
	    (PRDISP(.ROUTN); ERROR(6))
	ELSE
	    CHKUWP( PNTR[0,TBLBIT] = 1, .PNTR)
	END
    END;
ROUTINE SETBIT(VAL:BITVECTOR, FBEGIN, FEND):NOVALUE=
!+
! FUNCTION
!	Set interest bits and action-pointers into the ROUTS table
! INPUTS
!	VAL	- mask of interesting bits
!	FBEGIN	- Flag indicating interest at routine entry
!	FEND	- Flag indicating interest at routine exit
!
! IMPLICIT INPUTS
!	SIXLP[0]	- CH$PTR to conditional action text
!	SIXRP[0..N]	- ROUTINE addresses
! OUTPUT
!	None
!-
    BEGIN
    LOCAL
	L;

    IF .SIXLC EQL 0 THEN SIXLP = UPLIT(0);	! Unconditional Actions

    INCR IDX FROM 18 TO MAXACTRTN DO
	IF .VAL[.IDX]				! Interesting "event"
	THEN
	    DECR I FROM .SIXRC-1 TO 0 DO
		BEGIN
		L = CINSERT(.SIXRP[.I]);
		IF NOT .ROUTS[.L, INTEREST(.IDX)] THEN DECRTOG;	! New interest
		ROUTS[.L, INTEREST(.IDX)] = 1;			!  added
		ROUTS[.L, CNDACTION(.IDX)] = .SIXLP[0];

		! Mark routine entry and exit as necessary
		!
		IF .FBEGIN NEQ 0 THEN SETTBLBIT(.(SIXRP[.I])<RH>,0);
		IF .FEND NEQ 0 THEN SETTBLBIT(.(SIXRP[.I])<RH>,1)
		END;
    END;
ROUTINE UNSETBIT(VAL)=
    DECR I FROM .SIXRC-1 TO 0 DO CREMOVE(.SIXRP[.I],.VAL);
ROUTINE XBREAK:NOVALUE=
    BEGIN
    SETBIT(BREAKV,1,0);
    BUGCHECK(-34,RETURN)
    END;

ROUTINE DBREAK : NOVALUE=UNSETBIT(BREAKV);

ROUTINE XABREAK:NOVALUE=SETBIT(ABREAKV,0,1);

ROUTINE DABREAK : NOVALUE =UNSETBIT(ABREAKV);

ROUTINE OPAQUE:NOVALUE=
	SETBIT(OPQAFTV+(IF .MODEFLAG NEQ 1 THEN OPQATV ELSE 0),1,1);

ROUTINE DOPAQUE : NOVALUE=
	UNSETBIT(OPQAFTV+(IF .MODEFLAG NEQ 1 THEN OPQATV ELSE 0));
ROUTINE XTRACE:NOVALUE=
    BEGIN
    SETBIT((CASE .MODEFLAG FROM 0 TO 2 OF
		SET
		[0]:	TRCATV;
		[1]:	TRCAFTV;
		[2]:	TRCAFTV+TRCATV
		TES
	    ),1,1);

    BUGCHECK(-34,0)
    END;
ROUTINE DTRACE=
	UNSETBIT(CASE .MODEFLAG FROM 0 TO 2 OF
		SET
		[0]:	TRCATV;
		[1]:	TRCAFTV;
		[2]:	TRCAFTV+TRCATV
		TES
		);
ROUTINE STABREAK(RTN): NOVALUE=
!+
! FUNCTION
!	Set a Temporary ABREAK on a routine.
! INPUT
!	RTN	- routine address
!-
    BEGIN
    STACKLOCAL
	L;			! Dummy for SIXRP target

    SIXLC=0;			! fake unconditional break
    SIXRC=1;
    SIXRP=L;			! pointer to name of routine
    L=(.RTN);			! name of routine

    SETBIT(TABREAKV,0,1)	! go set bit
    END;

ROUTINE DSTABREAK(RTN): NOVALUE=
!+
! FUNCTION
!	???
! INPUTS
!	RTN	- Routine address with a possible TRACE after
!-
    BEGIN
    LOCAL
	L;

    SIXRC=1;
    SIXRP=L;
    L=(.RTN);
    UNSETBIT(TABREAKV)
    END;
%SBTTL	'Monitor|Watch Variables'
!		MONITORING of VARIABLES
!		-----------------------

! The monitoring routines use another table with two-word entries,
! formatted
!
!	!---------------!---------------!
!	!	WATCHED_LOCATION	!
!	!---------------!---------------!
!	!	WATCHED_VALUE		!
!	!---------------!---------------!
!
! where location is a *pointer* to the byte being monitored
! (i.e. it has a position, size field),  and value is the
! byte's last reported contents.

FIELD
    WATCH_FIELDS=
	SET
	WATCHED_LOCATION=	[0, FW],	! Address
	WATCHED_VALUE=		[1, FW]		! Old value
	TES;

OWN
    MONVALS:	BLOCKVECTOR[MONITCNT,2] FIELD(WATCH_FIELDS);

MACRO
	WATCHTAG=0, WATCHFLAG %;
ROUTINE PRBPTR(ENTRY:$BYTE_POINTER):NOVALUE=
!+
! FUNCTION
!	Print out a PDP-10 byte-pointer being used for WATCH or MONITOR
!	points.
! INPUT
!	ENTRY	- Hardware byte pointer
!-
    BEGIN

    PRDISP(.ENTRY[P_OFFSET]);				! PRINT NAME

    IF .ENTRY[P_POS_SIZE] NEQ 36	! Non-fullwords get qualified <p,s>
    THEN
	BEGIN			! PRINT <P,S>
	OUTC(%C'<');
	OUTFD(.ENTRY[P_POS],0);
	OUTC(%C',');
	OUTFD(.ENTRY[P_SIZE],0);
	IF .ENTRY[P_INDEX] NEQ 0
	THEN
	    BEGIN
	    OUTC(%C',');  OUTD(.ENTRY[P_INDEX]);
	    OUTC(%C',');  OUTD(.ENTRY[P_INDIRECT]);
	    END;
	OUTC(%C'>')
	END
    END;
ROUTINE PRMVALSNAM(ENTRY: $BYTE_POINTER):NOVALUE=
!+
! FUNCTION
!	Print byte pointer with W(atch) or M(onitor) indicator
! INPUT
!	ENTRY	- Hardware byte pointer
!-
    BEGIN
    IF .ENTRY<WATCHFLAG> THEN OUTC(%C'W') ELSE OUTC(%C'M');
    OUTC(%C'-'); OUTC(%C' ');
    PRBPTR(.ENTRY)
    END;
ROUTINE CKVALS(RTN,TOG):NOVALUE=
!+
! FUNCTION
!	CHECK FOR CHANGED VALUES IN THE MONITOR TABLE
! INPUTS
!	RTN	- Address
!	TOG	- Controls printout as follows
!			TOG < 0		Internal call, not from a user
!					routine. [Probably XASSIGN]
!			TOG >= 0	Called during DEBUG UUO processing
!
!			TOG<0,1>	1 = Break AFTER
!					0 = Break BEFORE
!
!-
    BEGIN
    DECR I FROM .NVALS TO 0 DO
	BEGIN
	LOCAL
	    X;

	X = SCANN(MONVALS[.I,WATCHED_LOCATION]);
	IF .X NEQ .MONVALS[.I,WATCHED_VALUE]
	THEN
	    BEGIN
	    IF .TOG GEQ 0
	    THEN
		BEGIN
		OUTS('*** ');
		IF .TOG
		THEN
		    OUTS('During ')
		ELSE
		    OUTS('Before ');

		IF NOT .MONVALS[.I,WATCHTAG] THEN TOG = -1;
		PRXDISP(.RTN);
		IF .TOG THEN 0 ELSE
		    BEGIN
		    OUTS(' from ');
		    PRDISP(GETCALLFROM(.ENTERPNT))
		    END;
		CRLF
		END;

	    PRMVALSNAM(.MONVALS[.I,0,FW]);
	    PUTTAB;
	    OUTS('Old: ');
	    OUTDEFAULT(.MONVALS[.I,WATCHED_VALUE]);
	    PUTTAB;
	    OUTS('New: ');
	    OUTDEFAULT(.X);
	    CRLF;
	    MONVALS[.I,WATCHED_VALUE] = .X
	    END
	END;

    IF .TOG EQL -1  THEN STOPIT()
    END;
ROUTINE XPRINTMON:NOVALUE=
!+
! FUNCTION
!	COMMAND: PRINT MONITOR
!-
    BEGIN
    IF .NVALS LSS 0 THEN RETURN OUTS('No monitored locations',%CHAR(13,10));

    DECR I FROM .NVALS TO 0 DO
	BEGIN
	PRMVALSNAM(.MONVALS[.I,0,FW]);
	OUTS(%STRING(%CHAR(9),'= '));
	OUTDEFAULT(.MONVALS[.I,WATCHED_VALUE]);
	DBLEQL();
	PRDISP(.MONVALS[.I,WATCHED_VALUE]);
	CRLF
	END
    END;
ROUTINE DOMON(WATCHBIT):NOVALUE=
!+
! FUNCTION
!       Implements MONITOR and WATCH commands
! INPUTS
!       WATCHBIT	- 0=> MONITOR command
!			 1=> WATCH command
!-
    BEGIN
    LABEL
	L;
    LOCAL
	X;
    MAP
	SIXRP	: REF BLOCKVECTOR[, 1] FIELD(BYTEPOINTER_FIELDS);

    IF .SIXRC EQL 0
    THEN
	! Report current entries
	!
	BEGIN
	MODEFLAG = 4;		! SO XPRINTMON WILL BE CALLED
	RETURN
	END;

    ! MAKE A NEW ENTRY
    !
    DECR I FROM .SIXRC-1 TO 0  DO
L:	BEGIN
	IF .SIXRP[.I,P_LHALF] EQL 0	! Change address to a valid byte-ptr
	THEN				!  with <0,36>
	    SIXRP[.I,P_LHALF] = %O'004400';

	IF .SIXRP[.I,P_INDEX] NEQ 0 OR
	    .SIXRP[.I,P_INDIRECT]	! Having index-reg or indirect is
	THEN				!  frowned upon
	    (PRMVALSNAM(.SIXRP[.I,P_FWORD]);  RETURN ERROR(18));

	IF NOT ISREADABLE(.SIXRP[.I,P_FWORD] AND AddrMask)
	THEN
	    BEGIN
	    ILLMEM = .SIXRP[.I,P_FWORD] AND AddrMask;
	    ERROR(IF NOT ISADDRESS(.ILLMEM) THEN 28 ELSE 33);
	    RETURN
	    END;

	DECR J FROM .NVALS TO 0 DO
	    IF (.MONVALS[.J,WATCHED_LOCATION] AND %O'777737777777')  EQL .SIXRP[.I,P_FWORD]
!					   ^^ mask out watch bit
	    THEN 
		BEGIN
		! same location, we may be changing watch flag
		MONVALS[.J,WATCHTAG] = .WATCHBIT;
		LEAVE L;
		END;
	DECRTOG;
	NVALS = .NVALS+1;
	MONVALS[.NVALS,WATCHED_LOCATION] = .SIXRP[.I,P_FWORD];
	MONVALS[.NVALS,WATCHTAG] = .WATCHBIT;
	MONVALS[.NVALS,WATCHED_VALUE] = SCANN(SIXRP[.I,P_FWORD])
	END;

    BUGCHECK(-34,0)
    END;
ROUTINE XMONITOR : NOVALUE= DOMON(0);

ROUTINE XWATCH: NOVALUE = DOMON(1);
ROUTINE XDMONITOR:NOVALUE=
!
! DELETE ENTRY from MONITOR VALUES TABLE
!
    BEGIN
	LABEL LB;
    LOCAL
	L;
    MAP
	SIXRP	: REF BLOCK;

    DECR I FROM .SIXRC-1 TO 0 DO
LB:	BEGIN
	IF .SIXRP[.I,LH,0] EQL 0
	THEN
	    SIXRP[.I,LH,0] = %O'004400';	! INSERT <FW>
	L = (
	    DECR J FROM .NVALS TO 0 DO
		IF (.MONVALS[.J,WATCHED_LOCATION] AND %O'777737777777')  EQL .SIXRP[.I,FW]
		THEN
		    EXITLOOP .J
	    );

	IF .L LSS 0
	THEN
	    BEGIN
	    OUTS('No entry for ');
	    PRMVALSNAM( .SIXRP[.I,FW] );
	    CRLF;
	    LEAVE LB;
	    END;
	INCRTOG;
	IF .L LSS .NVALS
	THEN
	    BEGIN
	    MONVALS[.L,WATCHED_LOCATION] = .MONVALS[.NVALS,WATCHED_LOCATION];
	    MONVALS[.L,WATCHED_VALUE] = .MONVALS[.NVALS,WATCHED_VALUE];
	    END;
	NVALS = .NVALS-1;
	END;
    END;
%SBTTL	'Miscellaneous Command Action Routines'

!		THE DEBUG PROCESSING ROUTINES
!		-----------------------------

ROUTINE DOTVREG =
!+
! FUNCTION
!	"No-op" routine which is used frequently in tables to provide a
!	default action routine with no nasty side-effects.
!-
    BEGIN
    REGISTER
	R = VREG;

    .R
    END;
ROUTINE RET612:NOVALUE=
!+
! FUNCTION
!	This routine restores the SIX12 registers saved by XDDT before
!	entering DDT.  Doing a POPJ SP, then returns us to where we were
!	relative to XDDT.
!
! NOTES
!	This routine is never called directly.
!-
    BEGIN
    REGISTER
	R;
    R = SIXACS^18;		! This is JRST-ed to to restore SIX12
    BLT(R,%O'17')		!  after a visit into DDT
    END;
ROUTINE XDDT:NOVALUE=
!+
! FUNCTION
!	This routine locates DDT, saves the registers and SP, and
!	jumps to the DDT entry-point.  ?.JBOPC is pre-loaded with
!	where to return to.  This is accessed by the DDT command
!			SIXRET$X
!	which results in a JRST @.JBOPC instruction.  RET612 is a
!	critical routine.
!
!	BEWARE:	There should be NO "STACKLOCAL" storage in this routine
!		either!
!-
    BEGIN
    REGISTER
	R;

    R = SIXACS;
    BLT(R,SIXACS[15]);		! Preserve the AC's when we enter DDT.

%IF EXTENDED
%THEN
    $JBOPC = 1^18+RET612;
%ELSE
    $JBOPC = (RET612);		! N.B. that this implies that you cannot
				!  actually modify a register from DDT, unless
				!  you modify SIXACS..SIXACS+15
%FI
%IF TOPS10
%THEN
    IF .$JBDDT<RH> EQL 0 THEN RETURN ERROR(21);
    JRST(0,.$JBDDT);
%ELSE
    BEGIN
    OWN
	SAVENTVEC;
    REGISTER
	PROTECTION;

    RPACS( $FHSLF^18 + %O'770'; PROTECTION );	! Check page 770 for ddt

    IF (.PROTECTION AND PA_PEX) EQL 0	! Non-existant page...
    THEN
	BEGIN
	LOCAL
	    JFN;

	GEVEC( $FHSLF ; SAVENTVEC );	! Save entry vector, GET will smash

	IF GTJFN( GJ_OLD+GJ_PHY+GJ_SHT,	! Old file, use system logicals
		MSG( 'SYS:UDDT.EXE');
		JFN)
	THEN
	    IF GET( $FHSLF^18 + GT_NOV + .JFN )
	    THEN
		SEVEC( $FHSLF, .SAVENTVEC )
	    ELSE
		RETURN ERROR(21)
	ELSE					! Can't find file, so quit with
	    RETURN ERROR(10);			!  appropriate message

	IF .$JBSYM NEQ 0		! Ensure symbols loaded
	THEN
	    .%O'770001' = .$JBSYM;	! Copy pointer into DDT

	.%O'770002' = .$JBUSY		! and undefined symbol pointer
	END;

    JRST(0,%O'770000')			! Always loads at this address
    END
%FI
    END;
ROUTINE SLASH(PARSE):NOVALUE=
!+
! FUNCTION
!       Print range of memory locations according to either the "!" infix
!       operator or the "/" postfix operator.
! INPUTS
!       PARSE   - indicates which parse was detected.
!-
    BEGIN
    LOCAL
	N;		      ! Number of locations to display
    MAP
	SIXLP   : HBLOCK;

    N = (IF .PARSE EQL 3 THEN .SIXRP[0] - 1 ELSE 0);

    INCRA A FROM .SIXLP[0,RH,0] TO .SIXLP[0,RH,0]+.N DO
	BEGIN
	PRDISP(.A);
	OUTC(%C'/');
	PUTTAB;
	IF NOT ISREADABLE(.A)
	THEN
	    BEGIN
	    OUTS('?');
	    CRLF;
	    EXITLOOP
	    END;
	OUTRDEF(..A,14);
	DBLEQL();
	PRDISP(..A);
	CRLF;

	IF ISON(ENABFLAG) AND ISOFF(NOPOLLFLAG) AND (.A MOD 4) EQL 0
	THEN
	    BEGIN		! During long type-outs, give user
%IF TOPS10			!  an opportunity to escape from
%THEN				!  "core-dump".....
	    IF SKPINL() THEN EXITLOOP;
%ELSE
	    IF NOT SIBE($PRIIN) THEN EXITLOOP;		! Input buffer empty
%FI
	    END
	END
    END;
ROUTINE GOER:NOVALUE=
    BEGIN
    IF ISON(TRACEFLAG) THEN DECRTOG;
    GOFLAG = 1;
    END;

ROUTINE CLRSTEP:NOVALUE=(SETOFF(STEPFLAG));

ROUTINE XGO:NOVALUE=(CLRSTEP(); GOER());

ROUTINE XNOPOLLON:NOVALUE=(SETON(NOPOLLFLAG));

ROUTINE XNOPOLLOFF:NOVALUE=(SETOFF(NOPOLLFLAG));

ROUTINE XCOPAQUE:NOVALUE=(SETON(COPQFLAG));

ROUTINE XNOCOPAQUE:NOVALUE=SETOFF(COPQFLAG);
ROUTINE DISAB:NOVALUE=(SETOFF(ENABFLAG));

ROUTINE XSTEP:NOVALUE=
    BEGIN
    BUGCHECK(35,RETURN);
    SETON(STEPFLAG);
    GOER()
    END;
ROUTINE XOK:NOVALUE=
! XOK performs the following actions
!	(1) set a temporary ABREAK at the current routine
!	(2) do a GO (XGO)
!
!	The temporary ABREAK is removed when encountered
!
	BEGIN

	BUGCHECK(35,RETURN );

	IF .RTNLVL EQL 0
	THEN			    ! OK works only at routine entry
	    BEGIN
	    STABREAK(.RNAME);
	    XGO()
	    END
	ELSE
	    ERROR(24)
	END;
ROUTINE XSTRACE:NOVALUE=
    BEGIN
    IF .OPQCNT GTR 0
    THEN
	BEGIN
	OPQCNT = 0;
	DECR J FROM .NROUTS TO 0 DO
	     ROUTS[.J,0,FW] = .ROUTS[.J,0,FW] AND NOT (IDIDOFFV+PREVOFFV+PREVSTEPV)
	END;
    SETON(TRACEFLAG);
    END;
ROUTINE XCLRTRACE:NOVALUE=(SETOFF(TRACEFLAG));
ROUTINE XGOTRACE:NOVALUE=(XSTRACE(); CLRSTEP();  GOER());
ROUTINE XGOCLR:NOVALUE=(SETOFF(TRACEFLAG); CLRSTEP(); GOER());
ROUTINE NOSIX12:NOVALUE=
!+
! FUNCTION
!       Disable SIX12's UUO handler by placing a JFCL 0 into location
!       41(8).
!-
    IF ISOFF(ERRORFLAG) THEN ($JB41 = DBG_OFF_INST;  GOER());
ROUTINE XDEBUG: NOVALUE=
!+
! FUNCTION
!	Set up debugging environment by making LUUO trap location be
!	a call of the SIX12 UUO handler.
!-
    IF ISOFF(ERRORFLAG)
    THEN
	$JB41 = DBG_ON_INST;		! Transfer to UUOH
ROUTINE XBASE(K):NOVALUE=
!+
! FUNCTION
!	Set default radix for type-in and type-out.
! INPUTS
!	K	- distinguishes between NILADIC and PREFIX command form
! NOTES
!	SIXRP[0] contains new radix.
!-
    BEGIN		! set IOBase
    IF .K
    THEN
	BEGIN
	IF .SIXRP[0] EQL 0 THEN (.SIXRP) = 8;
	IF ((.SIXRP[0] LSS 2) OR (.SIXRP[0] GTR 10))
	THEN
	     RETURN ERROR(5)
	ELSE
	     (IOBASE = .SIXRP[0])
	END;

    OUTD(.IOBASE);
    OUTS(' decimal');
    OUTCRLF()
    END;
ROUTINE XWBASE(K):NOVALUE=
    BEGIN		! set WDBase
    IF .K THEN WDBASE = ..SIXRP;
    OUTDEFAULT(.WDBASE);
    CRLF;
    END;
ROUTINE XBACKTO:NOVALUE=
    BEGIN
    IF .DEPTH LEQ 1
    THEN
	RETURN ERROR(29);		! no place to go back to
    IF .SIXRP[0] EQL .DEPTH THEN RETURN;	! Already there!

    IF .SIXRP[0] GTR .DEPTH THEN RETURN ERROR(30);	! can't go back to deeper stack
    IF .UNWINDVALUE EQL 0 THEN RETURN ERROR(37);	! unwind will fail, don't do it
    ! do unwinding
    !
    WHACKS = .DEPTH - .SIXRP[0] + 1;	! how many levels to whack off

    SIGNAL( SIXUNWSIGNAL )
    END;
ROUTINE XPOP(N):NOVALUE=
    BEGIN
    LOCAL
	CNT;

    CNT = (IF .N EQL 0 THEN 1 ELSE .SIXRP[0]);

    IF .CNT GTR .DEPTH THEN CNT = .DEPTH;

    IF .DEPTH LEQ 1 THEN RETURN ERROR(29);	! no place to go back to
    IF .CNT EQL 0 THEN RETURN;			! already there!

    IF .CNT LSS 0
    THEN
	BEGIN
	CNT = (-.CNT) + .DEPTH;
	RETURN ERROR(30);		! can't go back to deeper stack
	END;

    IF .CNT GEQ .DEPTH THEN CNT = .DEPTH;

    IF .UNWINDVALUE EQL 0 THEN RETURN ERROR(37);	! Unwind will fail, don't do it!

    ! do unwinding
    !

    WHACKS = .CNT+1;				! how many levels to whack off

    SIGNAL( SIXUNWSIGNAL )
    END;
ROUTINE XSIGNAL:NOVALUE=
    BEGIN
    SIGNAL( .SIXRP[0] )
    END;
ROUTINE XSETUNWIND:NOVALUE=
    BEGIN
    SETUNWIND()
    END;
ROUTINE EXITSIGNAL(P,V,KIND):NOVALUE=
!+
! FUNCTION
!	This implements the RESUME and RESIGNAL commands
! INPUT
!	P	- Indicates parse to use, either NILADIC or PREFIX
!	V	- Value to leave in SIXRP[0]
!	KIND	- Is this RESUME or RESIGNAL
! OUTPUTS
!	None
!-
    BEGIN
    !	Here we see if our return address is in WithinSignalHandler
    !	If not, we do an Error(27)
    !
    LOCAL
	F	: $FRAME;

    F = .ENTERPNT;
    IF .F[NEXT_FRAME] NEQ 0 AND
	.F[NEXT_FRAME] LSS .F<RH>
    THEN
	F = .F[NEXT_FRAME]
    ELSE
	BEGIN
	ERROR(27);	! first failure...FREG will be at least
			! depth 2 in signal handler!
	RETURN
	END;

    IF NOT WITHINSIGNALHANDLER(GETCALLFROM(.F<RH>)) 
    THEN
	BEGIN
	ERROR(27);	! second failure...return address is
			! not to signal handler
	RETURN
	END;

    !	We now know that we are about to return to the signal
    !	handler.  First, we modify the value of the signal
    !	or return value if necessary

    IF .P						! MONADIC
    THEN
	BEGIN %(modify values)%
	LOCAL
	    S	: REF VECTOR;

	! Now, what we WANT here is that S=GetArgAdr(n,.F<RH>)
	! but since the signal handler doesn't follow strict
	! parameter passing protocols, GetArgAdr will fail.
	! However, by this point we KNOW that we are being called
	! from a signal handler routine, so the following code
	! will indeed return the correct address of the parameter
	IF .KIND EQL DORESUME THEN
	    BEGIN %(resuming)%
	    S = .F[ARG_N_OF_M(2,3)];		! get address of mechanism
						! vector
	    S[1] = .SIXRP[0];			! store return value
						! for signal call
	    END %(resuming)%;
	IF .KIND EQL DORESIGNAL THEN
	    BEGIN %(resignalling)%
	    S = .F[ARG_N_OF_M(1,3)];		! get address of first arg,
						! which is the signl vector
	    S[1] = .SIXRP[0];			! new value stored
	    END %(resignalling)%;
	END %(modify values)%;

    SIXRP[0] = .V;
    XRETURN()
    END;
ROUTINE XRESUME(P) : NOVALUE=
!+
! FUNCTION
!	This operator has two parses:
!		niladic: equivalent to the RETURN 1 command
!		monadic: sets the return value in the mechanism
!			vector to the value of SIXRP
!
!	This operator is valid only when in the signal handler
!	routine!
!
    BEGIN
    EXITSIGNAL(.P,1,DORESUME)
    END;
ROUTINE XRESIGNAL(P): NOVALUE=
!+
! FUNCTION
!	This operator has two parses:
!		niladic: equivalent to the RETURN 0 command
!		monadic: sets the signal value in the mechanism
!			vector to the value of SIXRP
!
!	This operator is valid only when in the signal handler
!	routine!
!-
    BEGIN
    EXITSIGNAL(.P,0,DORESIGNAL)
    END;
ROUTINE CALL1:NOVALUE=
!+
! FUNCTION
!	Implements the CALLS command
!-
    BEGIN
    OUTFLAG();
    PSTK( .ENTERPNT[NEXT_FRAME], 0,  BIGNUMBER )
    END;


ROUTINE CALL2:NOVALUE=
!+
! FUNCTION
!	Implement the LCALLS command
!-
    BEGIN
    OUTFLAG();
    PSTK( .ENTERPNT[NEXT_FRAME], 1, BIGNUMBER )
    END;


ROUTINE XCALL(K): NOVALUE=
!+
! FUNCTION
!	Implement the CALL or CALL <n> command
! INPUT
!	K	- indicates NILADIC or MONADIC parse
!-
    BEGIN
    OUTFLAG();
    PSTK( .ENTERPNT[NEXT_FRAME], 0, (IF .K THEN ..SIXRP ELSE 1) )
    END;


ROUTINE XLCALL(K): NOVALUE=
!+
! FUNCTION
!	Implement the LCALL and LCALL <n> commands
! INPUT
!	K	- Flag indicating NILADIC or MONADIC parse
!-
    BEGIN
    OUTFLAG();
    PSTK( .ENTERPNT[NEXT_FRAME], 1, (IF .K THEN ..SIXRP ELSE 1) )
    END;
ROUTINE ISADDRESS(P)=
!+
! FUNCTION
!	Is value an address in the user's address space?
! INPUTS
!	P	- Address value
! OUTPUT
!	True	- Valid address
!	False	- Non-existant memory
!-
    BEGIN
%IF TOPS10
%THEN
    IF .P<RH>  GTR .$JBREL<RH>	 AND	! not in lowseg
	.$JBHRL NEQ 0
    THEN
	IF .P<RH> GTR .$JBHRL<RH> OR
	   .P<RH>  LSS .$JBHRL<RH> - .$JBHRL<LH>
	THEN
	    RETURN 0;
    RETURN 1
%ELSE
    LOCAL
	PROTECTION;

    RPACS( $FHSLF^18 + (.P<RH>)^(-9) ; PROTECTION );

    (.PROTECTION AND (PA_CPY OR PA_PEX)) NEQ 0			! Does page exist?
%FI
    END;
ROUTINE ISREADABLE(P)=
!+
! FUNCTION
!	Check that the given address is "readable"
! INPUT
!	P	- address value
! OUTPUT
!	TRUE	- address can be read (no NXM trap will occur)
!	FALSE	- address is not mapped...
!-
    BEGIN
    LOCAL
	PAGENUM,
	PROTECTION;

%IF TOPS10
%THEN
    ISADDRESS(.P) 
%ELSE
    PAGENUM = (.P AND AddrMask)^(-9);

    RPACS( $FHSLF^18 OR .PAGENUM ; PROTECTION );

    (.PROTECTION AND PA_RD) NEQ 0
%FI
    END;
ROUTINE ISWRITABLE(P)=
!+
! FUNCTION
!	Determine if this address is writable.
! INPUTS
!	P	- Virtual address
! OUTPUTS
!	TRUE	- location may be written
!	FALSE	- location is non-writable
!-
    BEGIN
%IF TOPS10
%THEN
    RETURN 1
%ELSE
    LOCAL
	PAGENUM,
	PROTECTION;

    PAGENUM = (.P AND AddrMask)^(-9);
    RPACS( $FHSLF^18 OR .PAGENUM ; PROTECTION );

    (.PROTECTION AND (PA_WT OR PA_CPY)) NEQ 0	! Writable or copy on write...
%FI
    END;
ROUTINE ISROUTINE(P: REF $INSTRUCTION)=
!+
! FUNCTION
!	See if P is address of a BLISS routine.
! INPUT
!	P	- machine address of PDP-10/20 Instruction
! OUTPUT
!	0	- not a routine address
!	#0	- CH$PTR to descriptive text
!-
    BEGIN
    IF NOT ISREADABLE(.P) THEN RETURN 0;	! Location isn't addressable

    !+	
    ! It is certainly a routine if it contains any one of the
    ! instructions which start a routine, such as a DEBUG UUO
    !-
    SELECTONE .P[M_OPCODE] OF
	SET
	[DEBUGUUO]:
	    IF .P[0,NOVALUEBIT]
	    THEN
		RETURN MSG( 'NoValue Routine w/debug' )
	    ELSE
		RETURN MSG( 'Routine w/debug' );

	[PUSHOP,POPJOP,PUSHJOP]:
	    IF .P[M_REGF] EQL SREG
	    THEN
		RETURN MSG('Routine')
	    ELSE
		RETURN 0;

	[OTHERWISE]:
	    RETURN 0
	TES
    END;
ROUTINE PPSYM(P:SYMBOL, W):NOVALUE=	! Common code for PRS, SEARCH, PRM
!+
! FUNCTION
!	Formatted dump of selected portions of the symbol table.  Used by
!       PRS, PRM and SEARCH commands.
! INPUTS
!	P	- Pointer to symbol-table entry
!	W	- Width of symbol-name printed. (Used to align columns)
!-
    BEGIN
    LOCAL
	T,		      ! Pointer to a text string
	S;			! Count of symbols in a module

    IF .P[INVALIDFLAG]		! Smashed symbols get "*" to indicate
    THEN			!  no valid binding
	BEGIN
	OUTC(%C'*');
	W = .W + 1
	END;

    DECR I FROM 9-.W TO 0 DO OUTC(%C' ');

    IF .P[RAD50FLAG] NEQ DDT$_MODULE		! Not a module
    THEN
	OUTRDEF(.P[VALUEWRD],12);		! Display 36 bit value

    PUTTAB;

    CASE .P[RAD50FLAG] FROM DDT$_MODULE TO DDT$_OWN OF
	SET
	[DDT$_MODULE]:
		BEGIN				! Show addr of module base
		S = -.P[SYMBOLCNT];		! Get count of symbols
		OUTRDEF(.P[SYMBOLVAL],12);

		IF .P<RH> EQL .GQUALIFIER<RH>
		THEN
		    OUTC(%C'\')
		ELSE
		    OUTC(%C' ');
		OUTS('Module');
		PUTTAB;  PUTTAB;
		OUTDR(.S/2, 5);
		OUTS(' symbols');
		CRLF;
		RETURN
		END;

	[DDT$_GLOBAL]:
		OUTS(' Global');
	[DDT$_OWN]:
		OUTS(' Own');
	[OUTRANGE]:
		(CRLF; RETURN)
	TES;


    PUTTAB;  
    PRSYM50(MODDDT(.P)); 
    IF (T=ISROUTINE(.P[ADDRWRD])) NEQ 0
    THEN
	BEGIN
	PUTTAB;
	OUTSA(.T)
	END
    ELSE
	IF ISREADABLE(.P[ADDRWRD])
	THEN
	    BEGIN
	    PUTTAB;
	    OUTDEFAULT(.(.P[ADDRWRD]) );
	    IF (.P[RAD50NAME] / (%O'50'*%O'50'*%O'50')) EQL %RAD50_10 'P.'
		AND .(.P[VALUEWRD]) LSS 0 
		AND NOT .(.P[VALUEWRD])
	    THEN
		!+
		! Heuristics implying that the above is a "BIND" to a string
		! literal value
		!-
		BEGIN
		LOCAL
		    T,
		    C;

		T = CH$PTR(.P[ADDRWRD]);
		PUTTAB;
		OUTC(%C'''');
		INCR I FROM 0 TO 8 DO
		    BEGIN 
		    C = CH$RCHAR_A(T);
		    IF .C EQL 0 THEN EXITLOOP;
		    IF .C GEQ %C' '
		    THEN
			OUTC(.C)
		    ELSE
			BEGIN
			OUTC(%C'?');
			OUTC(.C+%O'100');
			END;
		    END;
		IF .C NEQ 0 THEN OUTS('...');
		OUTC(%C'''');
		END %(string? )%
	    ELSE
		IF .(.P[ADDRWRD]) GTR %O'40' AND
		    .(.P[ADDRWRD]) LSS %O'177'
		THEN				! Single ASCII character
		    BEGIN
		    PUTTAB;
		    OUTC(%C'"');
		    OUTC(.(.P[ADDRWRD]));
		    OUTC(%C'"')
		    END;
	END;

    CRLF
    END;
ROUTINE PRS:NOVALUE=
!+
! FUNCTION
!	Implements the PRS command
!	Prints all symbols which have the same name as the input.
!
!-
    BEGIN
    INCR I FROM 0 TO .SIXRC-1 DO
	BEGIN
	LOCAL
	    NAME,				! SIXBIT name to look up
	    P	: SYMBOL,			! Matching symbol
	    W;					! Field-width printed

	P = 0;					! Initially no symbols found
	NAME = .SIXRP[.I];			! Get next sixbit name

	INCR J FROM 1 DO
	    BEGIN
	    IF (P = NSDDTFA(.NAME,.P)) EQL 0
	    THEN
		BEGIN
		IF .J EQL 1
		THEN
		    (TTOUTS('No entry for ');  PRSYM50(.NAME);  CRLF);
		EXITLOOP
		END;

	    W = PRSYM50(.NAME);
	    IF .P[RAD50FLAG] NEQ DDT$_MODULE	! Print postfix numeric
	    THEN				!  qualification for any
		BEGIN				!  duplicated name.
		OUTC(%C'%');
		W = .W + 1;
		W = .W + OUTDEFAULT(.J)
		END
	    ELSE
		! Do not count module names in %-qualification
		J = .J -1;

	    PPSYM(.P,.W)
	    END
	END
    END;
ROUTINE PRMS(SYM,SYMNAME,CHAR): NOVALUE=
!+
! FUNCTION
!	Implement the PRM Command [ PRint Module ]
! INPUTS
!	Sym	- The symbol table to use
!	SymName	- The module name to print out, or 0 if all modules
!	Char	- the prefix character to use, either SPACE [LOWSEG] or
!		  UPARROW ("^") [HISEG]
!-
    BEGIN
    LOCAL
	R	: SYMBOL;

    R = - .SYM<LH,1>;
    R = (.R^18) + .R + .SYM<RH>;

    WHILE (R = .R-%O'2000002') GEQ 0 DO
	BEGIN
	IF .R[RAD50FLAG] EQL DDT$_MODULE
	THEN
	    BEGIN  %(have module name)%
	    IF .SYMNAME EQL 0 OR		! All modules
		.R[RAD50NAME] EQL .SYMNAME	!  or this specific one
	    THEN
		BEGIN %(want this one)%
		LOCAL
		    ME, 	    ! My module name
		    C;

		OUTC(.CHAR);
		C = PRSYM50(ME = .R[RAD50NAME]);
		PPSYM(.R<RH>,.C);
		IF .SYMNAME NEQ 0
		THEN
		    BEGIN %(names in module)%
		    LABEL DONAME;
		    WHILE (R = .R-%O'2000002') GEQ 0 DO
DONAME:			BEGIN %(print names)%
			LABEL CHECK;
			IF .R[RAD50FLAG] EQL DDT$_MODULE THEN RETURN;
			IF .R[RAD50NAME] EQL (%RAD50_10 '%%%%%%')+1
			THEN
			    LEAVE DONAME; ! Don't print suppressed SIX12 symbols
			OUTC(.CHAR);
			C = PRSYM50(.R[RAD50NAME]);
			PPSYM(.R<RH>,.C);

			! Now, do something about checking lowseg
			! consistency

			IF ISHIGHSYMBOLTABLE()
			THEN
CHECK:			    BEGIN %(check)%
			    LOCAL
				L	: SYMBOL,
				M	: SYMBOL;

			    IF .SYM NEQ .HCACHE OR .R[ADDRWRD] GEQ .IJOBHSM
			    THEN
				LEAVE CHECK; 		! symbol is in hiseg

			    M = - .$JBSYM<LH,1>;
			    M = (.M^18) + .M + .$JBSYM<RH>;

			    WHILE (M = .M- %O'2000002') GEQ 0 DO
				BEGIN %(scan lowseg for module)%
				IF .M[RAD50FLAG] EQL DDT$_MODULE AND
				   .M[RAD50NAME] EQL .ME
				THEN
				    EXITLOOP;
				END;
	    
			    IF .M LEQ 0 THEN LEAVE CHECK;	! module not in lowseg
			    L = NSDDTW(.R[RAD50NAME], .M, .$JBSYM);
			    IF .L[VALUEWRD] NEQ .R[VALUEWRD]
			    THEN
				PPSYM(.L<RH>,0)
			    END %(check)%;
			END %(print names)%;
		    END %(names in module)%;
		END %(Want this one)%;
	    END %(have module name)%;
	END;
    END;
ROUTINE PRM:NOVALUE=
!+
! FUNCTION
!	Null: Print out all module names
!	Prefix: Print out all symbols in module names given
!-
    BEGIN
    IF .SIXRC EQL 0
    THEN
	BEGIN
	IF ISHIGHSYMBOLTABLE() THEN PRMS(.HCACHE,0,%C'^');
	PRMS(.$JBSYM, 0,%C' ')
	END
    ELSE
	BEGIN %(just what we asked for)%
	INCR I FROM 0 TO .SIXRC-1 DO
	    BEGIN %(see if requested)%
	    IF ISHIGHSYMBOLTABLE()
	    THEN
		PRMS(.HCACHE, .SIXRP[.I], %C'^');

	    PRMS(.$JBSYM, .SIXRP[.I], %C' ')
	    END
	END
   END;
ROUTINE QUAL : NOVALUE=
!+
! FUNCTION
!	Set up default qualification value for symbol table lookups
!-
    BEGIN
    MAP
	GQUALIFIER	: SYMBOL;
    LOCAL
	S;

    IF .SIXRC EQL 0
    THEN
	BEGIN %(print out)%
	IF .GQUALIFIER EQL 0
	THEN
	    BEGIN
	    OUTS('No default module name');
	    OUTCRLF();
	    RETURN
	    END;

	! otherwise, the GQualifier points to the module name
	! entry
	IF ISHIGHSYMBOLTABLE()
	THEN
	    IF .HQUALIFIER NEQ .HCACHE
	    THEN
		BEGIN
		GQUALIFIER = 0;
		HQUALIFIER = .$JBSYM;
		ERROR(36);
		RETURN;
		END;
	    PRSYM50(.GQUALIFIER[RAD50NAME]);
	    OUTCRLF();
	    RETURN
	END %(print out)%;

    S = FINDMODULE(.SIXRP[0]);
    IF .S EQL 0 THEN RETURN ERROR(0);

    GQUALIFIER = .S;
    IF ISHIGHSYMBOLTABLE()
    THEN
	IF .S<RH> GEQ .HCACHE<RH>
	THEN
	    HQUALIFIER = .HCACHE
	ELSE
	    HQUALIFIER = .$JBSYM
    END;
ROUTINE XQUAL:NOVALUE=
!+
! FUNCTION
!	Push QUALIFY operator onto DBGSTK
!-
    BEGIN
    QUOTFLG = BIGNUMBER;
    PUSHOPER(4^18 + (UPLIT(10^18+QUAL, 10^18+QUAL, 0,0)))
    END;
ROUTINE HSEARCH(SYM : SYMBOL, CHAR):NOVALUE=
!+
! FUNCTION
!	Search under mask for symbols.  This implements the semantics of the
!		SEARCH "aaa???"
!	command
! INPUTS
!	SYM	- Symbol Table pointer (to MODULE?)
!	CHAR	- ??
!-
    BEGIN
    LABEL
	L;
    LOCAL
	ALPHA,					! A character temporary
	P	: SYMBOL,
	NAME:	VECTOR[6],
	TNAME:	VECTOR[6],
	CNT,
	W,
	TPTR,
	TCNT,
	R50NAME;

    CNT = -1;
    TPTR = CH$PTR( .SIXRP );

    WHILE (ALPHA = CH$RCHAR_A(TPTR)) NEQ 0 DO
	IF .CNT LSS 5
	THEN
	    NAME[(CNT = .CNT+1)] = (IF .ALPHA EQL %C'?'
				    THEN
					0
				    ELSE
					F7TO50(.ALPHA))
	ELSE
	    EXITLOOP;					! Seen enough chars

    P = - .SYM<LH,1>;
    P = .P^18 + .P + .SYM<RH>;

    WHILE (P = .P-%O'2000002') GEQ 0 DO
L:	BEGIN
	R50NAME = .P[RAD50NAME];

	TCNT = (DECR X FROM 5 TO 0 DO
		BEGIN
		TNAME[.X] = .R50NAME MOD %O'50';
		IF (R50NAME = .R50NAME / %O'50') EQL 0 THEN EXITLOOP .X
		END);

	IF 5-.TCNT GTR .CNT THEN LEAVE L;	! Wrong # of characters
	INCR X FROM 0 TO .CNT DO		! Check for equality under
	    BEGIN				!  masking
	    IF .NAME[.X] NEQ 0 AND .NAME[.X] NEQ .TNAME[.TCNT]
	    THEN
		LEAVE L;
	    TCNT = .TCNT+1
	    END;

	OUTC(.CHAR);
	W = PRSYM50(.P[RAD50NAME]);
	PPSYM(.P,.W)
	END;
    END;
ROUTINE XSEARCH: NOVALUE=		! ? SEARCH FEATURE
    BEGIN
    IF ISHIGHSYMBOLTABLE() THEN HSEARCH(.HCACHE,%C'^');

    HSEARCH(.$JBSYM, %C' ')
    END;
ROUTINE XWHERE:NOVALUE=
!+
! FUNCTION
!	Given an address, indicate which module the address can be found in.
!-
    INCR I FROM 0 TO .SIXRC-1 DO
	BEGIN
	LOCAL
	    S;

	S = .SIXRP[.I];
	OUTRDEF(.S<RH>,6);
	IF ISADDRESS(.S<RH>)
	THEN
	    BEGIN
	    OUTS(': Module ');
	    PRSYM50(MODDDT(SDDTFS(.S)));
	    OUTS(', ');
	    PRDISP(.S<RH>)
	    END
	ELSE
	    OUTS(': Not in address space');

	OUTCRLF()
	END;
ROUTINE XRETURN: NOVALUE=
!+
! FUNCTION
!	Implement the "RETURN <exp>" command
!-
    BEGIN
    IF .RTNLVL EQL 0
    THEN
	!+
	! Returning while at routine-entry.  So we must locate the DEBUG UUO
	! marking the exit sequence and resume execution there.
	!-
	BEGIN
	LOCAL
	    L	: REF $INSTRUCTION;
	MACRO
	    POPADR= ENTERPNT[RET_ADDRESS] %;

	L = FNDDBGUUO(.$JBUUO,1);

	IF .L LEQ 0 THEN (PRXDISP(.POPADR);  RETURN ERROR(6));

	! if we found the DEBUG unwind,rtn UUO and we are NOT at
	! then unwind, we want to exit via the standard exit code
	!

	IF .L[0,UNWINDBIT] AND .L<RH> NEQ .RNAME
	THEN
	    BEGIN
	    L = FNDDBGUUO(.L+1,1);
	    IF .L LEQ 0 THEN (PRXDISP(.POPADR); RETURN ERROR(6));
	    END;
	POPADR = .L+1			! Advance to next instruction
	END;
    SIXVREG = .SIXRP[0];		! Set returned value
    GOER()
    END;
ROUTINE XDEL2:NOVALUE=
!+
! FUNCTION
!	Delete a name from the SIX12 "MACRO" table
! NOTES
!	Space for name is recovered, but space for definition is not.
!-
    BEGIN
    DECR J FROM .SIXRC-1 TO 0 DO
	BEGIN
	LOCAL
	    PNT;

	! Lookup name in the macro-definition table
	!

	PNT = (DECR K FROM .NNAMES TO 0 DO
		IF .SIXRP[.J] EQL .SIXNAMES[.K,MACRO_NAME] THEN EXITLOOP .K);

	IF .PNT GEQ 0
	THEN 
	    BEGIN				! Found the name
	    IF .PNT LSS .NNAMES
	    THEN
		BEGIN
		SIXNAMES[.PNT,MACRO_NAME] = .SIXNAMES[.NNAMES,MACRO_NAME];
		SIXNAMES[.PNT,MACRO_BODY] = .SIXNAMES[.NNAMES,MACRO_BODY]
		END;
	    NNAMES = .NNAMES-1
	    END
	END;
    END;
ROUTINE XDEL1:NOVALUE=
!+
! FUNCTION
!	COMMAND: FORGET name ,...
!
!	CREATE OPERATOR FOR EXECUTION AFTER LIST of NAMES IS BUILT.
!-
    BEGIN
    QUOTFLG = BIGNUMBER;
    PUSHOPER(4^18 + UPLIT(0, 10^18+XDEL2, 0, 0))
    END;

MACRO
    APPLY(OP)=
	BEGIN
	SIXVC = .SIXVC+1;
	SIXVP = VTEMP;
	VTEMP = ..SIXLP OP ..SIXRP;
	END %,

    ONEAPPLY(OP)=
	BEGIN
	SIXVC = .SIXVC+1;
	SIXVP = VTEMP;
	VTEMP = OP ..SIXRP;
	END %;
ROUTINE XADD: NOVALUE=APPLY(+);

ROUTINE XSUBTRACT(K): NOVALUE=IF .K LSS 2 THEN ONEAPPLY(-) ELSE APPLY(-);

ROUTINE XTIMES: NOVALUE=APPLY(*);

ROUTINE XDIV: NOVALUE =APPLY(/);

ROUTINE XSHIFT:NOVALUE= APPLY(^);

ROUTINE XEQL:NOVALUE=APPLY(EQL);
ROUTINE XNEQ:NOVALUE=APPLY(NEQ);
ROUTINE XLSS:NOVALUE=APPLY(LSS);
ROUTINE XLEQ:NOVALUE=APPLY(LEQ);
ROUTINE XGTR:NOVALUE=APPLY(GTR);
ROUTINE XGEQ:NOVALUE=APPLY(GEQ);

ROUTINE XAND:NOVALUE=APPLY(AND);
ROUTINE XEQOR:NOVALUE=APPLY(OR);
ROUTINE XNOT:NOVALUE=ONEAPPLY(NOT);
ROUTINE CONTENTS:NOVALUE=
!+
! FUNCTION
!	Fetch contents of specified location.
!
!	Location is implicitly supplied thru SIXRP
!-
    BEGIN
    MAP
	SIXRP	: REF $BYTE_POINTER;

    IF	(.SIXRP[P_POS] + .SIXRP[P_SIZE]) GTR 36 OR	! Validate that the
	.SIXRP[P_INDEX] NEQ 0				!  pointer is "sane"
    THEN
	(PRBPTR(..SIXRP);  RETURN ERROR(18));

    IF NOT ISADDRESS(..SIXRP)
    THEN
	BEGIN
	ILLMEM = ..SIXRP AND AddrMask;
	ERROR(28);
	RETURN
	END;
    IF NOT ISREADABLE(..SIXRP)
    THEN
	BEGIN
	ILLMEM = ..SIXRP;
	ERROR(33);
	RETURN
	END;

    SIXVC = 1;
    SIXVP = VTEMP;

    IF .SIXRP[P_LHALF] EQL 0
    THEN
	VTEMP = ..SIXRP[0,FW]		! Do 36-bit load
    ELSE
	VTEMP = SCANN(SIXRP[0,FW])	! Get value using LDB
    END;
ROUTINE XFUTURE : NOVALUE=
!+
! FUNCTION
!	Indicate that "@" is reserved for FUTURE use.  Probably as
!	a 30-bit addressing operator of some flavor.
!-
    BEGIN
    ERROR(38)
    END;
ROUTINE COLON:NOVALUE=
!+
!	LG change
!-
    BEGIN
    ERROR(1);		! illegal character;
    END;


ROUTINE SYNTAX=ERROR(2);
ROUTINE LGFLD:NOVALUE = ERROR(1);

ROUTINE LGVEC:NOVALUE = ERROR(2);	! syntax error
ROUTINE JOIN:NOVALUE=			! BINARY COMMA (CATENATION)
!+
! FUNCTION
!	"Binary" Comma - CATENATION Operator
!-
    BEGIN
    INCR J FROM 0 TO .SIXRC-1 DO
	SIXLP[.SIXLC +.J] = .SIXRP[.J];

    SIXVP = .SIXLP;
    SIXVC = .SIXLC + .SIXRC
    END;
ROUTINE LPAREN=			! Routine CALL
!+
! FUNCTION
!	Implement procedure calls
!-
    BEGIN
    LOCAL
	SCOUNT,
	SAVEGO,
	SAVJBUUO,
	SAVESTEP,
	SAVETRACE;
    OWN
	ARGCOUNT;		! Must be Own for stack trace to find

    SCOUNT = .ARGCOUNT;
    SAVEGO = .GOFLAG;
    SAVESTEP = .STEPFLAG;
    SETOFF(STEPFLAG);

    SAVETRACE = .TRACEFLAG;

    IF ISON(COPQFLAG) THEN SETOFF(TRACEFLAG);

    SAVJBUUO = .$JBUUO;
    GOFLAG = 1;					! Don't stop in routine

    ARGCOUNT = .SIXRC^18 + .SIXRC;		! SAVE # of PARMS

    !**********************************************************************

    CODECOMMENT	'This is very dangerous code':
	BEGIN
	BUILTIN
	    SP;

	INCR I FROM 0 TO .SIXRC-1 DO		! PUSH PARMS
	    PUSH(SP, SIXRP[.I]);
	(..SIXLP) ();	 			! THIS IS IT!

	SP = .SP - .ARGCOUNT;
    
	VTEMP = .VREG				! MUST BE AFTER STACK SUBTRACT
	END;
    !**********************************************************************

    $JBUUO = .SAVJBUUO;
    STEPFLAG = .SAVESTEP;
    TRACEFLAG = .SAVETRACE;
    GOFLAG = .SAVEGO;
    ARGCOUNT = .SCOUNT;
    SIXVC = 1;
    SIXVP = VTEMP;
    HCACHE = 0			! Clear cache, since user could call a
				! segment swapper
    END;
ROUTINE FIELDSPEC:NOVALUE=
!+
! FUNCTION
!	Evaluate ADDR<P,S> expression, forming a byte-pointer as the
!	result.
!-
    BEGIN
    LOCAL
	R	: $BYTE_POINTER;
    MAP
	SIXVP	: REF $BYTE_POINTER;

    IF .SIXRC NEQ 2 THEN RETURN ERROR(3);	! Insufficient arguments

    R = 0;
    R[P_POS] = .SIXRP[0];			 ! Set up position and
    R[P_SIZE] = .SIXRP[1];			 !  field values in byte-ptr

    SIXVP = .SIXLP;
    SIXVC = 1;

    SIXVP[P_LHALF] = .R[P_LHALF];	! Set into LH of addr word

    IF	.SIXRP[0] GTRU %O'77' OR		! Complain about deformed
	.SIXRP[1] GTRU %O'77'			!  pointer values.
    THEN
	BEGIN
	PRDISP(.(.SIXLP)<RH>);			! Print the displacement
	OUTC(%C'<');				!  and the suspicious
	OUTFD(.SIXRP[0]);			!  position and size
	OUTC(%C',');				!  values
	OUTFD(.SIXRP[1]);
	OUTC(%C'>');
	ERROR(18)
	END
    END;
ROUTINE STRUCT:NOVALUE=
!+
! FUNCTION
!	Fake structure accesses
! INPUTS
!	SIXLP	->	Base expression value
!
!	SIXRC	- Indicates if we are doing a VECTOR or a BLOCK
!		  reference
!-
    BEGIN
    LOCAL
	R;
    MAP
	SIXVP   : REF $BYTE_POINTER;

    ! Check for correct number of access actuals in reference.  Either
    ! one (for VECTOR) or 3 for BLOCK is correct.  All others are suspect.

    IF .SIXRC EQL 2 OR .SIXRC GTR 4 THEN RETURN ERROR(3);

    SIXVP = .SIXLP<RH>;
    IF .SIXREF THEN SIXVP[0,FW] = ..SIXVP[0,FW];	! Implicit REF is "on"

    SIXVP[P_OFFSET] = .SIXVP[P_OFFSET] + .SIXRP[0];	! Include OFFSET value

    SIXVC = 1;

    IF .SIXRC GTR 1
    THEN
	BEGIN
	SIXVP[P_POS] = .SIXRP[1];	! Get position and
	SIXVP[P_SIZE] = .SIXRP[2]	!  size in byte-ptr
	END
    END;
%SBTTL'File service routines for SAVE and LOAD commands'

LITERAL
	BINARYMODE=0,
	ASCIIMODE=1;

ROUTINE INTEXT:NOVALUE=
    BEGIN
    LOCAL
	W;

    WHILE ISOFF(ERRORFLAG) DO
	BEGIN
	IF (W = INWORD()) EQL 0 THEN RETURN;

	.PTEXT = .W;
	PTEXT = .PTEXT+1;
	IF .PTEXT<RH> GEQ TEXTAREA[2*NMACROS] THEN RETURN ERROR(12)
	END
    END;
ROUTINE OUTTEXT(POINT):NOVALUE=
    BEGIN
    INCR PTR FROM .POINT<RH> DO
	BEGIN
	OUTWORD(..PTR);
	IF .(.PTR)<29,7> EQL %O'177' THEN EXITLOOP;
	IF .(.PTR)<22,7> EQL %O'177' THEN EXITLOOP;
	IF .(.PTR)<15,7> EQL %O'177' THEN EXITLOOP;
	IF .(.PTR)<8,7> EQL %O'177' THEN EXITLOOP;
	IF .(.PTR)<1,7> EQL %O'177' THEN EXITLOOP
	END;
    OUTWORD(0)
    END;
ROUTINE FILEOPEN(ISINPUT,MODEFLAG)=
    BEGIN
%IF TOPS10
%THEN
    LOCAL
	BLOCK:		VECTOR[4],
	OPENBLOCK:	VECTOR[4],
	TPPNBUF:	VECTOR[2],
	BP,
	PTR,
	I,
	C;

    MACRO
	ASCIITOSIX(C)=(((C)-%O'40') AND %O'77') %,
	TPPN=I %;

    ROUTINE CMUDEC(PTR)=
	BEGIN
	REGISTER
	    PPNVAL;

	PPNVAL = .PTR<RH>;
	IF NOT MACHSKIP(%O'47', PPNVAL, -2)	! CMU to DEC PPN conversions
	THEN
	    RETURN 0;

	.PPNVAL
	END;

    ROUTINE UPCASE(CHR) =
	SELECTONE .CHR OF
	    SET
	    [%C'a' TO %C'z']:	.CHR -%o'40';
	    [OTHERWISE]:	.CHR
	    TES;

    ROUTINE XTYP(C)=
	SELECTONE .C OF
	    SET
	    [0]:		0;
	    [%C' ']:		1;
	    [%C'.']:		2;
	    [%C'[']:		3;
	    [%C'A' TO %C'Z']:	4;
	    [%C'a' TO %C'z']:	4;
	    [%C'0' TO %C'9']:	4;
	    [%C':']:		5;
	    [OTHERWISE]:	6
	    TES;

    LABEL
	LB;

    STATUS = (IF .MODEFLAG EQL BINARYMODE THEN $IOIMG ELSE $IOASC);

    LDEV = %SIXBIT 'DSK';
    BUFW = (IF ISON(ISINPUT) THEN DSKHDR ELSE DSKHDR^18);

    IF NOT OPEN(SLCHN,OPENBLOCK) THEN RETURN ERROR(10);

LB:
    BEGIN
    FNAME =  JUNK = PPN = 0;
    FEXT = %SIXBIT '612';
    PTR = CH$PTR( .SIXRP );
    SIXRP[.SIXRC] = 0;			! GUARANTEE asciz STRING
    BP = CH$PTR( FNAME, 0, 6 );		! Set up SIXBIT pointer
    I = 6;

    WHILE 1 DO
	BEGIN			! GET FILENAME
	C = UPCASE(CH$RCHAR_A( PTR ));

	CASE XTYP(.C) FROM 0 TO 6 OF
	    SET
	    [0]:	LEAVE LB;
	    [1]:	0;
	    [2]:	EXITLOOP;
	    [3]:	EXITLOOP;
	    [4]:	IF (I = .I-1) GEQ 0
			THEN
			    CH$WCHAR_A(ASCIITOSIX(.C), BP);
	    [5]:	BEGIN
			LDEV = .FNAME;
			RELEASE(SLCHN);
			IF NOT OPEN(SLCHN,OPENBLOCK) THEN RETURN ERROR(10);
			FNAME = 0;
			BP= CH$PTR(FNAME, 0, 6);
			I=6
			END;
	    [6]:	RETURN ERROR(9)
	    TES
	END;

    IF .C EQL %C'.'
    THEN
	BEGIN			! GET EXTENSION
	BP = CH$PTR( FEXT, 0, 6 );
	FEXT = 0;
	I = 3;
	WHILE 1 DO
	    BEGIN
	    C = UPCASE( CH$RCHAR_A( PTR ) );

	    CASE XTYP(.C) FROM 0 TO 6 OF 
		SET
		[0]:    LEAVE LB;
		[1]:    0;
		[2]:    RETURN ERROR(9);
		[3]:    EXITLOOP;
		[4]:    IF (I = .I-1) GEQ 0
			THEN
			    CH$WCHAR_A(ASCIITOSIX(.C), BP);
		[5]:    RETURN ERROR(9);
		[6]:    RETURN ERROR(9)
		TES
	    END
	END;
    IF .C EQL %C'['
    THEN
	BEGIN			! GET PPN
	IF (I = .PTR;  CH$RCHAR_A(I)) GTR %C'7'
	THEN
	    BEGIN			! CMU PPN
	    BP = CH$PTR( TPPNBUF );
	    DECR I FROM 7 TO 0 DO
		BEGIN
		LOCAL
		    TCH;

		TCH = CH$RCHAR_A( PTR );
		CH$WCHAR_A( .TCH, BP );
		IF .TCH EQL %C']' THEN RETURN ERROR(9)
		END;

	    IF CH$RCHAR_A(PTR) NEQ %C']' THEN RETURN ERROR(9);
	    IF (PPN = CMUDEC(TPPNBUF)) EQL 0 THEN RETURN ERROR(9)
	    END
	ELSE
	    BEGIN			! OCTAL PPN
	    TPPN = 0;
	    WHILE (C = CH$RCHAR_A(PTR)) NEQ %C']' DO
		IF .C EQL %C','
		THEN ((PPN)<LH> = .TPPN;  TPPN = 0)
		ELSE
		    IF .C GEQ %C'0' AND .C LEQ %C'7'
		    THEN (TPPN = .TPPN^3 + .C - %C'0')
		    ELSE RETURN ERROR(9);
	    (PPN)<RH> = .TPPN
	    END 
	END
    END;		! of DUMMY BLOCK

    IF ISON(ISINPUT)
    THEN
	(IF NOT LOOKUP(SLCHN,BLOCK) THEN RETURN ERROR(10); INBUF(SLCHN,2))
    ELSE
	(IF NOT ENTER(SLCHN,BLOCK) THEN RETURN ERROR(10); OUTBUF(SLCHN,2));

%ELSE
    LOCAL
	JFN,
	ACMODE;

    SIXRP[.SIXRC] = 0;				! Guarantee ASCIZ string

    ACMODE = (IF .MODEFLAG EQL BINARYMODE THEN 36^30 ELSE 7^30);

    IF ISON(ISINPUT)
    THEN
	BEGIN
	IF NOT GTJFN( GJ_OLD+GJ_SHT, CH$PTR(.SIXRP); JFN)
	THEN
	    RETURN ERROR(10);			! OPEN FAILURE

	DSKHDR = .JFN<RH>;

	IF NOT OPENF( .JFN, .ACMODE+OF_RD ) THEN RETURN ERROR(10)
	END
    ELSE
	BEGIN
	IF NOT GTJFN( GJ_NEW+GJ_SHT+GJ_FOU, CH$PTR(.SIXRP) ; JFN )
	THEN
	    RETURN ERROR(10);			! Open failure	    

	DSKHDR = .JFN<RH>;

	IF NOT OPENF( .JFN, .ACMODE + OF_WR ) THEN RETURN ERROR(10)
	END;

%FI
    1
    END;
ROUTINE XSAVE: NOVALUE=
!+
! FUNCTION
!	Implement the SAVE command to dump the "internal" state of
!	SIX12, including user defined macros, operators, etc..
!-
    BEGIN
%IF TOPS10
%THEN
    LOCAL
	SAVFF;

    SAVFF = .$JBFF;		! Remember memory high-water mark
%FI

    !+
    ! Open the output file
    !-
    IF NOT FILEOPEN(0,BINARYMODE) THEN RETURN;	! You lose....

    SETOFF(ERRORFLAG);
    OUTWORD(.SIXTOG);
    OUTWORD(.SIXREF);
    OUTWORD(.COPQFLAG);
    OUTWORD(.GQUALIFIER);		! Note that we do not worry
					! about overlaid hiseg, as binary
					! save assumes reload in current
					! state...but we do save...
    OUTWORD(.HQUALIFIER);
    INCR J FROM 0 TO .NVALS DO
	BEGIN				! OUTPUT A MONITOR ENTRY
	OUTWORD(.MONVALS[.J,WATCHED_LOCATION]);
	OUTWORD(.MONVALS[.J,WATCHED_VALUE])
	END;
    OUTWORD(-1);			! end of MONITORS

    INCR J FROM 0 TO .NNAMES DO
	BEGIN				! OUTPUT A Macro
	OUTWORD(.SIXNAMES[.J,MACRO_NAME]);
	OUTTEXT(.SIXNAMES[.J,MACRO_BODY])
	END;
    OUTWORD(-1);			! end of MACROS

    INCR J FROM 0 TO .NROUTS DO
	BEGIN				! OUTPUT A Routine ENTRY
	BIND
	    ENTRY = ROUTS[.J,0,FW]: BLOCK;	! Number of actions associated
						!  with this routine

	OUTWORD(.ENTRY[0,0,MAXACTRTN,0]);	! Interest bits and routine
	DECR SUB FROM MAXACTRTN TO 18 DO	! Dump conditional actions
	    BEGIN				!  for each event
	    IF .ENTRY[INTEREST(.SUB)]		! This is interesting event
	    THEN
		IF .ENTRY[CNDACTION(.SUB)] NEQA 0	! With conditional text
		THEN
		    OUTTEXT(.ENTRY[CNDACTION(.SUB)])
		ELSE
		    OUTWORD(0)
	    END
	END;

    OUTWORD(-1);

%IF TOPS10
%THEN
    IF ISON(ERRORFLAG)
    THEN
	(ERROR(11);  CLOSE(SLCHN, CL$RST))	! Close, but don't enter into
    ELSE					!  user's directory
	CLOSE(SLCHN,0);
    RELEASE(SLCHN,0);
    $JBFF = .SAVFF;
%ELSE
    CLOSF( .DSKHDR );
%FI
    0
    END;
ROUTINE XLOAD:NOVALUE=
!
! COMMAND
!
    BEGIN
    LOCAL
	W,
	W2,
	SAVFF;

%IF TOPS10 %THEN SAVFF = .$JBFF; %FI

    IF NOT FILEOPEN(1,BINARYMODE) THEN RETURN;

    SETOFF(ERRORFLAG);
    NVALS = NNAMES = NROUTS = -1;
    PTEXT = CH$PTR( TEXTAREA );
    SIXTOG = INWORD();		! *** These must match exactly with XSTORE
    SIXREF = INWORD();		! ***
    COPQFLAG = INWORD();	! ***
    GQUALIFIER = INWORD();	! ***
    HQUALIFIER = INWORD();	! ***

    WHILE (W = INWORD()) NEQ -1 DO
	BEGIN						! Get MONITOR entries
	MONVALS[(NVALS = .NVALS+1),WATCHED_LOCATION] = .W;
	MONVALS[.NVALS,WATCHED_VALUE] = INWORD()
	END;

    WHILE (W = INWORD()) NEQ -1 DO
	BEGIN						! RETRIEVE Macro
	IF .NNAMES GEQ NMACROS
	THEN
	    EXITLOOP ERROR(13);

	SIXNAMES[(NNAMES = .NNAMES+1),MACRO_NAME] = .W;
	SIXNAMES[.NNAMES,MACRO_BODY] = .PTEXT<RH>;
	INTEXT();
	IF ISON(ERRORFLAG) THEN EXITLOOP;
	END;

    WHILE (W = INWORD()) NEQ -1 DO
	BEGIN						! Get Routine entries
	LOCAL
	    SAVERR;

	SAVERR = .ERRORFLAG;
	ROUTS[(NROUTS = .NROUTS+1),0,FW] = .W;

	! We do not want to include the TABREAKV bit in these tests...
	!
	IF (.W AND (BREAKV+OPQATV+OPQAFTV+TRCATV+TRCAFTV)) NEQ 0
	THEN
	     SETTBLBIT(.W<RH>,0);
	IF (.W AND (ABREAKV+OPQATV+OPQAFTV+TRCATV+TRCAFTV)) NEQ 0
	THEN
	    SETTBLBIT(.W<RH>,1);
	ERRORFLAG = .SAVERR;		! Ignore errors from SETTBLBIT Routine
	
	DECR SUB FROM MAXACTRTN TO 18 DO
	    BEGIN
	    MAP
		W:	BLOCK[1];	! Only ACTION bits are valid here

	    IF .W[INTEREST(.SUB)]		! Interesting event
	    THEN
		BEGIN
		IF (W2 = INWORD()) NEQ 0
		THEN
		    BEGIN					! Get ptr for
		    ROUTS[.NROUTS, CNDACTION(.SUB)] = .PTEXT;	!  string area
		    (.PTEXT) = .W2;			! Save 1st chars
		    PTEXT = .PTEXT+1;			!  and advance pointer
		    INTEXT()				! Get remaining chars
		    END
		ELSE
		    ROUTS[.NROUTS, CNDACTION(.SUB)] = 0;	! No conditional text
		END
	    ELSE
		ROUTS[.NROUTS, CNDACTION(.SUB)] = 0
	    END
	END;

    IF ISON(ERRORFLAG) THEN (NVALS = NNAMES = NROUTS = -1;  ERROR(11));

%IF TOPS10
%THEN
    CLOSE(SLCHN,0);
    RELEASE(SLCHN,0);
    $JBFF = .SAVFF;
%ELSE
    CLOSF( .DSKHDR );
%FI
    END;
ROUTINE OUTOP(J,T):NOVALUE=
!+
! FUNCTION
!	Utility routine used by XSTORE to reduplicate the command used to
!	define user-commands
! INPUTS
!	J	- ?
!	T	- ?
!-
    BEGIN
    IF .DEFOPTAB[.J+.T] EQL 0 THEN RETURN;
    OUTS('Define ');
    IF (.DEFOPTAB[.J] AND %O'777600777777') EQL 0 
    THEN
	BEGIN
	OUTC(%C'"');
	OUTC(.(DEFOPTAB[.J])<LH>);
	OUTC(%C'"')
	END
    ELSE
	BEGIN
	PRSYM6(.DEFOPTAB[.J]);
	END;
    OUTC(%C',');
    IF  .DEFOPTAB[.J+.T] NEQ 0
    THEN
	CASE .T FROM 0 TO 4 OF
	    SET
	    [1]:		OUTS('null=');
	    [2]:		OUTS('prefix=');
	    [3]:		OUTS('postfix=');
	    [4]:		OUTS('infix=');
	    [INRANGE,OUTRANGE]:	0
	    TES;

    OUTFD(.(DEFOPTAB[.J+.T])<LH>,0);
    OUTC(%C',');
    PRQUAL(.(DEFOPTAB[.J+.T])<RH>,1);
    CRLF
    END;				! End of OUTOP
ROUTINE XSTORE:NOVALUE=
!+
! FUNCTION
!       Produce a "re-executable" command sequence to attain present
!       "state".
!-
    BEGIN
    MAP
	GQUALIFIER	: SYMBOL;
%IF TOPS10
%THEN
    LOCAL
	SAVEFF;

    SAVEFF = .$JBFF;
%FI

    IF NOT FILEOPEN(0,ASCIIMODE) THEN RETURN;
    SETOFF(ERRORFLAG);
    SETON(DISKOFLAG);
    IF ISON(COPQFLAG) THEN OUTS('COPAQUE',%CHAR(CR,LF));
    IF ISON(NOPOLLFLAG) THEN OUTS('POLLOFF',%CHAR(CR,LF));
    IF ISON(TRACEFLAG) THEN OUTS('SETTRACE',%CHAR(CR,LF));
    IF .$JB41 EQL DBG_OFF_INST THEN OUTS('NODEBUG',%CHAR(CR,LF));
    IF .IOBASE NEQ 8 
    THEN
	BEGIN
	OUTS('Base 0',%CHAR(CR,LF),'Base ');	OUTN(.IOBASE,8,1); CRLF
	END;

    IF .WDBASE NEQ IWDBASE
    THEN
	BEGIN
	OUTS('WBase ');	OUTDEFAULT(.WDBASE);	CRLF
	END;

    IF .GQUALIFIER NEQ 0 
    THEN
	BEGIN
	! validate cache
	ISHIGHSYMBOLTABLE();
	IF .HQUALIFIER EQL .$JBSYM OR .HQUALIFIER EQL .HCACHE
	THEN
	    BEGIN
	    OUTS('Qualify ');	PRSYM50(.GQUALIFIER[RAD50NAME]); CRLF
	    END
	END;

    ! Save all the actions
    !
    DECR J FROM .NROUTS TO 0 DO
	BEGIN
	LOCAL
	    T	: BLOCK[1];	! action bits

	T = .ROUTS[.J,0,FW] AND (BREAKV + ABREAKV + OPQATV + OPQAFTV + TRCATV + TRCAFTV);		! actions to save

	DECR IDX FROM MAXACTRTN TO 18 DO
	    BEGIN
	    LOCAL
		TPTR,
		TCHAR;


	    IF .T[INTEREST(.IDX)]			! Interesting EVENT?
	    THEN
		BEGIN
		IF .ROUTS[.J, CNDACTION(.IDX)] NEQ 0	! Look for conditional
		THEN					!  events and dump
		    BEGIN				!  the conditional
		    OUTS('If |');			!  text.
		    TPTR = CH$PTR(.ROUTS[.J, CNDACTION(.IDX)]);
		    WHILE (TCHAR = CH$RCHAR_A(TPTR)) NEQ %O'177' DO
			OUTC(.TCHAR);
		    OUTS('| ')
		    END;

		PRSYM50(ACTBIT2NAM(1^.IDX));	! now output the action name
		OUTC(%C' ');
		PRQUAL(.ROUTS[.J,0,RH,0],1);	! And Routine name too
		CRLF
		END
	    END
	END;
    ! Save the macros

    DECR J FROM .NNAMES TO 0 DO
	BEGIN
	LOCAL
	    PTR;
	REGISTER
	    C;

	PTR = CH$PTR(.SIXNAMES[.J,MACRO_BODY]);	! Convert 18-bits to byte-ptr
	OUTS('Macro ');
	PRSYM50(.SIXNAMES[.J,MACRO_NAME]);
	OUTS(' = |');
	WHILE (C=CH$RCHAR_A(PTR)) NEQ %O'177' DO OUTC(.C);
	OUTS('|',%CHAR(CR,LF))
	END;

    ! Save the BINDs
    BEGIN
    LOCAL
	JSYM;

    JSYM = .$JBSYM;
    $JBSYM = .IJOBSYM;		! don't use new symbols for printout!

    INCR SYM FROM .JSYM<RH> TO (.IJOBSYM<RH>)-2 BY 2 DO
	BEGIN
	MAP
	    SYM : SYMBOL;

	OUTS('Bind ');
	PRQ50(.SYM[RAD50NAME]);
	OUTS(' = ');
	PRQUALBP(.SYM[VALUEWRD],1);
	CRLF
	END;
    $JBSYM = .JSYM
    END;

    ! Save the user-defined operators

    DECR J FROM .NEWOPS TO 0 BY OPSIZE DO
	BEGIN

	DECR T FROM 4 TO 1 DO OUTOP(.J,.T)
	END;

	
    ! Save the MONITOR locations

    DECR I FROM .NVALS TO 0 DO
	BEGIN
	IF .MONVALS[.I,WATCHTAG]
	THEN
	    OUTS('Watch ')
	ELSE
	    OUTS('Monitor ');
	PRQUALBP(.MONVALS[.I,WATCHED_LOCATION]);
	CRLF;
	END;

    ! Now close the file
    SETOFF(DISKOFLAG);

%IF TOPS10
%THEN
    IF ISON(ERRORFLAG)
    THEN
	BEGIN
	ERROR(11);
	CLOSE(SLCHN,CL$RST);
	END
    ELSE
	CLOSE(SLCHN,0);
    RELEASE(SLCHN,0);
    $JBFF = .SAVEFF;
%ELSE
    CLOSF( .DSKHDR );
%FI
    END;
ROUTINE XRECALL : NOVALUE=
!+
! FUNCTION
!	RECALL command - complement of STORE.  Reads commands from a
!		file.
!
!-
    BEGIN
    LOCAL
	SAVEFF,
	SAVEGO;

%IF TOPS10
%THEN
    SAVEFF = .$JBFF;
%FI

    IF NOT FILEOPEN(1,ASCIIMODE) THEN RETURN;

    SETOFF(ERRORFLAG);
    SETON(DISKIFLAG);
    SAVEGO = .GOFLAG;
    GOFLAG = 0;
    ISUB();
    SETOFF(DISKIFLAG);
    GOFLAG = .SAVEGO;

    IF ISON(ERRORFLAG) THEN ERROR(11);

%IF TOPS10
%THEN
    CLOSE(SLCHN,0);
    RELEASE(SLCHN,0);
    $JBFF = .SAVEFF
%ELSE
    CLOSF( .DSKHDR )
%FI
END;
%SBTTL 'Further Command Routines'

ROUTINE BOOBOO : NOVALUE =ERROR(4);

ROUTINE COPYR : NOVALUE=(SIXVP = .SIXRP;  SIXVC = .SIXRC);

ROUTINE XDEFINE : NOVALUE=(QUOTFLG = 2;  MODEFLAG = 1);

ROUTINE XSET1 : NOVALUE=(QUOTFLG = 1;  MODEFLAG = 1);

ROUTINE XSET2 : NOVALUE=(QUOTFLG = 1;  MODEFLAG = 2);

ROUTINE XSET3 : NOVALUE=(QUOTFLG = 1;  MODEFLAG = 3);

ROUTINE SETAFTER : NOVALUE=(MODEFLAG = 1 );

ROUTINE SETFROM : NOVALUE=(MODEFLAG = 2 );
ROUTINE XIDENT : NOVALUE=
!+
! FUNCTION
!	Identify linkage conventions in use.
!-
    BEGIN
    ROUTINE REGLIST(CVP: REF VECTOR) :NOVALUE=
	!+
	! FUNCTION
	!	Utility to output a list of register names
	!-
	DECR I FROM .CVP[-1]-1 TO 0 DO
	    BEGIN
	    OUTD(.CVP[.I]);
	    IF .I NEQ 0 THEN OUTC(%C',')
	    END;

    SIXID();
    OUTS('Using default linkage with registers (decimal):');  CRLF;
    OUTS('   Stack pointer: ');  OUTD(SREG);  CRLF;
    OUTS('   Frame pointer: ');  OUTD(FREG);  CRLF;
    OUTS('   Value register: '); OUTD(VREG);  CRLF;
    OUTS('   Preserved registers: '); REGLIST( PLIT(PRREGS) ); CRLF;
    OUTS('   Non-preserved registers: '); REGLIST( PLIT(NPREGS) ); CRLF
    END;
!	The plit below maps print name to Routine
!	-----------------------------------------

! Remember while inserting entries that the plit is searched *backwards*.

! The plit contains a five-word entry for each predefined
! operator. Operators defined at run-time are stored in the
! Same format in 'DEFOPTAB', which is searched first. The format is
!
!	!------!----------!------------!-------------!------------!
!	!PRINT ! WORD FOR !  WORD FOR  !  WORD FOR   !  WORD FOR  !
!	! NAME !NULL PARSE!PREFIX PARSE!POSTFIX PARSE!BINARY PARSE!
!	!------!----------!------------!-------------!------------!
!
! where Print Name contains the SIXBIT representation of a symbol,
! or an ASCII char. In its left half for a special-character print name.
! Each 'Word for...' word has the priority of operation for that parse
! in its left half, and the address of the Routine which is to be called
! to execute it in its right half. A zero word denotes "no such parse".
! A priority P > BraceVal indicates a left brace; The corresponding right
! brace must have priority P-BraceVal. The right brace Routine is a dummy, which
! is never executed. The call method for operators is explained in the SIX12 manual.

! These macros simplify entering operators...

MACRO
    ACHAR(OP,P0,R0,P1,R1,P2,R2,P3,R3)=
	OP^18,
	(P0)^18+ R0,
	(P1)^18+ R1,
	(P2)^18+ R2,
	(P3)^18+ R3 %;

MACRO
    ANAME(OP,P0,R0,P1,R1,P2,R2,P3,R3)=
	%SIXBIT %STRING(OP),
	(P0)^18+ R0,
	(P1)^18+ R1,
	(P2)^18+ R2,
	(P3)^18+ R3 %;


BIND
    OPTAB=  PLIT(

!     Name	NULL		PREFIX		POSTFIX		INFIX
ANAME(ACTION,	50,XSET2,	0,0,		0,0,		0,0),
ANAME(AFTER,	50,SETAFTER,	0,0,		0,0,		0,0),
ANAME(FROM,	50,SETFROM,	0,0,		0,0,		0,0),
ANAME(OPER,	50,XSET1,	0,0,		0,0,		0,0),
ACHAR(ESCAPE,	50,GETTEXT,	0,0,		0,0,		0,0),
ACHAR(BAR,	50,GETTEXT,	0,0,		0,0,		0,0),
!
!		^  ^  ^
!		|  |  |
!	Operators back here do not print out when HELP is done
ANAME(HELP,	50,XHELP,	0,0,		0,0,		0,0),
!		
!	All these commands will be printed by the HELP command
!		| | |
!		V V V
ANAME(ABREAK,	0,0,		10,XABREAK,	0,0,		10,XABREAK),
ANAME(AND,	0,0,		0,0,		0,0,		32,XAND),
ANAME(BACKTO,	0,0,		20,XBACKTO,	0,0,		0,0),
ANAME(BASE,	20,XBASE,	20,XBASE,	0,0,		0,0),
ANAME(BIND,	50,XSET2,	0,0,		0,0,		0,0),
ANAME(BREAK,	0,0,		10,XBREAK,	0,0,		10,XBREAK),
ANAME(CALL,	20,XCALL,	20,XCALL,	0,0,		0,0),
ANAME(CALLS,	50,CALL1,	0,0,		0,0,		0,0),
ANAME(CLRTRA,	50,XCLRTRACE,	0,0,		0,0,		0,0),
ANAME(COPAQU,	50,XCOPAQUE,	0,0,		0,0,		0,0),
ANAME(DABREA,	0,0,		10,DABREAK,	0,0,		0,0),
ANAME(DBREAK,	0,0,		10,DBREAK,	0,0,		0,0),
ANAME(DDT,	50,XDDT,	0,0,		0,0,		0,0),
ANAME(DEBUG,	50,XDEBUG,	0,0,		0,0,		0,0),
ANAME(DEFINE,	50,XDEFINE,	0,0,		0,0,		0,0),
ANAME(DISABL,	50,DISAB,	0,0,		0,0,		0,0),
ANAME(DMONIT,	0,0,		10,XDMONITOR,	0,0,		0,0),
ANAME(DOPAQU,	0,0,		10,DOPAQUE,	0,0,		0,0),
ANAME(DTRACE,	0,0,		10,DTRACE,	0,0,		0,0),
ANAME(DWATCH,	0,0,		10,XDMONITOR,	0,0,		0,0),
ANAME(EQL,	0,0,		0,0,		0,0,		36,XEQL),
ANAME(FORGET,	50,XDEL1,	0,0,		0,0,		0,0),
ANAME(GEQ,	0,0,		0,0,		0,0,		36,XGEQ),
ANAME(GO,	50,XGO,		0,0,		0,0,		0,0),
ANAME(GOCLR,	50,XGOCLR,	0,0,		0,0,		0,0),
ANAME(GOTRAC,	50,XGOTRACE,	0,0,		0,0,		0,0),
ANAME(GTR,	0,0,		0,0,		0,0,		36,XGTR),
ANAME(IDENT,	50,XIDENT,	0,0,		0,0,		0,0),
ANAME(IF,	50,DOTVREG,	0,0,		0,0,		0,0),
ANAME(LCALL,	20,XLCALL,	20,XLCALL,	0,0,		0,0),
ANAME(LCALLS,	50,CALL2,	0,0,		0,0,		0,0),
ANAME(LOAD,	0,0,		20,XLOAD,	0,0,		0,0),
ANAME(LPTCLO,	50,CLOSELPT,	0,0,		0,0,		0,0),
ANAME(LPTDUP,	50,LPTDUP,	0,0,		0,0,		0,0),
ANAME(LPTOFF,	50,LPTOFF,	0,0,		0,0,		0,0),
ANAME(LPTON,	50,LPTON,	0,0,		0,0,		0,0),
ANAME(LPTOPE,	50,OPENLPT,	0,0,		0,0,		0,0),
ANAME(LEQ,	0,0,		0,0,		0,0,		36,XLEQ),
ANAME(LSS,	0,0,		0,0,		0,0,		36,XLSS),
ANAME(MACRO,	50,XSET3,	0,0,		0,0,		0,0),
ANAME(MONITO,	10,XMONITOR,	10,XMONITOR,	0,0,		0,0),
ANAME(NEQ,	0,0,		0,0,		0,0,		36,XNEQ),
ANAME(NOCOPA,   50,XNOCOPAQUE,	0,0,		0,0,		0,0),
ANAME(NODEBU,	50,NOSIX12,	0,0,		0,0,		0,0),
ANAME(NOT,	0,0,		34,XNOT,	0,0,		0,0),
ANAME(OK,	50,XOK,		0,0,		0,0,		0,0),
ANAME(OPAQUE,	0,0,		10,OPAQUE,	0,0,		10,OPAQUE),
ANAME(OR,	0,0,		0,0,		0,0,		30,XEQOR),
ANAME(POLLOF,	50,XNOPOLLON,	0,0,		0,0,		0,0),
ANAME(POLLON,	50,XNOPOLLOFF,	0,0,		0,0,		0,0),
ANAME('POP',	20,XPOP,	20,XPOP,	0,0,		0,0),
ANAME(PRINT,	10,XPRINT,	10,XPRINT,	0,0,		0,0),
ANAME(PRM,	50,XPRM,	0,0,		0,0,		0,0),
ANAME(PRS,	50,XPRS,	0,0,		0,0,		0,0),
ANAME(QUALIF,	50,XQUAL,	0,0,		0,0,		0,0),
ANAME(RECALL,	0,0,		20,XRECALL,	0,0,		0,0),
ANAME(RESIGN,	20,XRESIGNAL,	20,XRESIGNAL,	0,0,		0,0),
ANAME(RESET,	50,XRESET,	0,0,		0,0,		0,0),
ANAME(RESUME,	20,XRESUME,	20,XRESUME,	0,0,		0,0),
ANAME(RETURN,	0,0,		20,XRETURN,	0,0,		0,0),
ANAME(SAVE,	0,0,		20,XSAVE,	0,0,		0,0),
ANAME(SEARCH,	0,0,		20,XSEARCH,	0,0,		0,0),
ANAME(SETTRA,	50,XSTRACE,	0,0,		0,0,		0,0),
ANAME(SIGNAL,	0,0,		20,XSIGNAL,	0,0,		0,0),
ANAME(STEP,	50,XSTEP,	0,0,		0,0,		0,0),
ANAME(STORE,	0,0,		20,XSTORE,	0,0,		0,0),
ANAME(TRACE,	0,0,		10,XTRACE,	0,0,		10,XTRACE),
ANAME(UNWIND,	50,XSETUNWIND,	0,0,		0,0,		0,0),
ANAME(WATCH,	10,XWATCH,	10,XWATCH,	0,0,		0,0),
ANAME(WBASE,	20,XWBASE,	20,XWBASE,	0,0,		0,0),
ANAME(WHERE,	0,0,		10,XWHERE,	0,0,		0,0),
ACHAR(LBRACE,	0,0,		0,0,		45,LGFLD,	0,0),  !LG change  {
ACHAR(RBRACE,	0,0,		0,0,		4,BOOBOO,	0,0),
ACHAR(LPOINTY,	0,0,		10003,COPYR,	0,0,		10003,FIELDSPEC),
ACHAR(RPOINTY,	0,0,		0,0,		3,BOOBOO,	0,0),
ACHAR(LSQUARE,	0,0,		10002,COPYR,	0,0,		10002,STRUCT),
ACHAR(RSQUARE,	0,0,		0,0,		2,BOOBOO,	0,0),
ACHAR(LEFTPAREN,0,0,		10001,COPYR,	0,0,		10001,LPAREN),
ACHAR(RPAREN,	0,0,		0,0,		1,BOOBOO,	0,0),
ACHAR(%C'=',	0,0,		0,0,		0,0,		9,EQUALS),
ACHAR(%C';',	5,DOTVREG, 	5,COPYR, 	5,DOTVREG, 	5,COPYR),
ACHAR(%C'^',	0,0,		0,0,		0,0,		42,XSHIFT),
ACHAR(%C'*',	0,0,		0,0,		0,0,		40,XTIMES),
ACHAR(%C':',	0,0,		0,0,		46,COLON,	0,0),  !LG change
ACHAR(%C'@',	20,XFUTURE,	20,XFUTURE,	0,0,		0,0),
ACHAR(%C'.',	0,0,		44,CONTENTS,	0,0,		0,0),
ACHAR(%C'-',	0,0,		38,XSUBTRACT,	0,0,		38,XSUBTRACT),
ACHAR(%C'+',	0,0,		38,COPYR,	0,0,		38,XADD),
ACHAR(%C',',	0,0,		0,0,		0,0,		15,JOIN),
ACHAR(%C'!',	0,0,		0,0,		0,0,		20,SLASH),
ACHAR(%C'/',	0,0,		0,0,		20,SLASH,	40,XDIV),
	0 )	:VECTOR;
LITERAL
    BRACEVAL = 10000,			! Special indicator for (,{,<,[..

    P_NULL=	21,			! Bit number for valid parses
    P_PREFIX=	20,
    P_POSTFIX=	19,
    P_INFIX=	18;
ROUTINE XPRS:NOVALUE=
!+
! FUNCTION
!	COMMAND: PRS name ,...
!-
    BEGIN
    QUOTFLG = BIGNUMBER;

    PUSHOPER( %(permissible parse: Prefix )% MASK_(P_PREFIX) +
	 UPLIT(ANAME(XPRS, %(null)% 0,0, %(prefix)% 10,PRS, %(postfix)% 0,0, %(infix)% 0,0)) + 1);
    END;
ROUTINE XPRM : NOVALUE=
    !
    ! COMMAND: PRM name ,...
    !
    BEGIN
    QUOTFLG = BIGNUMBER;
    PUSHOPER(%(permissible parse: null, prefix )% MASK_(P_NULL,P_PREFIX) +
	 UPLIT(ANAME(XPRM, %(null)% 10,PRM, %(prefix)% 10,PRM, %(postfix)% 0,0, %(infix)% 0,0)) + 1)
    END;
ROUTINE EQUALS0= ERROR(7);
GLOBAL ROUTINE SIXOP(NEWOP,PARSE,PRIORITY,RTN)=
!+
! FUNCTION
!	Add a new operator to SIX12
!-
    BEGIN
    LOCAL
	ENTRY,
	OLD;

    !+
    ! Look-up in operator table
    !-
    ENTRY = (DECR J FROM .NEWOPS TO 0 BY OPSIZE DO
		IF .NEWOP EQL .DEFOPTAB[.J] THEN EXITLOOP .J );

    IF .ENTRY LSS 0				! Not found, so
    THEN					!  insert new entry
	BEGIN
	ENTRY = NEWOPS = .NEWOPS+OPSIZE;
	DEFOPTAB[.NEWOPS] = .NEWOP;
	OLD = ( DECR J FROM .OPTAB[-1]-(OPSIZE+1) TO 0 BY OPSIZE DO
		IF .NEWOP EQL .OPTAB[.J] THEN EXITLOOP .J );

	DECR J FROM 3 TO 0 DO		! COPY OLD Entry
	    DEFOPTAB[.NEWOPS+1+ .J] = 
		(IF .OLD GEQ 0
		    THEN .OPTAB[.OLD+1 +.J]
		    ELSE 0)
	END;
    (DEFOPTAB[.ENTRY+1+.PARSE])<LH> = .PRIORITY;
    (DEFOPTAB[.ENTRY+1+.PARSE])<RH> = .RTN;
    1
    END;
ROUTINE X2DEFINE: NOVALUE=
!+
! FUNCTION
!	Second-level Define action routine (triggered by XDefine)
!-
    BEGIN
    LOCAL
	OLD,
	PARSE,
	ENTRY,				! DEFINE (OPERATOR)
	NEWOP;

    IF .SIXRC NEQ 2 OR .SIXLC NEQ 2 THEN RETURN ERROR(3);

    PARSE = .SIXLP[1];

    !+
    ! "Parse" may be a numeric code or a special string
    !-

    IF .PARSE LSS 0 OR .PARSE GTR 3
    THEN
	PARSE =
	    BEGIN
	    SELECT .PARSE OF
		SET
	       [%RAD50_10 'NULL']:	0;
	       [%RAD50_10 'PREFIX']:	1;
	       [%RAD50_10 'POSTFI']:	2;
	       [%RAD50_10 'INFIX']:	3;
	       [OTHERWISE]:		(ERROR(31);  RETURN )
		TES
	    END;

    NEWOP = ( IF .(.SIXLP)<RH> EQL 0 THEN ..SIXLP ELSE F50TO6(..SIXLP) );

    SIXOP(.NEWOP,.PARSE,.SIXRP[0], .SIXRP[1])
    END;
ROUTINE XBIND: NOVALUE=
!+
! FUNCTION
!	Implement the BIND command
!-
    BEGIN
    LOCAL
	S	: SYMBOL,
	T	: SYMBOL,
	R	: SYMBOL;	! Bind (CREATE DDT-SYMBOL)
    
    ! This uses only the lowseg symbol table for the BINDs
    
    R = .$JBSYM - %O'2000002';
    
    IF (S = NSDDTFA(%RAD50_10 'PAT..', 0)) EQL 0	! There isn't any
    THEN						!  patch area!
	RETURN ERROR(15);
    
    ! see if we are rebinding the symbol
    
    T=.$JBSYM;

    WHILE .T<RH> LSS .S<RH> DO
	BEGIN				%(scan bound symbols)%
	IF .T[RAD50NAME] EQL ..SIXLP
	THEN
	    IF .T[VALUEWRD] NEQ ..SIXRP
	    THEN
		BEGIN %(redefined)%
		OUTS('Redefined ');
		PRSYM50(..SIXLP);
		OUTS(', old value was ');
		OUTDEFAULT(.T[VALUEWRD]);
		DBLEQL();
		PRDISP(.T[VALUEWRD]);
		T[VALUEWRD] = .SIXRP[0];
		CRLF;
		RETURN
		END %(redefined)%
	    ELSE
		RETURN;

	T= .T+%O'2000002'
	END;

    ! if we get here, the symbol is being bound for the first time
    !

    IF .R<RH> LSS .S[SYMBOLVAL] THEN RETURN ERROR(15);

    R[NAMEWRD] = ..SIXLP OR DDT$_GLOBAL^32;	! DEFINE AS Global SYMBOL
    R[VALUEWRD] = .SIXRP[0];

    $JBSYM = .R;

    ! Now update the size field of PAT.. module patch area, by adjusting the
    ! module symbol count appropriately.
    !

    S[SYMBOLCNT] = .S[SYMBOLCNT] - 2
    END;
ROUTINE XMACRO : NOVALUE=
!+
! FUNCTION
!	Establish a MACRO definition
 !-
    BEGIN
    IF .NNAMES GEQ NMACROS THEN RETURN ERROR(13);

    DECR J FROM .NNAMES TO 0 DO
	IF ..SIXLP EQL .SIXNAMES[.J,MACRO_NAME] THEN RETURN ERROR(14);

    SIXNAMES[(NNAMES = .NNAMES+1),MACRO_NAME] = ..SIXLP;
    SIXNAMES[.NNAMES,MACRO_BODY] = ..SIXRP
    END;
ROUTINE XASSIGN : NOVALUE=
!+
! FUNCTION
!	Implements the "=" operator
! NOTES
!	Constant position and size are handled in destination expressions
!-
    BEGIN
    MAP
	SIXLP	: REF $BYTE_POINTER;

    IF .SIXLP[P_POS_SIZE] EQL 0
    THEN       					!ADD P,S =<FW>
	SIXLP[P_SIZE] = 36;

    IF .SIXLP[P_POS] + .SIXLP[P_SIZE] GTR %BPVAL OR
	.SIXLP[P_INDEX] NEQ 0
    THEN
	(PRBPTR(.SIXLP[0,FW]);  RETURN ERROR(18));

    IF NOT ISADDRESS(..SIXLP)
    THEN
	BEGIN
	ILLMEM = .SIXLP[0,FW];
	ERROR(28);
	RETURN
	END;
    IF NOT ISWRITABLE(.SIXLP[0,FW])
    THEN
	BEGIN
	ILLMEM = .SIXLP[0,FW];
	ERROR(32);
	RETURN;
	END;

    REPLACEN( SIXLP[0,FW], .SIXRP[0] );

    IF .NVALS GEQ 0 THEN CKVALS(0,-2);	! CHECK MONITORED LOCATIONS
    END;
BIND
    EQUALSDISP = UPLIT(EQUALS0,X2DEFINE,XBIND,XMACRO,XASSIGN) : VECTOR;

ROUTINE EQUALS :NOVALUE=
!+
! FUNCTION
!	Dispatch to specific ROUTINE
!-
    (.EQUALSDISP[.MODEFLAG])();
!
!   COMMAND: PRINT
!


BIND
    XPRINTDISP = UPLIT(XPRINT0,XPRINTOPER,XPRINTACT,XPRINTMACRO,XPRINTMON)	:VECTOR;

ROUTINE XPRINT = (.XPRINTDISP[.MODEFLAG])();	!DISPATCH to SPECIFIC ROUTINES

ROUTINE XPRINT0 = ERROR(2);
ROUTINE XPRINTOPER:NOVALUE =
!
! COMMAND: PRINT OPER
!
    BEGIN
    LOCAL
	WHICHOP,
	PNTR	: REF VECTOR;			! OPERATOR

    ! If the operator is in radix50, then some bits outside the left
    ! halfword character code will be set, so we use this test to 
    ! determine which kind we have

    WHICHOP = ( IF (..SIXRP AND %O'777600777777') NEQ 0
		THEN
		    F50TO6(.SIXRP[0])
		ELSE
		    .SIXRP[0] );

    IF .SIXRC GTR 1 THEN RETURN ERROR(3);

    PNTR = ( DECR J FROM .NEWOPS TO 0 BY OPSIZE DO
		IF .WHICHOP EQL .DEFOPTAB[.J]
		THEN
		    EXITLOOP (DEFOPTAB[.J]) );

    IF .PNTR LSS 0
    THEN
	PNTR = ( DECR J FROM .OPTAB[-1]-(OPSIZE+1) TO 0 BY OPSIZE DO
			IF .WHICHOP EQL .OPTAB[.J]
			THEN
			    EXITLOOP OPTAB[.J] );

    IF .PNTR LSS 0
    THEN
	(OUTS('No such operator',%CHAR(CR,LF) );  RETURN);

    PROP(.PNTR[0]);
    IF .PNTR[1] NEQ 0
    THEN
	BEGIN
	OUTS( %CHAR(CR,LF),'Null',%CHAR(9) );
	OUTFD(.(PNTR[1])<LH>,5);
	PUTTAB;
	PRXDISP(.PNTR[1])
	END;
    IF .PNTR[2] NEQ 0
    THEN
	BEGIN
	OUTS( %CHAR(CR,LF),'Prefix',%CHAR(9) );
	OUTFD(.(PNTR[2])<LH>,5);
	PUTTAB;
	PRXDISP(.PNTR[2])
	END;
    IF .PNTR[3] NEQ 0
    THEN
	BEGIN
	OUTS( %CHAR(CR,LF),'Postfix',%CHAR(9) );
	OUTFD(.(PNTR[3])<LH>,5);
	PUTTAB;
	PRXDISP(.PNTR[3])
	END;
    IF .PNTR[4] NEQ 0
    THEN
	BEGIN
	OUTS( %CHAR(CR,LF),'Infix',%CHAR(9) );
	OUTFD(.(PNTR[4])<LH>,5);
	PUTTAB;
	PRXDISP(.PNTR[4])
	END;
    CRLF
    END;
! The following definitions are used by
! the "PRINT ACTION" display routines

MACRO
    ATM(A,B) = %RAD50_10 A,B %;

BIND
    ALLACTV =					! ALL ACTION BITS
	    BREAKV+ABREAKV+OPQATV+OPQAFTV+TRCATV+TRCAFTV+TABREAKV,
    ACTTBL =
	    PLIT (
		ATM('BREAK',	BREAKV ),
		ATM('ABREAK',	ABREAKV),
		ATM('OPAQ',	OPQATV),
		ATM('OPAQAF',	OPQAFTV),
		ATM('TRACE',	TRCATV),
		ATM('TRACEA',	TRCAFTV),
		ATM('OK',	TABREAKV),
		ATM('ALL',	ALLACTV)
		)
		 :	VECTOR;		! <= "ALL" must be the last entry
ROUTINE ACTBIT2NAM(BIT_VAL) =
!+
! FUNCTION
!	Convert a bit-mask value (action mask) into its print-name
!-
    (DECR J FROM .ACTTBL[-1]/2-2 TO 0 DO
	IF .ACTTBL[.J*2+1] EQL .BIT_VAL
	THEN EXITLOOP .ACTTBL[.J*2]);
ROUTINE ACTNAM2BIT(NAM) =
!+
! FUNCTION
!	Convert print name to bit mask
! INPUT
!	NAM	- Name in ???? (sixbit?)
! OUTPUT
!	Bitmask for setting into table or ZERO if name not found
!-
    BEGIN
    DECR J FROM .ACTTBL[-1]/2-1 TO 0 DO
	IF .ACTTBL[.J*2] EQL .NAM
	THEN
	    RETURN .ACTTBL[.J*2+1];

    0
    END;
ROUTINE PR1ACTION(NAME,TYPE):NOVALUE =
!+
! FUNCTION
!	Print one action.
! INPUTS
!	NAME	- Routine address
!	TYPE	- Mask of action type
!-
    BEGIN
    LOCAL
	P,			! Index into ROUTS of a routine
	T;
    LABEL
	NEXTACT;

    IF (P = CFINDR(.NAME)) LSS 0
    THEN
	(OUTS('No actions set',%CHAR(CR,LF));  RETURN);

    T = .ROUTS[.P,0,FW] AND .TYPE;	! Masked by Events we're interested in

    IF .T NEQ 0 AND .SIXRC EQL 1
    THEN
	BEGIN
	OUTS('Routine ');  PRQUAL(.ROUTS[.P,0,RH,0],1);  CRLF
	END;

    DECR I FROM MAXACTRTN TO 18 DO
NEXTACT:
	BEGIN
	MAP
	    T:	BITVECTOR;

	IF NOT .T[.I] THEN LEAVE NEXTACT;	! Ignore uninteresting events

	IF .TYPE EQL ALLACTV		! When ALL actions are desired,
	THEN				!  print the action-name we are
	    BEGIN			!  going to display next.
	    PRSYM50(ACTBIT2NAM(1^.I));
	    OUTS(':',%CHAR(9) )
	    END;

	IF .ROUTS[.P, CNDACTION(.I)] EQLA 0
	THEN
	    (OUTS('Unconditional'); CRLF)
	ELSE
	    BEGIN
	    LOCAL
		TV,		! Pointer to conditional text
		TC;		! Next character

	    TV = CH$PTR( .ROUTS[.P, CNDACTION(.I)] );
	    WHILE (TC = CH$RCHAR_A(TV)) NEQ %O'177' DO OUTC(.TC);
	    CRLF
	    END
	END
    END;
ROUTINE XPRINTACT :NOVALUE=
!+
! FUNCTION
!	Implements the		PRINT ACTION <type> <name>
!	command
! IMPLICIT INPUTS
!	SIXRP[0]	- action-type
!	SIXRP[1]	- optional routine name
!-
    BEGIN
    LOCAL
	TMP;

    IF .SIXRC LSS 1 OR .SIXRC GTR 2 THEN RETURN ERROR(3);	! Check args

    IF (TMP = ACTNAM2BIT(..SIXRP)) EQL 0 THEN RETURN ERROR(8);	! Bad type

    IF .SIXRC EQL 2
    THEN
	PR1ACTION(.SIXRP[1], .TMP)	! Display given name
    ELSE
	! Display all names for this action
	BEGIN
	IF .NROUTS EQL -1
	THEN
	    (OUTS('No actions set',%CHAR(CR,LF));  RETURN);

	DECR J FROM .NROUTS TO 0 DO PR1ACTION(.ROUTS[.J,0,FW],.TMP)
	END
    END;
ROUTINE PR1MACRO(NAME) :NOVALUE=
    ! Print one Macro definition
    BEGIN
    LOCAL
	PNTR,
	C;
    PNTR = ( DECR J FROM .NNAMES TO 0 DO
		IF .NAME EQL .SIXNAMES[.J,0,FW] THEN EXITLOOP .J );
    IF .PNTR LSS 0
    THEN
	(OUTS( 'No such macro',%CHAR(CR,LF) );  RETURN);

    PNTR = CH$PTR(.SIXNAMES[.PNTR,1,FW]);

    WHILE (C =CH$RCHAR_A(PNTR)) NEQ %O'177' DO OUTC(.C);

    CRLF
    END;
ROUTINE XPRINTMACRO:NOVALUE =
!
! COMMAND: PRINT Macro [NAME]
!
    BEGIN
    IF .SIXRC GTR 1 THEN RETURN ERROR(3);
    IF .SIXRC EQL 1
    THEN
	! PRINT GIVEN Macro
	PR1MACRO(..SIXRP)
    ELSE
	! PRINT ALL MACROS
	BEGIN
	LOCAL
	    P;
	IF .NNAMES EQL -1
	THEN (OUTS( 'No macros defined',%CHAR(CR,LF) );  RETURN);

	DECR J FROM .NNAMES TO 0 DO
	    BEGIN
	    P = .SIXNAMES[.J,0,FW];
	    PRSYM50(.P);
	    OUTS(' =',%CHAR(9) );
	    PR1MACRO(.P)
	    END
	END;
    END;
    	%SBTTL	'Analysis of DEBUG input lines'
!		-----------------------------

! The parsing algorithm uses a simple stack method based on one first
! developed By bauer and Samelson.  In order to retain maximum information
! about context (necessary since operator parse is not fixed), both
! operators and operands are kept in one stack. The operand stack
! elements are formatted
!
!		!-------------------------!
!		! NO. of WORDS IN OPERAND !	<- TOP WORD of ENTRY
!		!-------------------------!
!		! LAST DATA WORD	  !	^  INCREASING
!		!	! ! !		  !	^    STACK
!		! FIRST DATA WORD	  !	^  SUBSCRIPTS
!		!-------------------------!
!
! where the count in the top (last) word does not include the count
! word itself.  Operator entries are chained together:
!
! TOPOP -->	!------------+------------!
!		! #400000    ! POINTER    !	to IMMEDIATELY PREVIOUS OPERATOR
!		!------------+------------!
!		! PARSE INFO ! POINTER    !	to TABLE ENTRY FOR THIS OPERATOR
!		!------------+------------!
!
! thus, operator and operand entries on the stack can be distinguished
! by the sign of their top word.  The 'PARSE INFO' in the entry is contained
! in the last 4 bits of the halfword, each of which is 1 when the corresponding
! parse (null-bit <21,1>, prefix-<20,1>, postfix-<19,1>, infix-<18,1>) might be valid.
! the pointer to the table entry points to its second word, the
! print name not being required at this stage of the game.

MACRO
	ENDOFLINE=(.CHAR EQL CR) %;

MACRO 	PARSEFIELD=18,4,0 %,
	PARSENULL=21,1,0 %,
	PARSEPREFIX=20,1,0 %,
	PARSEPOSTFIX=19,1,0 %,
	PARSEINFIX=18,1,0 %;
ROUTINE ADVANCE:NOVALUE=		! GET NEXT CHARACTER
    BEGIN
    IF .NPCHAR EQL 0 THEN NCHAR = .NCHAR+1;
    CHAR = CH$RCHAR_A(PCHAR[.NPCHAR]);

    IF .CHAR EQL %O'177'	! End of input-stream indicator?
    THEN
	BEGIN
	NPCHAR = .NPCHAR-1;	! Back down to previous input-stream
	CHAR = %C' ';		! Force break in parse at end of Macro
	END;
    END;
LITERAL
    T_NUMBER	= 0,
    T_ALPHA	= 1,
    T_RADIX	= 2,
    T_QUOTE	= 3,
    T_OTHER	= 4;

ROUTINE TYPE(TFLAG)=
!+
! FUNCTION
!	Determine type of character in CHAR for input scanning.
! INPUTS
!	TFLAG	- Zero for normal name. 1, if name began with "?" to
!		  quote it.
! OUTPUTS
!	value indicating type of character, from set
!		0	- numeric
!		1	- alphabetic
!		2	- numeric over-ride "#"
!		3	- quoting characters " and '
!		4	- all other operator chars, etc.
!-
    BEGIN
    SELECTONE .CHAR OF
	SET
	[%C'0' TO %C'9']:	.TFLAG;		! ?<digit> is alpha, else num
	[%C'A' TO %C'Z']:	T_ALPHA;
	[%C'a' TO %C'z']:	T_ALPHA;
	[%C'&']:		T_ALPHA;
	[%C'_', %C'$']:		T_ALPHA;
	[%C'.', %C'%']:		IF .TFLAG	! MACRO-10 specials, if "?"
				THEN		!  seen to quote it
				    T_ALPHA	!  say it's alpha
				ELSE
				    T_OTHER;	! No, it's a special character
	[%C'#']:		T_RADIX;
	[DQUOTE]:		T_QUOTE;	! ASCII "
	[SQUOTE]:		T_QUOTE;	! ASCII '
	[OTHERWISE]:		T_OTHER
	TES
    END;
ROUTINE ERROR(EN)=
!+
! FUNCTION
!	Error message printouts
!-
    BEGIN
    IF .EN GEQ 0 THEN SETON(ERRORFLAG) ELSE EN = - .EN;

    IF ISON(DISKIFLAG)
    THEN
	BEGIN
	LOCAL
	    PTR,
	    C;
	PTR = CH$PTR(BUFF);
	OUTC(%C'&');
	WHILE (C=CH$RCHAR_A(PTR)) NEQ CR DO OUTC(.C);
	CRLF
	END;

    SELECTONE .EN OF
	SET
	[0 TO 4, 16,17,22,25,38]:
		(TTOUTM(%C'.',.NCHAR);  TTOUTC(%C'^');  TTCRLF);
	[28,32,33]:
		(PRBPTR(.ILLMEM))
	TES;

    CASE .EN FROM 0 TO 38 OF
	SET
	[0]:	TTOUTS('Unknown symbol');
	[1]:	TTOUTS('Illegal character');
	[2]:	TTOUTS('Syntax error');
	[3]:	TTOUTS('Incorrect number of arguments');
	[4]:	TTOUTS('Unmatched brace');
	[5]:	TTOUTS('Base must be from 2 to 10 decimal');
	[6]:	TTOUTS(': No debug linkage found for this routine');
	[7]:	TTOUTS('Invalid equals');
	[8]:	TTOUTS('ACTION-type must be one of: BREAK, ABREAK, OPAQ, OPAQAF, TRACE, TRACEA or ALL');
	[9]:	TTOUTS('Improper file-spec');
	[10]:	TTOUTS('Open failure ');
	[11]:	TTOUTS('Transmission error');
	[12]:	TTOUTS('No space for macro text');
	[13]:	TTOUTS('No space for macro name definition');
	[14]:	TTOUTS('Name already defined');
	[15]:	TTOUTS('No space for symbol definition');
	[16]:	(TTOUTS('Digit invalid for base ');  OUTD(.IOBASE));
	[17]:	TTOUTS('Actual/Local index out of range');
	[18]:	TTOUTS(': Invalid field reference (byte pointer)');
	[19]:	TTOUTS('Line printer file not open');
	[20]:	TTOUTS('Line printer file still open');
	[21]:	TTOUTS('DDT not loaded');
	[22]:	(TTOUTS('Multiple definitions in DDT symbol table for ');  PRSYM50(.ERRORPARM));
	[23]:	TTOUTS('Impossible error 23');
	[24]:	TTOUTS('OK works only at routine entry');
	[25]:	TTOUTS('Ambiguous command name');
	[26]:	TTOUTS('Not available for Bliss-10');
	[27]:	TTOUTS('Valid only when in signal handler routine');
	[28]:	%IF TOPS10
		%THEN
		    TTOUTS(': Ill Mem Ref');
		%ELSE
		    TTOUTS(': Refers to non-existent page');
		%FI
	[29]:	TTOUTS('Already at top SIX12 level');
	[30]:	(TTOUTS('You are already above level '); OUTD(..SIXRP));
	[31]:	TTOUTS('Which Parse?');
	[32]:	TTOUTS(': Memory Write Protected');
	[33]:	%IF TOPS20 %THEN TTOUTS(': Memory Read Protected') %FI ;
	[34]:	TTOUTS('Warning: You are in NODEBUG mode');
	[35]:	TTOUTS('Operation makes no sense in NODEBUG mode');
	[36]:	TTOUTS('Module is in different high segment');
	[37]:	TTOUTS('Could not find SS$UNW in symbol table');
	[38]:	TTOUTS('Reserved for future use');
	[INRANGE,OUTRANGE]:	
		0
	TES;
%IF TOPS20
%THEN
	IF .EN EQL 10
	THEN
	    ERSTR( $PRIOU, $FHSLF^18+%O'777777', 0);	! Last JSYS error
%FI
    TTCRLF;
    0
    END;
ROUTINE PRSTK(K) : NOVALUE=
!+
! FUNCTION
!	Print the DEBUG parse stack
! INPUT
!	K	- depth to print to
!-
    BEGIN
    LOCAL
	I;

    IF .K EQL 0 THEN K = .TOPSTK;		! except 0 means all of it

    I = .TOPSTK;

    WHILE .I GTR .TOPSTK-.K DO
	BEGIN %(print it)%
	IF .DBGSTK[.I] LSS 0
	THEN
	    BEGIN %(operator)%
	    PROP(.(.(DBGSTK[.I-1])<0,18>-1));
	    OUTC(%C' ');
	    IF .(DBGSTK[.I-1])<PARSENULL> THEN PRSYM50(%RAD50_10 'NULL.');
	    IF .(DBGSTK[.I-1])<PARSEPREFIX> THEN PRSYM50(%RAD50_10 'PREFX.');
	    IF .(DBGSTK[.I-1])<PARSEPOSTFIX> THEN PRSYM50(%RAD50_10 'PSTFX.');
	    IF .(DBGSTK[.I-1])<PARSEINFIX> THEN PRSYM50(%RAD50_10 'INFIX.');
	    CRLF;
	    I = .I - 2;
	    END %(operator)%
	ELSE
	    BEGIN %(operand)%
	    OUTC(%C'['); OUTFD(.DBGSTK[.I],0); OUTC(%C']');
	    INCR J FROM .I-.DBGSTK[.I] TO .I-1 DO
		BEGIN
		OUTDEFAULT(.DBGSTK[.J]);
		OUTC(%C' ');
		END;
	    CRLF;
	    I = .I - (.DBGSTK[.I]+1);
	    END %(operand)%;
	END %(print it)%;
    END;
ROUTINE PUSHOPER(OPERATOR):NOVALUE=
!+
! FUNCTION
!	Push an operator onto the evaluation stack
    BEGIN
    TOPSTK = .TOPSTK+2;
    DBGSTK[.TOPSTK-1] = .OPERATOR;
    DBGSTK[.TOPSTK] =  1^35 OR .TOPOP<RH>;		! Sign is OPERATOR flag
    TOPOP = .TOPSTK;
    IF .PARSEDEBUG THEN (OUTS('op: '); PRSTK(2))	! print this operator
    END;
ROUTINE PUSHITEM(AWORD):NOVALUE=
!+
! FUNCTION
!	PUT 1-WORD OPERAND ON STACK
!-
    BEGIN
    IF .TOPSTK GEQ 0 AND .DBGSTK[.TOPSTK] GEQ 0 ! Already a partial operand
    THEN					!  on stack. Make room for
	BEGIN					!  one more component
	TOPSTK = .TOPSTK+1;
	DBGSTK[.TOPSTK] = .DBGSTK[.TOPSTK-1] + 1;
	DBGSTK[.TOPSTK-1] = .AWORD;
	IF .PARSEDEBUG THEN (OUTS('operand: '); PRSTK(2));	! print this operand
	RETURN
	END;
    TOPSTK = .TOPSTK+2;			 ! Make room for new operand
    DBGSTK[.TOPSTK] = 1;
    DBGSTK[.TOPSTK-1] = .AWORD;
    IF .PARSEDEBUG THEN (OUTS('operand: '); PRSTK(2));	! print this operand
    END;
ROUTINE GETNUMBER=
!+
! FUNCTION
!	Pick up number
! NOTES
!	It is necessary to acquire a register pair for doing the MUL
!	instruction.
!-
    BEGIN
    REGISTER				! Hope these are preserved regs.
	VAL = S1036(14,8),
	VAL2= S1036(15,9);

    VAL = 0;

    IF TYPE(FALSE) NEQ T_NUMBER THEN RETURN ERROR(2);

    DO
	BEGIN
	IF (.CHAR - %C'0') GEQ .IOBASE		! Check that digits are in
	THEN					!  the domain of the current
	    (NCHAR = .NCHAR+1;  ERROR(16));	!  input radix.

	MUL(VAL,IOBASE);  

	VAL2<35,1> = 0;				! Clear out for "predictability

	IF .VAL THEN VAL2<35,1> = 1;		! Keep sign in LSB's

	VAL = .VAL2 + .CHAR - %C'0';
	ADVANCE()
	END
    WHILE TYPE(FALSE) EQL T_NUMBER;

    .VAL
    END;
ROUTINE GETSYMBOL(TFLAG)=
!+
! FUNCTION
!	GET RADIX-50 REPRESENTATION of SYMBOL
!-
    BEGIN
    REGISTER
	Z,
	N;

    Z = 0;
    N = 6;

    WHILE 1 DO
	BEGIN
	IF (N = .N-1) GEQ 0
	THEN
	    Z = %O'50' * .Z + F7TO50(.CHAR) ;

	ADVANCE();
	IF TYPE(.TFLAG) GTR T_ALPHA THEN EXITLOOP
	END;
    .Z
    END;
ROUTINE XHELP:NOVALUE=
!+
! FUNCTION
!	Implements the HELP command
!-
    BEGIN
    LOCAL
	R,
	FLAG,
	COUNT;

    FLAG = 0;
    COUNT = 0;

    OUTS('Builtin operators:',%CHAR(CR,LF) );

    INCR I FROM 0 TO .OPTAB[-1]-(OPSIZE+1) BY OPSIZE DO
	BEGIN
	IF .OPTAB[.I] EQL %SIXBIT 'HELP' THEN FLAG=1;
	IF .FLAG
	THEN
	    BEGIN
	    PROP(.OPTAB[.I]);	
	    IF (COUNT = .COUNT+1) MOD 8 EQL 0 
	    THEN
		OUTCRLF()
	    ELSE
		PUTTAB
	    END
	END;

    IF .NEWOPS GEQ 0 
    THEN
	OUTS(%STRING(%CHAR(CR,LF),'User-defined operators:',%CHAR(CR,LF) ));

    COUNT=0;
    INCR I FROM 0 TO .NEWOPS BY OPSIZE DO
	BEGIN
	PROP(.DEFOPTAB[.I]);
	IF (COUNT = .COUNT+1) MOD 8 EQL 0
	THEN
	    OUTCRLF()
	ELSE
	    PUTTAB
	END;

    OUTCRLF()
    END;
ROUTINE GETOP(OPNAME)=
!+
! FUNCTION
!	(SECOND) STACK WORD FOR OPERATOR
!-
    BEGIN
    REGISTER
	R;

    R = ( DECR I FROM .NEWOPS TO 0 BY OPSIZE DO
		IF .OPNAME EQL .DEFOPTAB[.I] THEN EXITLOOP DEFOPTAB[.I] );

    IF .R LSS 0
    THEN
	R = ( DECR I FROM .OPTAB[-1]-(OPSIZE+1) TO 0 BY OPSIZE DO
		IF .OPNAME EQL .OPTAB[.I] THEN EXITLOOP OPTAB[.I] );

    IF .R LSS 0
    THEN
	-1
    ELSE
	OPRETURN(R)
    END;
ROUTINE GETNAMEOP(OPNAME) = 
!+
! FUNCTION
!	Given an operator name (in RAD50) return the encoded value
!	for the operator.
! INPUTS
!	OPNAME	- RAD50 value of a possible operator.
! OUTPUTS
!	-1	No matches (not an operator)
!	-2	Multiple matches (ambiguous)
!	n>0	Encoding for operator to be pushed on DBGSTK
!-
    BEGIN
    LOCAL
	R,
	OP,
	SIXNAME,
	MASK,
	CT,
	NAME50;

    MACRO CHECK(X) = 
	BEGIN
	IF (OP = .(X)) EQL .SIXNAME THEN
	    (CT = -2; R = (X); LEAVE SEARCHTAB);

	IF (.OP<LH> AND %O'770000') NEQ 0
	THEN
	    BEGIN
	    OP = .OP XOR .SIXNAME;
	    OP = .OP AND (NOT .MASK);
	    IF .OP EQL 0 THEN (CT = .CT+1; R = (X))
	    END
	END %;

    LABEL SEARCHTAB;

    NAME50 = .OPNAME;
    OP = 0;
    MASK = -1;

    !+
    ! Convert the name from RAD50 into SIXBIT, as the OPTAB stores them
    ! that way.  Further, it makes it straightforward to compare under a
    ! mask when forcing at least two characters to match.
    !-
    WHILE .NAME50 NEQ 0 DO
	BEGIN
	R = .NAME50 MOD %O'50';
	NAME50 = .NAME50/%O'50';
	OP = .OP+(F50TO7(.R)-%O'40');
	OP = ROT(.OP,-6);
	MASK = LSH(.MASK, -6)
	END;

    SIXNAME = .OP;
    MASK<24,12> = 0;	! FORCE AT LEAST TWO CHARACTER MATCH
    CT = -1;		! COUNT MATCHES

SEARCHTAB:
    BEGIN
    DECR I FROM .NEWOPS TO 0 BY OPSIZE DO CHECK(DEFOPTAB[.I]);
    DECR I FROM .OPTAB[-1]-(OPSIZE+1) TO 0 BY OPSIZE DO CHECK(OPTAB[.I]);
    END;	! of SEARCHTAB:

    SELECTONE .CT OF
	SET
	[-2]:	0;					! Exact match required
	[-1]:	RETURN -1;				! No match
	[0]:	IF NSDDTFA(.OPNAME,0) NEQ 0		! One match
		THEN
		    RETURN -1;
      [OTHERWISE]: RETURN -2				! Multiple matches
      TES;

    RETURN OPRETURN(R)
    END;
ROUTINE GETTEXT : NOVALUE=
!+
! FUNCTION
!	Get ASCII text from input stream and store into the macro-text
!	area.  Since only 18-bit addresses are saved, it is vital that
!	"new" text always begins on a FULLWORD boundary and is padded
!	as necessary to end on a fullword also.
!-
    BEGIN
    VTEMP = .PTEXT<RH> + 1;	! This is an ILDB pointer, so RH would be
				!  one less than actual address.
    DO
	BEGIN
	CH$WCHAR_A( .CHAR, PTEXT );		! Write characters out
	IF .PTEXT<RH> GEQ TEXTAREA[2*NMACROS]
	THEN
	    RETURN ERROR(12);			! No more text space left
	ADVANCE()				! Get next character
	END
    UNTIL ENDOFLINE OR .CHAR EQL ESCAPE OR .CHAR EQL BAR;

    CH$WCHAR_A( %O'177',PTEXT);		! Mark EOT
    ADVANCE();
    PTEXT = CH$PTR( .PTEXT<RH>+1 );	! Force ptr to next fullword
    SIXVP = VTEMP;			! Address of result and
    SIXVC = 1				!  its size
    END;
ROUTINE GETSTRING:NOVALUE=
!+
! FUNCTION
!	Input a text string, either left-justified (ala Bliss-10 syntax)
!       or right-justified (almost useless for anything bigger than one
!       character)
!-
    BEGIN
    LOCAL
	HOLD;

    IF .CHAR EQL SQUOTE
    THEN
	BEGIN
	HOLD = CH$PTR( DBGSTK[.TOPSTK]+1 );	! Bufferspace for a string

	IF .TOPSTK GEQ 0 AND .DBGSTK[.TOPSTK] GEQ 0	! Clean some things off
	THEN						!  the stack
	    BEGIN
	    TOPSTK = .TOPSTK - .DBGSTK[.TOPSTK];
	    HOLD = .HOLD - 1
	    END;

	WHILE 1 DO
	    BEGIN
	    ADVANCE();
	    IF ENDOFLINE THEN EXITLOOP;
	    IF .CHAR EQL SQUOTE			! Eat '' as a single ' value
	    THEN				!  was terminating "'" value
		(ADVANCE();  IF .CHAR NEQ SQUOTE THEN EXITLOOP);
	    CH$WCHAR_A( .CHAR, HOLD )		! copy into output buffer
	    END;

	CH$WCHAR_A(0, HOLD);			! Make it ASCIZ

	HOLD = (CH$DIFF(.HOLD, CH$PTR(DBGSTK))+4)/5;	! Words since base of
							!  the stack
	DBGSTK[.HOLD+1] = .HOLD - .TOPSTK;		! Set length of this
							!  operand
	TOPSTK = .HOLD+1				! Mark new TOS
	END
    ELSE
	!+
	! Should be suspicious of this, as it creates 7-bit ASCII which is
	!  RIGHT-JUSTIFIED.  This can't be very useful for anything but a
	!  single character operator, such as is used when defining new
	!  operators.
	!-
	BEGIN
	HOLD = 0;
	WHILE 1 DO
	    BEGIN
	    ADVANCE();
	    IF ENDOFLINE THEN EXITLOOP;
	    IF .CHAR EQL DQUOTE
	    THEN
		(ADVANCE();  IF .CHAR NEQ DQUOTE THEN EXITLOOP);
	    HOLD = .HOLD^7 + .CHAR
	    END;
	IF (QUOTFLG = .QUOTFLG-1) GEQ 0 THEN HOLD = .HOLD^18;	! Char operator
	PUSHITEM(.HOLD)
	END;

    IF .PARSEDEBUG THEN (OUTS('str: '); PRSTK(2))
    END;
ROUTINE EXECUTE: NOVALUE=
!+
! FUNCTION
!	Execute operator on top of SIX12 Parse stack
!-
    BEGIN
    LOCAL
        SAVEGO,				! These are used to save environment
        SAVESTEP,			!  if the operator we are executing
        SAVETRACE,			!  is implemented by USER code, not
        SAVEUSER,			!  by SIX12 code.
        SAVEJBUUO,

	PARSE,				! Indicates parse: infix,prefix, etc.
	ROUTN,				! Semantic action routine
	OPNAME;				! Print-name of the operator
    BIND
	LASTOP=	DBGSTK[.TOPOP-1]	: HBLOCK;

    PARSE = FIRSTONE( .LASTOP<PARSEFIELD> ) -32;

    SIXLC = SIXRC = SIXVC = 0;

    IF .PARSE AND .DBGSTK[.TOPSTK] GTR 0
    THEN
	BEGIN					! RIGHT OPERAND
	SIXRC = .DBGSTK[.TOPSTK];
	SIXRP = DBGSTK[.TOPSTK-.SIXRC];
	TOPSTK = .TOPSTK -.SIXRC -1
	END;

    ROUTN = .LASTOP[.PARSE,RH,0];
    OPNAME = .LASTOP[-1,FW];

    TOPOP = .DBGSTK[.TOPOP] AND %O'777777';		! POP Operator
    TOPSTK = .TOPSTK -2;

    IF .PARSE GEQ 2 AND .DBGSTK[.TOPSTK] GTR 0
    THEN
	BEGIN						! Left operand
	SIXLC = .DBGSTK[.TOPSTK];
	SIXLP = DBGSTK[.TOPSTK-.SIXLC];
	TOPSTK = .TOPSTK - .SIXLC -1
	END;

    ! The following state save/restore is required because
    ! in the case of user-defined operators, the dispatched
    ! routines could themselves contain debug linkages

    SAVEUSER = NOT WITHINSIX12(.ROUTN);
    IF .SAVEUSER
    THEN
        BEGIN
        ! We save and restore these only if a User Op because
        ! internal ops can change the state.  Only a user op
        ! cannot affect the SIX12 state except by recursive
        ! call, which is what this state saving is about
	!
        SAVEGO=.GOFLAG;
        SAVESTEP=.STEPFLAG;
        SETOFF(STEPFLAG);
        SAVETRACE=.TRACEFLAG;
        SETOFF(TRACEFLAG);
        SAVEJBUUO=.$JBUUO;
        GOFLAG=1
        END;

    IF .PARSEDEBUG
    THEN
	BEGIN
        OUTS('ex: ');
        PROP(.OPNAME);
        CRLF
        END;

    ( .ROUTN ) (.PARSE);			! Execute SEMANTIC Action

    IF .SAVEUSER
    THEN
        BEGIN
        $JBUUO = .SAVEJBUUO;
        TRACEFLAG = .SAVETRACE;
        STEPFLAG = .SAVESTEP;
        GOFLAG = .SAVEGO
        END;

    IF ISON(ERRORFLAG) THEN RETURN;

    IF .SIXVC GTR 0
    THEN
	BEGIN					! Get result of operation
	INCR J FROM 0 TO .SIXVC-1  DO DBGSTK[.TOPSTK+1 +.J] = .SIXVP[.J];
	TOPSTK = .TOPSTK+ .SIXVC +1;
	DBGSTK[.TOPSTK] = .SIXVC;
	IF .PARSEDEBUG THEN (OUTS('result: '); PRSTK(2))
	END
    END;
ROUTINE OPERATE(CURRNTOP: HBLOCK):NOVALUE=
!+
! FUNCTION
!	Schedule evaluation of operators on the DBGSTK
! INPUT
!	CURRNTOP	- New operator to either push or evaluate
!-
    BEGIN
    MACRO
	PRIO(OPWD,N)=
		BEGIN
		IF (.OPWD AND (1^N)) NEQ 0
		THEN
		    .OPWD[21-N, LH, 0]
		ELSE
		    0
		END%,

	BRACE(OPWD)=(.OPWD[1, LH, 0] GTR BRACEVAL) %,

	OPERAND=(.TOPSTK GEQ 0 AND .DBGSTK[.TOPSTK] GEQ 0) %,

	CHKPARSES(OP)= (IF .OP<PARSEFIELD> EQL 0 THEN RETURN ERROR(2)) %;

    LOCAL
	P,
	LBRACE;
    LABEL
	OPERANDTEST;

    SETOFF(LBRACE);
    P = PRIO(CURRNTOP, P_POSTFIX);			! Begin with POSTFIX

    IF .P EQL 0 THEN P = PRIO(CURRNTOP, P_INFIX);	! No POSTFIX, try INFIX

    UNTIL .TOPOP<17,1> DO	       		! While the stack isn't empty
	BEGIN
	BIND
	    LASTOP=DBGSTK[.TOPOP-1] : HBLOCK;
OPERANDTEST:
        BEGIN
        IF OPERAND
        THEN					! Found an operand between
	    BEGIN				!  this OP and previous one
	    LOCAL
		PARSE;

	    LASTOP = .LASTOP AND NOT MASK_(P_NULL, P_POSTFIX);
	    CHKPARSES(LASTOP);
	    PARSE = 21 - ( FIRSTONE( .LASTOP<PARSEFIELD> ) - 32);
	    IF PRIO(LASTOP,.PARSE) LSS .P THEN EXITLOOP
	    END
        ELSE
	    BEGIN
	    IF (.P EQL 0) OR BRACE(CURRNTOP)
	        OR ((.LASTOP AND MASK_(P_NULL, P_POSTFIX)) EQL 0)
	    THEN
	        BEGIN
	        IF BRACE(LASTOP) THEN LEAVE OPERANDTEST;
	        IF .CURRNTOP GEQ 0 THEN EXITLOOP
	        END;
	    LASTOP = .LASTOP AND NOT MASK_(P_PREFIX, P_INFIX);
	    CHKPARSES(LASTOP)
	    END;
        END %(OperandTest)%;

	IF  BRACE(LASTOP) AND (.CURRNTOP GEQ 0)
	THEN
	    IF .LASTOP[1,LH,0] EQL PRIO(CURRNTOP,P_POSTFIX) + BRACEVAL
	    THEN
		SETON(LBRACE)				! Onset of "compound"
	    ELSE
		EXITLOOP;

	EXECUTE();					! Previous operator
	IF ISON(ERRORFLAG) OR .LBRACE THEN RETURN
	END;

    ! Now stack the current operator
    !

    IF .CURRNTOP LSS 0 THEN RETURN;
    CURRNTOP = .CURRNTOP AND NOT (IF OPERAND
				THEN 
				    MASK_(P_NULL, P_PREFIX)
				ELSE
				    MASK_(P_POSTFIX, P_INFIX) );

    CHKPARSES(CURRNTOP);
    PUSHOPER(.CURRNTOP);				! Enter in eval stack

    ! If this is a NILARY or POSTFIX Parse, then we can execute it at once
    !
    IF (.CURRNTOP AND MASK_(P_PREFIX, P_INFIX)) EQL 0 THEN EXECUTE()

    END;
ROUTINE PDEBUG(PSWITCH)=
!+
! FUNCTION
!	Parse SIX12 command line and evaluate it
! INPUTS
!	PSWITCH	- Determines if result of expression evaluation should
!		  be printed (1) or suppressed (0)
! OUTPUTS
!	???	Possibly the number of entries to remove from the DBGSTK
!		at end of evaluation
!-
    BEGIN
    ROUTINE IGNORE:NOVALUE=WHILE .CHAR EQL %C' ' OR .CHAR EQL TAB DO ADVANCE();

    LABEL
	DECODE;
    LOCAL
	TFLAG,
	COUNT,
	QUALIFIER,
	SAWQUALIFIER;

    TOPOP = TOPSTK = -1;
    SETOFF(ERRORFLAG);
    QUOTFLG = MODEFLAG =  0;
    QUALIFIER = SAWQUALIFIER = 0;
    WHILE ISOFF(ERRORFLAG) DO
	BEGIN
	IF .QUALIFIER LSS 0
	THEN
	    BEGIN
	    QUALIFIER = -.QUALIFIER;
	    SAWQUALIFIER = 1
	    END
	ELSE
	    BEGIN
	    QUALIFIER = 0;
	    SAWQUALIFIER = 0
	    END;

	IGNORE();

	IF ENDOFLINE
	THEN
	    BEGIN
	    LOCAL
		RESLEN;

	    OPERATE(1^35);				! Clean up & stop
	    IF ISON(ERRORFLAG)
	    THEN
		(GOFLAG = 2;  RETURN 0);		! Never GO after error
	    IF .TOPSTK LEQ 0 THEN RETURN 0;

	    RESLEN = .TOPSTK - .DBGSTK[.TOPSTK];
	    IF ISON(PSWITCH)
	    THEN				! Print result
		INCR J FROM 0 TO .DBGSTK[.TOPSTK]-1  DO
		    BEGIN
		    PUTTAB;
		    OUTRDEF(.DBGSTK[.RESLEN+.J],14);
		    DBLEQL();
		    PRDISP(.DBGSTK[.RESLEN+.J]);
		    CRLF
		    END;
	    RETURN .DBGSTK[.RESLEN]
	    END;

     
	TFLAG = 0;
	IF .CHAR EQL %C'?'
	THEN
	    BEGIN
	    TFLAG = 1;
	    ADVANCE();
	    IF TYPE(.TFLAG) NEQ T_ALPHA THEN EXITLOOP ERROR(2)
	    END;

DECODE:
	BEGIN
	CASE TYPE(.TFLAG) FROM T_NUMBER TO T_OTHER OF
	    SET

	    [T_NUMBER]:
		BEGIN
		LOCAL
		    T,
		    NAME;

		IF .QUOTFLG GTR 0
		THEN
		    (ADVANCE();  LEAVE DECODE WITH ERROR(2));
		T = GETNUMBER();
		IGNORE();
		IF .CHAR EQL %C'%'		! Look for local or actual
		THEN				!  in form of
		    BEGIN			!	n%A - Actual parameter
		    ADVANCE();			!	n%L - STACKLOCAL
		    NAME = GETSYMBOL(.TFLAG);
		    SELECT .NAME OF
			SET
			[%RAD50_10 'A']:	T = GETARGADR(.T,0);
			[%RAD50_10 'L']:	T = GETLCLADR(.T,0);
			[OTHERWISE]:		LEAVE DECODE WITH ERROR(2);
			TES;
		    IF .T EQL -1 THEN LEAVE DECODE WITH ERROR(17);
		    END;
		PUSHITEM(.T)
		END;

	    [T_ALPHA]:
		!
		! GET A SYMBOL and HANDLE MACROS or QUALIFICATION
		!
		BEGIN
		LOCAL
		    NAME,		! RAD50 Symbol name
		    STE	: SYMBOL,
		    PCT_N;		! Indicate SYMBOL%n to get n-th
					!  definition of "SYMBOL"

		NAME = GETSYMBOL(.TFLAG);

		IF (QUOTFLG = .QUOTFLG-1) GEQ 0
		THEN
		    LEAVE DECODE WITH PUSHITEM(.NAME);

		IGNORE();

		IF .CHAR EQL %C'\'
		THEN
		    BEGIN
		    IF .NAME EQL 0 
		    THEN
			!+**************************************+!
			! Don't think this can EVER execute	 !
			!-**************************************-!
			BEGIN
			ISHIGHSYMBOLTABLE();
			IF .GQUALIFIER EQL 0 OR .HQUALIFIER EQL .$JBSYM OR
				.HQUALIFIER EQL .HCACHE
			THEN
			    QUALIFIER = .GQUALIFIER
			ELSE
			    LEAVE DECODE WITH ERROR(36)
			END
		    ELSE
			BEGIN
			QUALIFIER = FINDMODULE(.NAME);
			IF .QUALIFIER EQL 0 
			THEN
			    LEAVE DECODE WITH ERROR(0)
			END;
		    ADVANCE();
		    TFLAG = 0;
		    IF .CHAR EQL %C'?'
		    THEN
			BEGIN
			TFLAG = 1;
			ADVANCE();
			IF TYPE(.TFLAG) NEQ T_ALPHA
			THEN
			    LEAVE DECODE WITH ERROR(2)
			END;
		    NAME = GETSYMBOL(.TFLAG);
		    SAWQUALIFIER = 1
		    END;

		IF .CHAR NEQ %C'%' AND NOT .SAWQUALIFIER
		THEN
		    BEGIN
		    ! Look for Macro definition
		    DECR J FROM .NNAMES TO 0 DO
			IF .SIXNAMES[.J,MACRO_NAME] EQL .NAME
			THEN
			    !+
			    ! Back up byte-pointer in current input stream and
			    ! change to the MACRO stream
			    !-
			    BEGIN
			    PCHAR[.NPCHAR] = CH$PLUS( .PCHAR[.NPCHAR], -1);
			    NPCHAR = .NPCHAR+1;
			    PCHAR[.NPCHAR] = CH$PTR(.SIXNAMES[.J,MACRO_BODY]);
			    ADVANCE();
			    LEAVE DECODE
			    END;
		    END;

		! Have "%" or Non-Macro
		PCT_N = -1;			! Allows operator or user name
		IF .CHAR EQL %C'%'
		THEN
		    BEGIN
		    ADVANCE();
		    IF .SAWQUALIFIER THEN LEAVE DECODE WITH ERROR(2);	! may not use "%" if "\" seen
		    PCT_N = GETNUMBER();
		    IF ISON(ERRORFLAG) THEN LEAVE DECODE
		    END;

		IF .PCT_N LEQ 0 AND NOT .SAWQUALIFIER
		THEN
		    ! look for operator
		    BEGIN
		    LOCAL
			CODING;			! Operator encoded value
		    CODING = GETNAMEOP(.NAME);
		    IF .CODING GTR 0
		    THEN
			LEAVE DECODE WITH OPERATE(.CODING)
		    ELSE
			IF .PCT_N EQL 0 THEN LEAVE DECODE WITH ERROR(0);
		    IF .CODING EQL -2 THEN LEAVE DECODE WITH ERROR(25)
		    END;

		IF .PCT_N EQL -1
		THEN
		    ! Unqualified or \-qualified  name
		    BEGIN
		    LOCAL
			FIRSTTRY,
			HOLD	: SYMBOL,
			PREVSYM	: SYMBOL;

		    FIRSTTRY = 1;
		    HOLD = .QUALIFIER;
		    PREVSYM = 0;
		    WHILE 1 DO
			BEGIN
			HOLD = NSDDTFA(.NAME,.HOLD);
			IF .HOLD EQL 0
			THEN
			    BEGIN
			    IF NOT .FIRSTTRY THEN EXITLOOP;
			    !+
			    ! This is the first time thru the loop.  If we
			    !  found a symbol, save it and look to see if more
			    !  than one symbol matches (that would be an error)
			    !-
			    IF .PREVSYM NEQ 0 THEN EXITLOOP;
			    HOLD = 0;
			    FIRSTTRY = 0
			    END;
			IF .HOLD[RAD50FLAG] NEQ 0
			THEN
			    IF .PREVSYM EQL 0
			    THEN
				PREVSYM = .HOLD
			    ELSE 
				!+
				! If values differ for multiply defined symbols
				!  we will complain.  Otherwise, we allow any
				!  number of occurances of the same value here.
				! Further, if a definition is coming from a
				!  HISEG, we will take it even if it differs
				!  from a LOSEG symbol-table value.
				!-
				IF .HOLD[VALUEWRD] NEQ .PREVSYM[VALUEWRD]
				THEN
				    IF ISHIGHSYMBOLTABLE() AND
					.PREVSYM<RH> GEQ .HCACHE<RH> AND	! hiseg for previous
					.HOLD<RH> LSS .HCACHE<RH>	! lowseg for this one
				    THEN
					0   ! skip
				    ELSE
					LEAVE DECODE WITH (ERRORPARM = .HOLD[RAD50NAME];  ERROR(22))
			END;
		    ! If we get here, PrevSym is either undefined, or
		    ! is the symbol table address of the unique symbol
		    IF .PREVSYM EQL 0
		    THEN
			LEAVE DECODE WITH ERROR(0)
		    ELSE
			LEAVE DECODE WITH PUSHITEM(.PREVSYM[VALUEWRD])
		    END;

		! Must be %-qualified user symbol
		!
		STE = 0;		! to start symbol search
		COUNT = .PCT_N;
		WHILE .COUNT NEQ 0 DO
		    BEGIN
		    STE = NSDDTFA(.NAME,.STE);
		    IF .STE EQL 0 THEN LEAVE DECODE WITH ERROR(0);
		    IF .STE[RAD50FLAG] NEQ DDT$_MODULE
		    THEN
			COUNT = .COUNT-1;	! skip module names
		    END;
		PUSHITEM(.STE[VALUEWRD])
		END;

	    [T_RADIX]:
		!+
		! Implements numeric over-ride with the "#" symbol.  If current
		! radix is decimal, number will be handled as octal (and vice
		! versa).
		!-
		BEGIN
		LOCAL
		    SAVEDBASE;

		IF .QUOTFLG GTR 0
		THEN
		    (ADVANCE();  LEAVE DECODE WITH ERROR(2));
		IOBASE = ( IF (SAVEDBASE = .IOBASE) EQL 8 THEN 10 ELSE 8 );
		ADVANCE();
		PUSHITEM(GETNUMBER());
		IOBASE = .SAVEDBASE
		END;

	    [T_QUOTE]:
		BEGIN
		GETSTRING()
		END;

	    [T_OTHER]:
		BEGIN
		LOCAL
		    CODING;

		IF .CHAR EQL %C'\'
		THEN
		    BEGIN
		    ISHIGHSYMBOLTABLE();
		    IF .GQUALIFIER EQL 0 OR .HQUALIFIER EQL .$JBSYM OR
			.HQUALIFIER EQL .HCACHE
		    THEN
			QUALIFIER = -.GQUALIFIER;
		    ADVANCE();
		    LEAVE DECODE
		    END;
		IF .CHAR EQL %C'='
		THEN
		    BEGIN
		    QUOTFLG = 0;
		    IF .MODEFLAG EQL 0 THEN MODEFLAG = 4
		    END;

		CODING = GETOP(.CHAR^18);
		ADVANCE();
		IF .CODING LSS 0 THEN ERROR(1) ELSE OPERATE(.CODING)
		END
	    TES
	END			!*** End DECODE ***
	END;
    CHAR = CR;
    0
    END;
ROUTINE INPUT = 
!+
! FUNCTION
!	Read next input line from "debugging" input
!-
    BEGIN
%IF TOPS20
%THEN
    OWN
	TXIBUF:	VECTOR[$RDBKL+1];
%FI
    LOCAL
	CCOUNT;

    CCOUNT = 0;		! we use this locally for counting non-LFs

    PCHAR[0] = CH$PTR(BUFF);
    SAWCR = 0;
    SAWEOF = 0;

    IF ISON(DISKIFLAG)
    THEN
	BEGIN
	DO 
	    BEGIN
	    CHAR = INCHARS();
	    CH$WCHAR_A( .CHAR, PCHAR[0] );
	    CCOUNT = .CCOUNT+1;
	    IF ANYLPT() THEN LPTOUT(.CHAR);
	    IF .CHAR EQL CR THEN SAWCR = 1;
	    IF .CHAR EQL -1 THEN SAWEOF = 1
	    END
	UNTIL .CHAR EQL LF OR .CHAR EQL -1;
	CH$WCHAR( CR, .PCHAR[0] )
	END
    ELSE
	! Read from terminal instead...
	!
	BEGIN
%IF TOPS10
%THEN
	DO
	    BEGIN
	    CHAR = INC;
	    CH$WCHAR_A( .CHAR, PCHAR[0] );
	    CCOUNT = .CCOUNT + 1;
	    IF .CHAR EQL CR THEN SAWCR = TRUE
	    END
	UNTIL .CHAR EQL LF;
	IF ANYLPT() THEN OUTSA(CH$PTR(BUFF));	! Echo to LPT as needed
	CH$WCHAR( CR, .PCHAR[0] )
%ELSE
	TXIBUF[$RDCWB] = $RDBKL;		! Number of words following
	TXIBUF[$RDFLG] = RD_BEL+RD_JFN+RD_BBG;	! Break on CRLF, JFN supplied
	IF ISON(DISKIFLAG)
	THEN
	    TXIBUF[$RDIOJ] = .DSKHDR^18 + $NULIO	! Read from DSK:
	ELSE
	    TXIBUF[$RDIOJ] = $PRIIN^18+$PRIOU;	! Use controlling terminal

	TXIBUF[$RDDBP] = CH$PTR(BUFF);		! Destination string
	TXIBUF[$RDDBC] = BUFFERSIZE*5;		!  and size
	TXIBUF[$RDBFP] = CH$PTR(BUFF);		!
	TXIBUF[$RDRTY] = MSG('&');		! ^R retype prompt string
	TXIBUF[$RDBRK] = 0;			! No break chars supplied
	TXIBUF[$RDBKL] = CH$PTR(BUFF);		! Back up limit

	TEXTI( TXIBUF );

	CCOUNT = BUFFERSIZE*5 - .TXIBUF[$RDDBC];! compute bytes read
	IF ANYLPT() THEN OUTSA(CH$PTR(BUFF));	!  and echo to lpt

	IF SCANN(TXIBUF[$RDDBP]) EQL LF
	THEN
	    BEGIN
	    LOCAL
		PTR;

	    BKJFN( .TXIBUF[$RDDBP] ; PTR );
	    IF SCANN(PTR) EQL CR
	    THEN
		BEGIN
		SAWCR = 1;
		CCOUNT = .CCOUNT-1
		END
	    END;
	REPLACEN(TXIBUF[$RDDBP], CR);	! Overwrite LF with CR
%FI
	END;

    PCHAR[0] = CH$PTR(BUFF);
    NPCHAR = 0;
    IF NOT .SAWCR AND NOT .SAWEOF
    THEN
	BEGIN
	LOCAL
	    Q;
	Q = .PCHAR[0];
	IF CH$RCHAR_A(Q) EQL CR THEN SAWCR = 0
	END;
    IF NOT .SAWCR AND NOT .SAWEOF AND .CCOUNT LEQ 1
    THEN
	BEGIN %(want step)%
	PCHAR[0] = MSG('STEP',%CHAR(13));
	OUTC(CR);
	END %(want step)%;
    ADVANCE();
    NCHAR = 0
    END;
ROUTINE PROMPT:NOVALUE=
!+
! FUNCTION
!	Display prompt for debugger command inputs, with indication of
!		Depth of debugger invocations (if not top-level)
!		Output logging to DSK or LPT
!		Whether DEBUG UUO handling is disabled
!-
    BEGIN
    IF .DEPTH GTR 1
    THEN
	BEGIN
	TTOUTDEC(.DEPTH);
	TTOUTC(%C':')
	END;

    IF LPTOUTTING() THEN TTOUTC(%C'-');
    IF .$JB41 EQL DBG_OFF_INST THEN TTOUTC(%C'N');
    TTOUTC(%C'&')
    END;
ROUTINE ISUB=
!+
! FUNCTION
!	Drives syntax analyzer and polls terminal for interrupting command
!	lines.
! OUTPUTS
!	0	- Indicates normal return to caller
!
!	1	- Indicates SET_UNWIND done by ISUBSIG to ISUB's caller
!
!-
    BEGIN
    ENABLE
	ISUBSIG;		! Establish condition handler

    DEPTH = .DEPTH + 1;

    IF ((DCNT = .DCNT-1) LEQ 0) OR .TRACEFLAG
    THEN
	! If we have hit the BGOBASE-th DEBUG UUO and should do further
	! checking on this "sample", or if we are tracing each routine,
	! then come in here...
	!
	BEGIN
	IF .DCNT LEQ 0 THEN (DCNT = BGOBASE;  INCRTOG);	! Set to sample again

	IF ISON(ENABFLAG) AND ISOFF(NOPOLLFLAG)		! Want to check for
	THEN						!  unsolicited TTY:
	    BEGIN					!  input.
%IF TOPS10
%THEN
	    IF SKPINL() THEN (STOPIT();  GOFLAG = 0);
%ELSE
	    IF NOT SIBE($PRIIN)
	    THEN
		(STOPIT();  PROMPT(); GOFLAG = 0)
%FI
	    END
	END;

    UNTIL .GOFLAG DO
	BEGIN
	DO
	    ! Read input until we find something that isn't a "comment"
	    !
	    BEGIN
	    IF .GOFLAG GTR 0 THEN PROMPT();	! Don't prompt on "interrupt"
	    INPUT()
	    END
	UNTIL .CHAR NEQ %C'!';

	IF ISOFF(DISKIFLAG) THEN GOFLAG = 2;
	IF NOT .SAWEOF THEN PDEBUG(1) ELSE GOFLAG = 1;
	TOPOP = TOPSTK = -1;		! Fudge to ensure proper (?) operation
					! if SIX12 is entered recursively.
	END;

    DEPTH = .DEPTH -1;
    RETURN 0;		! if we return out of here, we leave SIX12
    END;
%SBTTL	'Entry into SIX36'
!	------------------

OWN
    ROUTPNT:	REF BLOCK FIELD(ROUT_FIELDS),
    CONDPNT;					! Ptr to conditional action
						!  text.
GLOBAL ROUTINE SIXXEQ(STR)=			
!+
! FUNCTION
!	Pass a command string to SIX36 for execution
! INPUT
!	STR	- Address of an ASCIZ string
!- 
    BEGIN
    LOCAL
	RETVAL;

    IF NOT ISADDRESS(.STR) THEN RETURN 0;	! Not addressable
    IF .STR EQL 0 THEN RETURN 0;		!  or invalid pointer

    NPCHAR = 1;
    PCHAR[1] = CH$PTR(.STR);			! First command to execute
    PCHAR[0] = MSG(%CHAR(CR,CR,LF));		!  followed by a "step" command
    ADVANCE();
    NCHAR = 0;

    ! Invoke parser, but don't print the top-level result.
    !

    RETVAL = PDEBUG(0);

    TOPOP = TOPSTK = -1;

    .RETVAL
    END;
ROUTINE CHKCOND=
!+
! FUNCTION
!	Check condition for action.
! OUTPUTS
!	T/F	Indicates if conditional expression is TRUE or FALSE
!-
    BEGIN
    LOCAL
	RETVAL;

    IF .CONDPNT EQL 0 THEN RETURN 1;	! Unconditional return

    NPCHAR = 1;				! Make input stream be the conditional
    PCHAR[1] = CH$PTR(.CONDPNT);	!  expression, followed by a "STEP"
    PCHAR[0] = MSG(%CHAR(CR,CR,LF));	!  command as previous stream
    ADVANCE();
    NCHAR = 0;

    RETVAL = PDEBUG(0);			! Evaluate the expression
    TOPOP = TOPSTK = -1;	

    .RETVAL				! The result of the conditional expr.
    END;
ROUTINE RTRCAFT:NOVALUE=
    BEGIN
    IF ISEXIT
    THEN
	! Check for TRACE where trace-count expires
	!
	(IF .ROUTPNT[IDIDONF] AND (TRCCNT = .TRCCNT-1) LEQ 0
	 THEN
	    TRACEFLAG = ROUTPNT[IDIDONF] = 0)
    ELSE
	IF .OPQCNT LEQ 0 AND .TRACEFLAG GEQ 0
	THEN
	    (IF CHKCOND()
	     THEN
		(ROUTPNT[IDIDONF] = 1;  TRCCNT = 1;  TRACEFLAG<RH> = -1)
	    )
	ELSE
	    IF .ROUTPNT[IDIDONF] THEN TRCCNT = .TRCCNT+1
    END;
ROUTINE RTRCAT: NOVALUE=
    BEGIN
    IF .OPQCNT LEQ 0 AND .TRACEFLAG GEQ 0
    THEN
	IF CHKCOND() THEN TRACEFLAG = .TRACEFLAG OR NOT 1
    END;
ROUTINE ROPQAFT:NOVALUE=
    BEGIN
    IF ISEXIT
    THEN
	BEGIN
	IF .ROUTPNT[IDIDOFFF] AND (OPQCNT = .OPQCNT-1) LEQ 0
	THEN
	    BEGIN
	    TRACEFLAG = -.ROUTPNT[PREVOFFF] AND NOT 2;
	    STEPFLAG = -.ROUTPNT[PREVSTEPF] AND NOT 2;
	    ROUTPNT[IDIDOFFF] = ROUTPNT[PREVOFFF] = ROUTPNT[PREVSTEPF] = 0
	    END
	END
    ELSE
	IF .OPQCNT LEQ 0
	THEN
	    BEGIN
	    IF CHKCOND()
	    THEN
		BEGIN
		ROUTPNT[IDIDOFFF] = 1;
		ROUTPNT[PREVOFFF] = .TRACEFLAG;
		ROUTPNT[PREVSTEPF] = .STEPFLAG;
		OPQCNT = 1;
		STEPFLAG<RH> = 0;
		TRACEFLAG<RH> = 0
		END
	    END
	ELSE
	    IF .ROUTPNT[IDIDOFFF] THEN OPQCNT = .OPQCNT+1
    END;
ROUTINE ROPQAT: NOVALUE=
    BEGIN 
    IF .STEPFLAG LSS 0 THEN STEPFLAG = .STEPFLAG AND 1;
    IF .TRACEFLAG LSS 0 AND CHKCOND()
    THEN
	TRACEFLAG = .TRACEFLAG AND 1
    END;
ROUTINE RTABREAK: NOVALUE=
!+
! FUNCTION
!	Do necessary processing to RETURN from an ABREAK-point
!-
    BEGIN
    IF ISEXIT
    THEN
	BEGIN
	STOPIT();
	IF NOT .REPORTED
	THEN
	    BEGIN
	    OUTS(%CHAR(CR,LF),'<=> After: ');
	    PRXDISP(.RNAME);
	    IF ISNOVALUE			! Give appropriate message
	    THEN				!  for a NOVALUE routine, or
		SHOWNOVALUE()			!  show the value which is
	    ELSE				!  being returned.
		OUTVALUE(.SIXVREG);
	    REPORTED = 1
	    END;

	! now, remove the TABREAK from the routine
	!
	DSTABREAK(.RNAME)
	END
    END;
ROUTINE RABREAK:NOVALUE=
!+
! FUNCTION
!	Process RETURN from ABREAK points
!-
    BEGIN
    IF ISEXIT AND CHKCOND()
    THEN
	BEGIN
	STOPIT();  
	IF NOT .REPORTED
	THEN
	    BEGIN
	    OUTS(%CHAR(CR,LF),'<=> After: ');
	    PRXDISP(.RNAME);  
	    IF ISNOVALUE THEN SHOWNOVALUE() ELSE OUTVALUE(.SIXVREG);
	    REPORTED = 1
	    END
	END
    END;
ROUTINE RBREAK : NOVALUE=
!+
! FUNCTION
!	Report a ROUTINE Break
!-
    BEGIN
    IF NOT ISEXIT AND CHKCOND()
    THEN 
        BEGIN
        STOPIT();  
        IF NOT .REPORTED
        THEN
	    BEGIN
	    OUTS(%CHAR(CR,LF),'<=> At: ');  
	    PRCALL(.ENTERPNT[NEXT_FRAME], .RNAME);  
	    CRLF;
	    REPORTED = 1
	    END
        END
    END;
! Dispatch vector for action routines.  This must be updated if
! additional action bits are added.  Notice that it is indexed with
! an implicit offset of 18. (the UPLIT(..)-18).

BIND
    RTNSPLIT=
	    UPLIT(
		%( bit 18 action )%	RBREAK,
		%( bit 19 action )%	RABREAK,
		%( bit 20 action )%	ROPQAT,
		%( bit 21 action )%	ROPQAFT,
		%( bit 22 action )%	RTRCAT,
		%( bit 23 action )%	RTRCAFT,
		%( bit 24 action )%	RTABREAK,
		%( remaining bits )%	REP 11 OF(DOTVREG)
	    )-18 : VECTOR;
ROUTINE CALLENABLED(FRAME: REF VECTOR, EXITCODE, HANDLER, CALLEE)=
!+
! FUNCTION
!	This is a VERY DELICATE piece of code. It is the FIRST PLACE you
!	should look if the signal handler in SIX12 starts blowing up.
!	Critical assumption is that NO LOCALS and NO REGISTERS are declared,
!	so only .ENT.0 is called by this routine to set up the Frame Pointer
!	for the arguments.
!	This is important, because the ExitHandler routine, which is called
!	via a JRST (!) instruction from the unwinder, assumes it can POP
!	 to clean up the stack
!
!	It is passed a 4-word "enable frame" pointer.  The frame is set up
!	to hold the 2-word enable stack frame and the 2-word dispatch vector.
!	It is the responsibility of the caller to unlink the exception
!	frame pointer if this is desired.
!
!	+----------------------+
!	| exit code addr       | 3
!	+----------------------+
!	| handler code addr    | 2 <----+
!	+----------------------+	|
!	| dispatch pointer     | 1 -----+
!	+----------------------+
!	| efpnt. link	  | 0
!	+----------------------+
!
    BEGIN
    FRAME[0] = .EFPNT$;
    FRAME[1] = FRAME[2];
    FRAME[2] = .HANDLER<RH>;
    FRAME[3] = .EXITCODE<RH>;

    EFPNT$ = FRAME[0];

    (.CALLEE)()
    END;


ROUTINE EXITHANDLER:NOVALUE=
!+
! FUNCTION
!	This is a delicate routine.  It assumes that no call is
!	made on any of .ENT.0 ... etc. so that the pops
!	will undo the stack in the correct manner for the enable
!	frame established by CallEnabled
!
!-
    BEGIN
    POP(SREG,EFPNT$);
    POP(SREG,FREG);
    POPJ(SREG,0)
    END;
ROUTINE B36ISUB:NOVALUE=
!+
! FUNCTION
!	The purpose of this loop is to handle the case of
!	an UNWIND when the SIGNAL was intercepted by the
!	SIX12 condition handler, i.e., we are unwinding back
!	to SIX12.  If we are doing an UNWIND, the value returned
!	is 1, so we re-enter the command scanner; otherwise
!	the value is 0, so we assume that we got here because
!	we left the command loop in ISUB.
!-
    BEGIN
    LOCAL
        SAVE:	VECTOR[4];

    SAVE[0] = .ENTERPNT;
    SAVE[1] = .RTNLVL;
    SAVE[2] = .INSIXHDR;
    SAVE[3] = .ENTERSP;

    WHILE ISUB() DO
	!+
	! An UNWIND has occurred.  Restore importint info about the current
	!  invocation of SIX36 and give another command prompt at the present
	!  level.
	!-
        BEGIN
        ENTERPNT = .SAVE[0];
        RTNLVL = .SAVE[1];
        INSIXHDR = .SAVE[2];
	ENTERSP = .SAVE[3];
        GOFLAG=2
        END
    END;
ROUTINE ISUBSIG(SIGNL: REF VECTOR,MECH: REF VECTOR,ENBL)=
!+
! FUNCTION
!
!	We get here under several conditions:
!
!	> We are handling a signal which has been generated by
!	someone SIX12 called.
!
!	> We are the first intercept of a SIX12-generated SIGNAL
!
!	> We are doing an UNWIND to ourself
!
!	> We are doing an UNWIND to some outer handler
!
!
!	SIGNL[1] is the signal value
!
!	The cleanup on an UNWIND consists of decrementing the
!	depth counter
!-
    BEGIN
    REGISTER
	SAVER;			! This must be a register
    LOCAL
	SAVE:	VECTOR[6];
    BUILTIN
	SP, FP;
    MACRO
	RETURNVALUE(X)=
			BEGIN 
			RTNLVL = .SAVE[1]; 
			ENTERPNT = .SAVE[2]; 
			INSIXHDR = .SAVE[3];
			RNAME = .SAVE[4];
			ENTERSP = .SAVE[5];
			RETURN (X) 
			END %;

    SAVER = .SIXVREG;
    SIXVREG = .VREG;

    SAVE[1] = .RTNLVL;
    SAVE[2] = .ENTERPNT;
    SAVE[3] = .INSIXHDR;
    SAVE[4] = .RNAME;
    SAVE[5] = .ENTERSP;

    ENTERPNT = .FP<RH>;			! Point to current frame chain
    ENTERSP = SIGNL;			! SP where this frame's arglist starts?

    IF .SIXSTK EQL 0 THEN SIXSTK = .SP;	! Set up valid saved SP

    IF .SIGNL[1] EQL SIXUNWSIGNAL
    THEN
	BEGIN %(start unwind)%
	IF (WHACKS = .WHACKS - 1) LEQ 0 
	THEN
	    BEGIN
	    ! we've reached the depth we want
	    !
	    SETON(WHACKING);
	    SETUNWIND();
	    RETURNVALUE(1)
	    END;
	RETURNVALUE(0)		! resignal
	END %(start unwind)%;
    !
    ! We would like to make this test based on the (signl)[2]
    ! value, which should be the PC of the signal caller, but
    ! which does not currently exist.
    !
    !
    !	Otherwise, a fairly conventional signal
    !
    IF WITHINSIX12(GETCALLFROM(.ENTERPNT[NEXT_FRAME])) AND ISOFF(WHACKING)
    THEN 
	! This handles the case of the SIGNAL command
	! from SIX12, so we don't get an unnecessary
	! call to the user
	!
	RETURN 0;
    
    IF .SIGNL[1] EQL .UNWINDVALUE 
    THEN
	BEGIN %(unwinding)%
	IF ISOFF(WHACKING)
	THEN
	    BEGIN
	    OUTS('SIX12: Unwinding level ');
	    OUTD(.DEPTH);
	    OUTCRLF()
	    END;

	DEPTH = .DEPTH -1;
	MECH[1] = 1;		! if unwinding to ourself,
				    ! this will cause SIX12 to
				    ! be re-invoked, else it does
				    ! nothing
	RETURNVALUE(1)
	END %(unwinding)%;

    IF .SIGNL[1] EQL .UNWINDVALUE THEN RETURNVALUE(0);

    !	If we get a signal, we first report it and call ourself
    !	recursively, and then resignal upon return.  
    !
    !	If we had the PC in the signl vector, we could determine that
    !	the signal came from SIX12, and could punt doing this
    !	call (and could provide useful information when we were not
    !	handing a SIX12-generated signal, like where it came from!)
    !
    
    OUTS('SIX12 signal handler called from ');
    PRDISP(GETCALLFROM(.ENTERPNT[NEXT_FRAME]));
    OUTS(' with signal ');
    OUTDEFAULT(.SIGNL[1]);
    OUTCRLF();

    STOPIT();
    B36ISUB();

    RTNLVL = .SAVE[1];
    ENTERPNT = .SAVE[2];
    INSIXHDR = .SAVE[3];
    RNAME = .SAVE[4];
    ENTERSP = .SAVE[5];

    EXCH(SAVER,SIXVREG);
    RETURN 0;					! resignal
    END;
ROUTINE OUTERHANDLER(SIGNL: REF VECTOR,MECH: REF VECTOR,ENBL)=
!+
! FUNCTION
!	This routine is enabled by INITSIX12 to catch an
!	otherwise unintercepted signal.  Its default action
!	(unlike ISubSig) is to RESUME!!!!
!-
    BEGIN
    REGISTER
        SAVER;
    LOCAL
        SAVE:	VECTOR[6];

    SAVER = .SIXVREG;
    SAVE[1] = .RTNLVL;
    SAVE[2] = .ENTERPNT;
    SAVE[3] = .INSIXHDR;
    SAVE[4] = .$JBUUO;			! Must save 36 bits so that
    SAVE[5] = .ENTERSP;				!  flags are preserved.

    ENTERPNT = .FREG<RH>;

    OUTS('SIX12 outermost signal handler called ');

    IF .SIGNL[1] EQL .UNWINDVALUE
    THEN
        OUTS('during UNWIND')
    ELSE
        BEGIN
        OUTS('from ');
        PRDISP(GETCALLFROM(..ENTERPNT));
        OUTS(' with signal ');
        OUTDEFAULT(.SIGNL[1])
        END;
    OUTCRLF();

    STOPIT();
    B36ISUB();

    RTNLVL= .SAVE[1];
    ENTERPNT = .SAVE[2];
    INSIXHDR = .SAVE[3];
    $JBUUO = .SAVE[4];
    ENTERSP = .SAVE[5];

    EXCH(SAVER,SIXVREG);

    RETURN 1;						! resume
    END;
%SBTTL	'DEBUG. UUO Processing'
LINKAGE
    SAVEMOST=	PUSHJ: LINKAGE_REGS(SREG,FREG,VREG)
			PRESERVE(PRREGS,NPREGS);	! Saves all ACs

ROUTINE CALLEM(DUMMY) : SAVEMOST=
!+
! FUNCTION
!       This routine does the bulk of the work in processing a DEBUG. UUO.
!       It is separate from UUOH, as it is allowed to allocate stack storage
!       and will be JRST-ed to from UUOH
! INPUTS
!	DUMMY	- Dummy formal parameter, such that we can easily determine
!		  our SP before the routine saves any registers, etc.
! NOTES
!	One piece of obscurity is the requirement that this procedure must
!	have a "saved" FP generated for itself.  This insures that the
!	ENTERPNT really points to the correct place, such that RETURN et al
!	will continue to work.
!
!-
    BEGIN
    REGISTER
	RSAVE;
    LOCAL
	SAVE:	VECTOR[4],
	L;
    BUILTIN
	FP;

    RSAVE = .SIXVREG;
    REPORTED = 0;				! nothing yet said
    HCACHE = 0;					! invalidate hiseg sym cache
    SIXVREG = .VREG;
    SAVE[0] = .RTNLVL;
    SETISEXIT();
    SAVE[1] = .ENTERPNT;
    SAVE[2] = .DISKIFLAG;			! turn off disk input
    SAVE[3] = .ENTERSP;
    IF .INSIXHDR THEN RETURN .RSAVE;
    SETOFF(DISKIFLAG);
    ENTERPNT = .FP;
    ENTERSP = DUMMY-1;				! Ignore the FP when computing
						!  stack at entry

    WHACKS = 0;					! for unwinding 
    SETOFF(WHACKING);
    IF .NVALS GEQ 0 THEN CKVALS(.RNAME, .RTNLVL);
    IF ISINTBL			  		! Marked as 'interesting'
    THEN
	IF (L = CFINDR(.RNAME)) GEQ 0   	! Look-up the routine in the
	THEN			    		!  action table to see what
	    BEGIN				!  kind of break|trace this is
	    ROUTPNT = ROUTS[.L,ROUT_INFO];
	    DECR J FROM MAXACTRTN TO 18 DO
		IF .ROUTPNT[INTEREST(.J)]	! Interested in this event
		THEN
		    BEGIN
		    CONDPNT = .ROUTPNT[CNDACTION(.J)];	! Set conditional
							!  action text ptr
		    (.RTNSPLIT[.J]) ()
		    END
	    END;


    IF .TRACEFLAG LSS 0 AND NOT .REPORTED AND .STEPFLAG EQL 0
    THEN
	IF ISEXIT 
	THEN
	    BEGIN
	    IF .TRACEFLAG<1,1>
	    THEN
		BEGIN
		OUTS('<-- ');
		PRXDISP(.RNAME)
		END;
	    IF ISNOVALUE THEN SHOWNOVALUE() ELSE OUTVALUE(.SIXVREG)
	    END
	ELSE
	    BEGIN
	    OUTS('--> ');
	    PRCALL(.ENTERPNT[NEXT_FRAME],.RNAME);
	    IF .TRACEFLAG<1,1> THEN CRLF
	    END;

    IF .STEPFLAG LSS 0
    THEN
	IF ISEXIT
	THEN
	    RABREAK()
	ELSE
	    RBREAK();

    ! The following two statements handle the opaque manipulations
    ! by converting the value 1 in TraceFlag and StepFlag to -1 when
    ! appropriate
    !
    IF .TRACEFLAG THEN SETON(TRACEFLAG) ELSE SETOFF(TRACEFLAG);
    IF .STEPFLAG THEN SETON(STEPFLAG) ELSE SETOFF(STEPFLAG);

    B36ISUB();

    RTNLVL = .SAVE[0];
    ENTERPNT = .SAVE[1];
    DISKIFLAG = .SAVE[2];
    ENTERSP = .SAVE[3];

    EXCH(RSAVE,SIXVREG)
    END;
ROUTINE UUOH: NOVALUE=
!+
! FUNCTION
!	DEBUG UUO handler.
!
! NOTES
!	This routine MUST not HAVE ANY Local, Register, or DYNAMIC Bind 
!	DECLARATIONS which would cause registers to be saved.
!	Further, it should not modify ANY registers, in case GLOBAL REGISTERs
!	or input-output parameters are present.
!
!	This routine does use a couple of registers while implemented field
!	references via Load Byte and Deposit Byte instructions.  In this case,
!	it is necessary to explicitly save/restore those registers in OWN
!	storage. 
!
!	In short, to know whether or not any registers are being smashed, it
!	is necessary to look at the code produced.
!-
    BEGIN
    BUILTIN
	SP, FP;
    REGISTER
	RETVAL=	VREG,
	RSAVE;			! We need at least one NOPRESERVE REGISTER
    OWN
	SAVED_AC,		!  and we will preserve it here

	SAVE_AC2;		! Sometimes we need to save/restore AC2.
				!  Actually, when %VARIANT EQL 10, we use AC1
				!  instead of AC2.
    MAP
	$JBUUO	: $INSTRUCTION;

%IF EXTENDED
%THEN
    PUSH(SP, SWT[$AROPC,FW]);		! Make non-zero "trap" look like
%FI					!  regular "call" to entrypoint.
	
    SAVED_AC = .RSAVE;			! Save otherwise unpreserved register

    RETVAL = .RETVAL;			! Tie up VREG across body of routine

    RSAVE = .INSIXHDR;			! Copy to register for safety

    IF .RSAVE OR ((SIXTOG = .SIXTOG-1) GTR 0 AND .STEPFLAG EQL 0 )
    THEN 
	BEGIN
	DCNT = .DCNT-1; 
	RSAVE = .SAVED_AC;
	POPJ(SP,0)
	END;

    MACHOP( %O'202', S1036(1,2), SAVE_AC2 );	! MOVEM AC2,SAVE_AC2.

%IF NOT EXTENDED
%THEN
    BEGIN
    MAP
	RSAVE	: $INSTRUCTION;

    RSAVE = ..SP;			! Get return address
    SWT[$AROPC,FW] = .RSAVE<RH>;	!  and store into dummy SWTRP% block
    SWT[$ARPFL,LH,0] = .RSAVE<LH>;	! Also get flags,

    RSAVE = .$JBUUO;			! Get offending instruction
    SWT[$AREFA,FW] = .RSAVE[M_OFFSET];	!  and save effective adr in DEBUG. UUO
    SWT[$ARPFL,9,9,0] = .RSAVE[M_REGF];	!  and the AC used
    END;
%ELSE
    RSAVE = .SWT[$AROPC,FW];		! Continuation PC
    RSAVE = .(.RSAVE-1);		! The DEBUG. UUO
    $JBUUO = .RSAVE;
%FI

    RSAVE = .$JBUUO;			! Force into my preserved temp reg.

    IF NOT (.RSAVE AND BITVAL(EXITPOS)) NEQ 0
    THEN
	BEGIN				! This is a ROUTINE-entry DEBUG. UUO
	BIND
	    P= RSAVE: REF $INSTRUCTION;
	OWN
	    ECNT;
	REGISTER			! This register is saved/restored
	    OPCODE = S1036(1,2);	!  outside this block.

	! Pop the return address off the stack so that the stack-depth
	!  will be identical to that expected after the DEBUG UUO returns.
	!  This allows us to XEQ the prolog code with the proper context
	!

	POP(SP,P);			! Get pushed address back

	OPCODE = .P[M_LHALF];

	IF .OPCODE EQL CAIOP^9
	THEN
	    !+
	    ! Routine entry sequence marker. Determine length
	    ! of routine prolog from effective address in RH
	    !-
	    BEGIN
	    ECNT = .P[M_IMMEDIATE];
	    AOS(0,P);			! Advance to 1st prolog instruction
	    END
	ELSE
	    !+
	    ! No prolog for this routine
	    !-
	    ECNT = 0;

	VTEMP = .P;			! Save pointer in static storage

	UNTIL (ECNT = .ECNT-1) LSS 0 DO
	    BEGIN
	    XCT(0,VTEMP,0,1);	! Execute instruction(s) after DEBUG UUO
	    AOS(0,VTEMP)	!  push RETURN past them
	    END;

	PUSH(SP,VTEMP)		! and SAVE the return address again
	END;

    MACHOP( %O'200', S1036(1,2), SAVE_AC2 );	! MOVE AC2,SAVE_AC2.

    PUSH(SP, FP);		! Enter a FRAME
    FP = .SP;
    RSAVE = .SAVED_AC;		! Restore value we were preserving.
    RETVAL = .RETVAL;		! Continue to tie-up VREG.

    CALLEM();
    POP(SP, FP);                ! Undo the frame and return to caller
    END;

GLOBAL BIND SIXUUO = UUOH;

!   This definition just results in a symbol table entry
!   for "SIXRET".  The value is define dynamically in INITSIX12.
!
GLOBAL BIND SIXRET = -1;
%SBTTL	'Initialization Code - Called from BLISS Main Routine'
ROUTINE INITSIX12: NOVALUE=
    BEGIN
    LOCAL
	T	: SYMBOL;

    SETOFF(COPQFLAG);
    STEPFLAG = TRACEFLAG = LPTFLAG = OPQCNT = 0;
    INSIXHDR = 0;
    SIXHDR = 0;
    SETOFF(DISKIFLAG);
    SETOFF(DISKOFLAG);
    GQUALIFIER = 0;	
    HQUALIFIER = 0;
    HSYM = 0;				! Unknown condition of high symbols
    DEPTH = 0;

    IF .IJOBSYM EQL 0 THEN IJOBSYM = .$JBSYM;

    NROUTS = NVALS = NNAMES = -1;
    DCNT = SIXTOG = BGOBASE;
    GOFLAG = 1;
    SIXREF = 0;
    NEWOPS = -OPSIZE;
    PTEXT = CH$PTR(TEXTAREA);		   ! Reset ptr to MACRO defn area

    IF (T = NSDDTFA(%RAD50_10 'SIXSP', 0)) NEQ 0
    THEN
	T[INVALIDFLAG] = 1;			! Suppress use of this symbol

    ! Set up definition of SIXRET as "JRST @.JBOPC", so that we can easily
    ! return from DDT with the command:
    !			SIXRET$X
    !
    IF (T = NSDDTFA(%RAD50_10 'SIXRET', 0)) NEQ 0
    THEN
	T[VALUEWRD] = JRSTOP^27 OR 1^22 OR $JBOPC;

    T = NSDDTW(%RAD50_10 'SS$UNW',0,.$JBSYM);	! use explicit lowseg or only symbol table
    IF .T NEQ 0 THEN UNWINDVALUE = .T[VALUEWRD];

    WHACKS = 0;
    SETOFF(WHACKING);

    ! Establish an outermost signal handler which will not be cleaned off the
    !  stack.  This is SIX12's "last-chance" handler.
    !
    CALLENABLED(OUTERSIGNAL,EXITHANDLER,OUTERHANDLER,DOTVREG);

%IF TOPS10
%THEN
    ! Now establish the variables we need to check on to see if the
    ! two-symbol-table hack is going to be used

    T = NSDDTW(%RAD50_10 '.JBHGH',0,.$JBSYM);
    IF .T NEQ 0 THEN JOBHGH = .T[ADDRWRD];

    T = NSDDTW(%RAD50_10 '.HIGH.',0,.$JBSYM);
    IF .T NEQ 0 THEN HIGH = .T[ADDRWRD];

    IF .JOBHGH EQL 0 
    THEN
	IJOBHSM = 0
    ELSE
	BEGIN
	T = NSDDTW(%RAD50_10 '.JBHSM',0,.$JBSYM);
	IF .T NEQ 0 
	THEN
	    IJOBHSM = .T[ADDRWRD]
	ELSE
	    IJOBHSM = 6;

	IF .HIGH NEQ 0
	THEN
	    ! We have seen cases where relocating the hiseg on
	    ! TOPS-20 (at least) does not change the value of
	    ! .JBHGH (stupid, but what can you expect from TOPS-20?)
	    ! but in this case, the value .HIGH. is defined
	    IJOBHSM = .IJOBHSM + .HIGH
	ELSE
	    IJOBHSM = .IJOBHSM + .JOBHGH
	END;
%ELSE
    !+
    ! This stuff just doesn't seem to work right at all on the 20, so we
    ! will suppress it.  [It probably can't happen anyway!]
    IJOBHSM = 0;
    HIGH = 0;
    JOBHGH = 0;
%FI
    IF SIXLSF NEQ 0
    THEN
	NOSIXSYMS();	! Kill Local symbols for SIX12 itself
    IOBASE = 8;
    WDBASE = IWDBASE;

    $JB41 = DBG_ON_INST;		! Instruction to execute on DEBUG. UUO
%IF EXTENDED
%THEN
    SWT[$ARNPC,FW] = 1^18 + $JB41;		! Set LUUO trap addr
    SWTRP_( $FHSLF, $SWLUT, 1^18+SWT )		!  and turn on trapper
%FI
    END;
ROUTINE SIXID: NOVALUE=
!+
! FUNCTION
!	Announce what environment we support
!-
    BEGIN
    OUTS('SIX36 ');
    OUTSA(VERSION);
%IF TOPS10
%THEN
    OUTS(' (TOPS-10 I/O) for Bliss-36');
%ELSE
    OUTS(' (TOPS-20 I/O) for Bliss-36');
%FI
    CRLF
    END;
ROUTINE SIX12A(XP)=
!+
! FUNCTION
!	Common initialization code.
! INPUT
!	XP	- Flag indicating type of initialization
!			Bit 35=1	-> Main Program Entry
!			Otherwise	-> User initialization (explicit)
! OUTPUTS
!	?
!-
    BEGIN
    BUILTIN
	FP, SP;
    LOCAL
	SAVE:	VECTOR[4];

    SAVE[0] = .SIXVREG;
    SIXVREG = .VREG;
    SAVE[1] = .RTNLVL;
    SAVE[2] = .ENTERPNT;
    SAVE[3] = .ENTERSP;

    ENTERPNT = .FP;
    ENTERSP = .FP;

    IF .SIXSTK EQL 0 THEN SIXSTK = .SP;

    SELECTONE .XP OF
	SET

      [%O'400000000000']:			! MAIN PROGRAM ENTRY
	    BEGIN
	    INITSIX12();
	    IF .STARTFLAG NEQ 0
	    THEN
		(GOFLAG = 2;  SIXID(); SETINTERNAL())
	    ELSE
		RETURN .SIXVREG
	    END;

      [%O'377777000000']:			! Main program exit (unused?)
	    RETURN .SIXVREG;

      [OTHERWISE]:				! user call
	    BEGIN
	    STOPIT();
	    CRLF;
	    OUTS('Pause ');
	    OUTDEFAULT(.XP);
	    SIXVREG = .ENTERPNT[RET_ADDRESS];

	    IF WITHINSIX12(.SIXVREG)
	    THEN
		OUTS(' from "within SIX12"')
	    ELSE
		(OUTS(' at ');  PRDISP(.SIXVREG));
	    CRLF;
	    SETINTERNAL();
	    SIXVREG = -1
	    END

	TES;

    SIXTOG = .SIXTOG-1;			! to KEEP COUNTERS IN STEP
    B36ISUB();
    RTNLVL = .SAVE[1];
    ENTERPNT = .SAVE[2];
    ENTERSP = .SAVE[3];

    BEGIN
    REGISTER
	VERYTEMP=VREG;

    VERYTEMP = .SAVE[0];
    EXCH(VERYTEMP, SIXVREG);
    EXCH(VERYTEMP, SAVE[0])
    END
    END;
ROUTINE SIXDD2: NOVALUE=
    BEGIN
    LOCAL
	SAVE:	VECTOR[3];

    IF .SIXSTK EQL 0
    THEN
	BEGIN
	TTOUTS('You must initialize SIX12',%CHAR(CR,LF));
	TTOUTS('Use "PUSHJ SIXSP,SIX36',%CHAR(CR,LF))
	END;

    SAVE[0] = .SIXVREG;
    SIXVREG = .VREG;
    SAVE[1] = .RTNLVL;
    SETINTERNAL();
    SAVE[2] = .ENTERPNT;
    ENTERPNT = .FREG;

    STOPIT();
    SIXTOG = .SIXTOG-1;
    B36ISUB();

    SIXVREG = .SAVE[0];
    RTNLVL = .SAVE[1];
    ENTERPNT = .SAVE[2];
    TTOUTS('Return to DDT',%CHAR(CR,LF))
    END;
GLOBAL ROUTINE SIXDDT:NOVALUE=
!+
! FUNCTION
!	Transfer control to DDT from SIX12
!-
    BEGIN
    SIXDD2();
    IF .$JBDDT NEQ 0 THEN JRST(0,.$JBDDT);

%IF TOPS20
%THEN
    JRST(0,%O'770000')			! Always loads at 770000
%FI
    END;
GLOBAL ROUTINE SIX36=
!+
! FUNCTION
!	Initialization entry used for Bliss-36 compiler.
!-
    BEGIN
    SIX12A(1^35)
    END;

ROUTINE ENDSIX12:NOVALUE = 0;	! Last code address in SIX12 (except "SIX12")

GLOBAL ROUTINE SIX12(XP)=
!+
! FUNCTION
!	User-callable entrypoint into SIX12
! INPUT
!	XP	- initialization parameter value, indicating what sort of
!		  entry this is....
!-
    SIX12A( .XP);

END ELUDOM

MODULE BREGHOME(ENTRY(%NAME('.BREG')), NODEBUG)=
BEGIN
GLOBAL
    %NAME('.BREG');		! Compatibility with B10 environment
END ELUDOM