! File:   LISTC.BLI
!
!    This work was supported by the Advanced Research
!    Projects Agency of the Office of the Secretary of
!    Defense (F44620-73-C-0074) and is monitored by the
!    Air Force Office of Scientific Research.

MODULE LISTC(TIMER=EXTERNAL(SIX12))=
BEGIN
!				LISTC MODULE
!				------------
!
!							J. APPERSON
!							S. HOBBS
!						    MODIFIED BY:
!							P. KNUEVEN
!
!
SWITCHES NOLIST;
REQUIRE COMMON.BEG;
REQUIRE PREDEF.BEG;
REQUIRE IOMACS.BEG;
REQUIRE GTST.BEG;
REQUIRE GTX.BEG;
REQUIRE ST.BEG;
REQUIRE LDSFT.BEG;
REQUIRE JBEG.BEG;
SWITCHES LIST;


EXTERNAL
	BRAK1,
	BRAK2,
	CHANGE,
	CSCNAME,
	CSDNAME,
	CSGNAME,
	CSONAME,
	CSPNAME,
	DLABEL,
        FELIST,
        FERASEDET,
        FINAL,
        FINRTNSIZE,
	IDENTFLG,
	IDENTLEX,
	NLHEAD,
NORMALVEC OPERTYPE,
	VTN;

BIND ROUTINESIZE = FINRTNSIZE;



!    THE FOLLOWING SECTION HANDLES LISTING OBJECT CODE



BEGIN


EXTERNAL FINPRINCNT;
BIND CNT=FINPRINCNT;

STRUCTURE VECTOR[I] = [I] (.VECTOR + .I)<0,36>;


MACRO	!  THESE MAY BELONG SOMEWHERE ELSE.....RJ.
	LSLENGTH=0,0,36$,
	DUPLENGTH=0,0,36$,
	LEXEMEF=0,0,36$;

FORWARD
	OUTCODE,
	OUTLAB,
        OUTNAME,
        OUTNAMOFF,
	OUTOPD,
	OUTCSECT,
	OUTPLIT,
	OUTSTORAGE,
	OUTGLBINDS,
	OUTVARS,
        OUTDLAB,
        PLACENXTDLAB,
        OUTDNUM,
        OUTDUNAME,
        ODADR,
        DTYPE,
        OUTDEBSYMTAB,
        OUTSTRNAME,
        OUTDEBNAMTAB,
	OUT11STR;

MACRO
    OUTREG(X)=OUTP(REGNAMES[X])$,
    OUTUNAME(NUM)=(OUTPUT(DOLLAR); OUTDEC(NUM,1))$;

BIND PDP11PRT=PLIT( '; UUO',
	'MOV','MOVB','CMP','CMPB','BIT','BITB',
	'BIC','BICB','BIS','BISB','ADD','SUB',
	'CLR','CLRB','COM','COMB','INC','INCB',
	'DEC','DECB','NEG','NEGB','ADC','ADCB',
	'SBC','SBCB','TST','TSTB','ROR','RORB',
	'ROL','ROLB','ASR','ASRB','ASL','ASLB',
	'JMP','SWAB','JSR','RTS','HALT','WAIT',
	'RTI','IOT','RESET','EMT','TRAP',
	'BR','BR','BNE','BEQ','BGE','BLT','BLE','BGT',
	'BPL','BMI','BHI','BLOS','BVC','BVS','BHIS','BLO',
	'NOP','CLC','00243','.WORD','.WORD',
	'MFPI','MFPD','MTPI','MTPD');


BIND REGNAMES=PLIT(
	'R$0',
	'R$1',
	'R$2',
	'R$3',
	'R$4',
	'R$5',
	'SP',
	'PC');


ROUTINE OUTCODE=
    BEGIN
    EXTERNAL STVEC BRAK1:BRAK2,VECTOR CODENAME;
    LOCAL CASEFLAG,CODE2;
    REGISTER STVEC CODEPTR;

    CASEFLAG_0;
    IF NOT .ALDON
	THEN BEGIN
	    OUTS('.TITLE '); OUTPXLIM(MODNAME,NAMESIZE); CRLF;
	      IF .IDENTFLG THEN (OUTS('.IDENT /');
				 OUT11STR(.IDENTLEX);
				 OUTS('/'); CRLF;
				 IDENTFLG_0);
	    OUTCSECT(MSG(.C)); CSFLAG_0; CRLF;
	    CRLF;
	    IF NOT .TTYLST THEN	!*****  DEBUG  *****
	    INCR I FROM 0 TO 7
		DO (OUTREG(.I); OUTS('=%'); OUTOCT(.I,1); CRLF);
	    ALDON_-1;
	    END;

    CRLF;
    IF .CSFLAG NEQ 0 THEN (OUTCSECT(MSG(.C)); CSFLAG_0; CRLF);
    CRLF;
    IF .DEBFLG AND NOT .MODDONE THEN IF .CODENAME[4] NEQ 0 THEN
	BEGIN  LOCAL GTVEC RNAME;
	RNAME_.CODENAME[4]; TAB;
	OUTDLAB(.RNAME[UNIQENAMEF]);
	CRLF;
	CODESIZE_.CODESIZE+1;
        ROUTINESIZE_.ROUTINESIZE+1;
	END;
    IF (CODE2_.CODENAME[2]) GTR 0 THEN OUTPUT(";");
    OUTPXLIM(CODENAME,NAMESIZE); OUTPUT(":"); CRLF;
    IF .CODE2 NEQ 0 THEN
	(OUTUNAME(ABS(.CODE2)); OUTPUT(":"); CRLF);
    IF .MODDONE AND .MAINDECL
	THEN BEGIN
	    IF .SSTKLEN GTR 0
		THEN (OUTS('?IMOV?I#S$TK-2,SP'); CRLF;
		      OUTS('?IMOV?I#S$TK,$BREG'); CRLF;
		      CODESIZE_.CODESIZE+5;
		      ROUTINESIZE_.ROUTINESIZE+5);
	    END;

    CODEPTR_.BRAK1[NEXTF];
    UNTIL .CODEPTR EQL .BRAK2 DO
	BEGIN
	CASE .CODEPTR[CELLTYPEF] OF
	    SET

	    ! 0 - REF
	    ;

	    ! 1 - CODE
	    IF .CODEPTR[OPF] EQL PINLINE
		THEN BEGIN
		    IF .CODEPTR[INLCOM] THEN
		      (CRLF; OUTPUT(";"));
		    OUT11STR(.CODEPTR[INLNARG]); CRLF;
		    IF .CODEPTR[INLCOM]
		      THEN CRLF
		      ELSE
			(NINLINES_.NINLINES+1;
			 CODESIZE_.CODESIZE-#201;
			 ROUTINESIZE_.ROUTINESIZE-#201)
		    END
		ELSE BEGIN
		    TAB;
		    OUTPXLIM(PDP11PRT[.CODEPTR[OPF]],5);
		    TAB;
		    CASE .OPERTYPE[.CODEPTR[OPF]] OF
		      SET
			% NOOP %
			0;

			% ONEOP %
			OUTOPD(SRCP(.CODEPTR));

			% TWOOP %
			BEGIN
                          OUTOPD(SRCP(.CODEPTR));
                          OUTPUT(",");
                          OUTOPD(DSTP(.CODEPTR))
                        END;

			% BROP %
			OUTOPD(SRCP(.CODEPTR));

			% JSROP %
			BEGIN
                          OUTREG(.CODEPTR[SRCREG]);
                          OUTPUT(",");
                          OUTOPD(DSTP(.CODEPTR))
                        END;

			% RTSOP %
			OUTREG(.CODEPTR[SRCREG]);

			% TRAPOP %
			OUTOCT(.CODEPTR[SRCOFFSET],1);

			% WORDOP %
			OUTNAMOFF(SRCP(.CODEPTR));

			% CASEOP %
			BEGIN
                          OUTNAMOFF(SRCP(.CODEPTR));
                          OUTPUT("-");
                          OUTNAMOFF(DSTP(.CODEPTR))
                        END

                      TES;
		    CRLF;
		    END;

	    ! 2 - LABEL
	    BEGIN
	    IF .SEGSW THEN
		IF CODEP(.CODEPTR[NEXTF]) THEN
		    IF CASPARAMP(.CODEPTR[NEXTF]) THEN
			(CASEFLAG_1; OUTCSECT(MSG(.G)); CRLF);
	    OUTLAB(.CODEPTR);
	    OUTPUT(":");
	    END

	    TES;
        CODEPTR_.CODEPTR[NEXTF];
	IF .CASEFLAG THEN
	    IF NOT CODEP(.CODEPTR) THEN
		(CASEFLAG_0; OUTCSECT(MSG(.C)); CRLF);
	END;

    CRLF;
    IF .SFLG THEN
	BEGIN
	LOCAL SDEV;
	SDEV_.DEVICE;
	DEVICE_TTYDEV;
	OUTPXLIM(CODENAME,NAMESIZE);
        OUTPUT(" ");
        OUTDEC(.ROUTINESIZE,1);
        CRLF;
	DEVICE_.SDEV
	END;
    IF .DEBFLG THEN BEGIN
      OUTPUT("$");
      IF .CODE2 NEQ 0
	THEN OUTUNAME(ABS(.CODE2))
	ELSE OUTPXLIM(CODENAME,NAMESIZE);
      OUTPUT(":");
      CRLF
    END;
    OUTS('; ROUTINE SIZE:  ');
    OUTDEC(.ROUTINESIZE,1);
    CRLF;

    END;


ROUTINE OUTLAB(LAB)=
    BEGIN
    MAP STVEC LAB;
    CASE .LAB[LABTYPEF] OF
	SET
	! 0 - ROUTINE EXIT LABEL
	(OUTPUT("$"); OUTPXLIM(.LAB[LABVALF],NAMESIZE-1));
	! 1 - USER LABEL
	(OUTNAME(.LAB[LABVALF]); ST[.LAB[LABVALF],LABUSEDF]_TRUE);
	! 2 - COMPILER GENERATED LABEL
	(OUTS('L$'); OUTDEC(.LAB[LABVALF],1))
	TES;
    END;


ROUTINE OUTNAME(STE) =
  BEGIN
    MAP STVEC STE;
    IF .STE[UNIQBIT] THEN
	IF ONEOF(.STE[TYPEF],BIT5(LABELT,OWNT,ROUTINET,GROUTINET,FORWT))
	    THEN OUTUNAME(.STE[UNIQENAMEF])
	    ELSE OUTPXLIM(.STE[NAMEPTR],NAMESIZE)
	ELSE OUTPXLIM(.STE[NAMEPTR],NAMESIZE);
  END;




ROUTINE OUTNAMOFF(OPRND) =
BEGIN
  MAP STVEC OPRND;
  IF .OPRND[ANAME] GTR 1 THEN BEGIN
    IF .OPRND[ANAMET] EQL NORMNAME THEN OUTNAME(.OPRND[ANAME])
    ELSF .OPRND[ANAMET] EQL LABELNAME THEN OUTLAB(.ST[.OPRND[ANAME],REFEF])
    ELSE OUTS('$TN');
    IF AOFFSETV(OPRND) EQL 0 THEN RETURN
    ELSF AOFFSETV(OPRND) GTR 0 THEN OUTPUT("+")
    ELSE OUTPUT("-");
    OUTOCT(ABS(AOFFSETV(OPRND)),1)
  END
  ELSF .OPRND[ATYPE] EQL IMMEDAT THEN OUTOCT(.OPRND[AOFFSET],1)
  ELSE BEGIN
    IF AOFFSETV(OPRND) LSS 0 THEN OUTPUT ("-");
    OUTOCT(ABS(AOFFSETV(OPRND)),1)
  END;
END;



ROUTINE OUTOPD(OPRND) =
    BEGIN
    MAP STVEC OPRND;
    LOCAL XMODE;
    IF XMODE_.OPRND[AMODE] THEN OUTPUT("@");
    XMODE_.XMODE AND NOT DEFERRED;
    IF .XMODE EQL GENREG
	THEN OUTREG(.OPRND[AREG])
	ELSF .OPRND[AREG] NEQ 7
	    THEN SELECT .XMODE OF
		    NSET
		    AUTODECR: OUTPUT("-");
		    INDEXED: OUTNAMOFF(.OPRND);
		    ALWAYS: (OUTPUT("(");
			     OUTREG(.OPRND[AREG]);
			     OUTPUT(")"));
		    AUTOINCR: OUTPUT("+");
		    TESN
	    ELSE BEGIN
		IF .XMODE EQL IMMEDIATE THEN OUTPUT("#");
                OUTNAMOFF(.OPRND)
		END;
    END;


    ROUTINE OUTNAMEDISP(S)=
	BEGIN MAP STVEC S; LOCAL STVEC B,N;
	IF .S[NAMEXP] THEN
	    BEGIN 
	    B_.S[NAMEXPTR];
	    N_.S[OFFSETF]-.B[OFFSETF];
	    IF .N NEQ 0 THEN
		BEGIN
		IF .N GTR 0 THEN OUTPUT("+") ELSE OUTPUT("-");
		OUTOCT(ABS(.N),1);
		END;
	    END;
	END;

  ROUTINE OUTCSECT(X)=
  BEGIN

    LOCAL FLAG,NAME;
    BIND SECTPLIT=PLIT ("C",CSCFLG,CSCNAME,
			"G",CSGFLG,CSGNAME,
			"O",CSOFLG,CSONAME,
			"P",CSPFLG,CSPNAME,
			"S",CSDFLG,CSDNAME,
			"N",CSDFLG,CSDNAME);


    INCR I FROM 0 TO .SECTPLIT[-1]-3 BY 3 DO
	IF .SECTPLIT[.I] EQL .(.X)<22,7>
	  THEN (FLAG_.(.SECTPLIT[.I+1]);
		NAME_.(.SECTPLIT[.I+2]);
		EXITLOOP);
    CASE .FLAG OF
	SET
	% 0 %
	  BEGIN
	  IF .CSFLG LEQ 1
	    THEN OUTS('.CSECT ')
	    ELSE OUTS('.PSECT ');
	  OUTPXLIM(CSNAME,4);
	  OUTXSTRING(.X,2,0)
	  END;

	% 1 %
	  (OUTS('.CSECT ');
	   OUT11STR(.NAME));

	% 2 %
	  (OUTS('.PSECT ');
	   OUT11STR(.NAME))

	TES;
    END;

  ROUTINE OUTPLIT(NAM,PP)=
  BEGIN
    MAP STVEC PP:NAM;
    LOCAL STVEC NL, LEXEME LEX;
    BIND CNT=FINPRINCNT;

    ROUTINE OUTSEP=
	IF (CNT_.CNT+1) GEQ 3
	    THEN (CNT_0; CRLF; OUTS('?I.WORD  '))
	    ELSE IF .CNT NEQ 0 THEN OUTPUT(",");

    IF .NAM NEQ 0 THEN
      BEGIN
	IF .NAM[COUNTED] THEN (OUTS('?I+'); OUTOCT(.PP[LSLENGTH],1); CRLF);
	OUTNAME(.NAM);
	OUTS(':?I.WORD  ');
	CNT_-1;
      END;

    NL_.PP[TOPF];
    UNTIL .NL EQL .PP DO ( IF .NL[CELLTYPEF]
      THEN INCR I FROM 1 TO .NL[DUPLENGTH] DO OUTPLIT(0,.NL)
      ELSE 
	BEGIN
	  LEX_.NL[LEXEMEF];
	  CASE .LEX[LTYPF] OF
	    SET
	      0; ! DELIMITER
	      (OUTSEP(); OUTOCT(LITVALUE(.LEX[ADDRF]),1)); ! LITERAL
	      (OUTSEP(); OUTNAME(.LEX); OUTNAMEDISP(.LEX)); ! SYMBOL
	      0; ! GRAPH TABLE NODE
	      0; ! ERROR LEXEME
	      OUTPLIT(0,.LEX[ADDRF]) ! LONG STRING
	    TES
	END;
      NL_.NL[NEXTF]);
  IF .NAM NEQ 0 THEN
    BEGIN
      LOCAL PAD;
      CRLF;
      PAD_.NAM[NCONTIGLOC]-.PP[LSLENGTH]*2;
      IF .PAD LEQ 0 THEN RETURN;
      OUTS('?I.=.+'); OUTOCT(.PAD,1); CRLF;
    END
  END;


ROUTINE OUTSTORAGE(TYPE,REGION,REGTOP,MUSTBEPLIT)=
    BEGIN
    LOCAL BYT,DOLABEL;
    REGISTER STVEC PUR;
    DOLABEL_-1;
    BYT_0;
    PUR_.PURGED;
    WHILE .PUR NEQ 0
	DO BEGIN
	    IF .PUR[TYPEF] EQL .TYPE
	      THEN IF .PUR[ITSAPLIT] EQL .MUSTBEPLIT
		THEN IF NOT .PUR[PRNF]
		  THEN BEGIN
			IF .DOLABEL
			    THEN BEGIN
				OUTCSECT(.REGION); CSFLAG_1;
				CRLF;
				DOLABEL_0;
				END;
			IF .BYT AND LITVALUE(.PUR[SIZEF]) MOD WRDSZ EQL 0
				THEN (OUTS('.EVEN'); CRLF; BYT_0);
			IF .PUR[REQINIT]
			  THEN OUTPLIT(.PUR,.PUR[INITP])
			  ELSE
			BEGIN
			OUTNAME(.PUR);
			OUTS(': .=.+');
			OUTOCT(.PUR[NCONTIGLOC],1);
			CRLF;
			END;
			BYT_.BYT+.PUR[NCONTIGLOC];
			IF .PUR[ITSAPLIT] THEN IF .PUR[COUNTED]
			  THEN BYT_.BYT+2;
			PUR[PRNF]_-1;
			END;
	    PUR_.PUR[THREAD];
	    END;
    IF .BYT THEN (OUTS('.EVEN'); CRLF);
    IF .MODDONE THEN IF .MAINDECL THEN IF @.REGION EQL ASCIZ '.G'
      THEN BEGIN
	IF .DOLABEL THEN
	  (OUTCSECT(MSG(.G)); CSFLAG_1; CRLF);
	OUTSTE(.LEXBREG);
	OUTS(': .=.+2');
	CRLF;
	END;
    END;


ROUTINE OUTGLBINDS=
    BEGIN
    REGISTER STVEC PUR;
    PUR_.PURGED;
    WHILE .PUR NEQ 0 DO
	BEGIN
	IF .PUR[TYPEF] EQL MBINDT
	  THEF .PUR[GLBIND]
	  THEN (OUTSTE(.PUR);
		OUTS(' = ');
		BEGIN
		  LOCAL LEXEME LEX;
		  LEX_.PUR[BINDLEXF];
		  IF .LEX[LTYPF] EQL LITTYP
		    THEN OUTOCT(LITVALUE(.LEX[ADDRF]),1)
		    ELSE (OUTNAME(.LEX); OUTNAMEDISP(.LEX));
		END;
		CRLF;
		OUTS('.GLOBL ');
		OUTSTE(.PUR);
		CRLF);
	PUR_.PUR[THREAD];
	END;
    END;


ROUTINE OUTVARS=
    BEGIN
    LOCAL STVEC SAVPTR;
    BIND VECTOR OUTL=
	PLIT(LEXMUL,LEXDIV,LEXMOD,LEXROT,LEXSHIFT,
		LEXCREATE,LEXEXCHJ,
		LXSIGV,LXSIGR,LXSIGL,LXSIG1,LXENAB,
		LXSAV2,LXSAV3,LXSAV4,LXSAV5,
		LXINT612,LXE612,LXX612,LXY612,
		LXHLNK,LXHLTB,LXIHLNK);
    CRLF; CRLF;
    OUTSTORAGE(OWNT,MSG(.O),.NEXTOWN,FALSE);
    IF .NEXTOWN THEN NEXTOWN_.NEXTOWN+1;
    OUTSTORAGE(GLOBALT,MSG(.G),.NEXTGLOBAL,FALSE);
    IF .NEXTGLOBAL THEN NEXTGLOBAL_.NEXTGLOBAL+1;
    OUTSTORAGE(GLOBALT,MSG(.P),NOVALUE,TRUE);	! PLITS
    OUTGLBINDS();
    SAVPTR_.PURGED;
    WHILE .SAVPTR NEQ 0
	DO BEGIN
	    IF ONEOF(.SAVPTR[TYPEF],BIT3(EXTERNALT,GLOBALT,GROUTINET))
	      THEF NOT (.SAVPTR[PRNEXF] OR .SAVPTR[ITSAPLIT] OR .SAVPTR[NAMEXP])
		THEN BEGIN
		    OUTS('.GLOBL ');
		    OUTSTE(.SAVPTR);
		    SAVPTR[PRNEXF]_-1;
		    CRLF;
		    END;
	    SAVPTR_.SAVPTR[THREAD];
	    END;
    CRLF;
    IF .MODDONE
	THEN BEGIN
	    DATASIZE_.DATASIZE+(.NEXTOWN+.NEXTGLOBAL)/2;
	    DECR I FROM .OUTL[-1]-1 TO 0
		DO BEGIN
		    SAVPTR_@(.OUTL[.I]);
		    IF .SAVPTR[PRNEXF]
			THEN BEGIN
			    OUTS('.GLOBL ');
			    OUTSTE(.SAVPTR);
			    CRLF;
			    SAVPTR[PRNEXF]_0;
			    END;
		    END;
	   IF .MAINDECL THEN
		BEGIN
		OUTS('.GLOBL ');
		OUTSTE(.LEXBREG);
		CRLF;
		END;
	    END;
    IF .MODDONE AND .MAINDECL
	THEN BEGIN
	    IF .SSTKLEN GTR 0
		THEN BEGIN
		    OUTS('.ASECT'); CRLF;
		    OUTS('.=400'); CRLF;
		    OUTS('.=.+'); OUTOCT(2*.SSTKLEN,1); CRLF;
		    OUTS('S$TK=.-2'); CRLF;
		    CRLF;
		    DATASIZE_.DATASIZE+.SSTKLEN;
		    END;
	    END;
    END;



ROUTINE OUTDLAB(L)=
    BEGIN 
    IF .L EQL 0 THEN RETURN OUTS('+0');
    OUTS('D$'); OUTOCT(.L,1);
    END;

ROUTINE PLACENXTDLAB(L)= (MAP GTVEC L;OUTDLAB(DLABEL_.L[UNIQENAMEF]); OUTPUT(":"));

ROUTINE OUTDNUM(X)= (OUTPUT(","); OUTOCT(.X AND #177777,1));

ROUTINE OUTDUNAME(X)= (OUTPUT(","); OUTUNAME(.X));

ROUTINE ODADR(X)= (OUTPUT(","); OUTNAME(.X));

ROUTINE DTYPE(L)=
    BEGIN MAP GTVEC L;
    SELECT .L[TYPEF] OF
	NSET
	ROUTINET : RETURN 2;
	GROUTINET : RETURN 2;
	OWNT : RETURN 3;
	GLOBALT : (RETURN IF .L[ITSAPLIT] THEN 0 ELSE 4);
	LOCALT : RETURN 5;
	REGT : RETURN 7;
	MBINDT :
		BEGIN LOCAL LEXEME X; X_.L[BINDLEXF];
		IF .X[LTYPF] EQL LITTYP THEN RETURN 0 % USED TO BE 8 %;
		IF .X[LTYPF] EQL GTTYP THEN RETURN 14;
		(MAP STVEC X;
		 IF .X[NAMEXP] THEN RETURN
					IF .X[REGF] EQL SP
					  THEN DTYPE(.X)+(-1)^18
					  ELSE 8);
		RETURN 0
		END;
	LABELT : (IF NOT .L[LABUSEDF] THEN RETURN 0;
		  IF .(.L[NAMEPTR])<22,7> EQL "$" THEN RETURN 0;
		  RETURN 9);
	FORMALT : RETURN 16;
	OTHERWISE : RETURN 0
	TESN
    END;



ROUTINE OUTDEBSYMTAB=
    BEGIN
    LOCAL STVEC L:M, GTVEC NAME:T, LEXEME LT, PC;
    EXTERNAL CODENAME;
    MACRO OUTLINKTB=(OUTPUT(","); OUTPXLIM(.LXHLTB[NAMEPTR],NAMESIZE))$;
	! CHANGED OUTLINKTB NOT TO CHECK HYDRASW BECAUSE C.MMP USERS
	! MUST HAVE "LINKTB" GENERATED TOO.  -TL 6/24/74
    ROUTINE BITCOUNT(WORD) =	! COUNT THE ONE BITS
	BEGIN REGISTER XWORD,COUNT;
	COUNT_0; XWORD_.WORD;
	WHILE .XWORD NEQ 0 DO (IF .XWORD THEN COUNT_.COUNT+1; XWORD_.XWORD^(-1));
	.COUNT
	END;
    IF NOT .DEBFLG THEN RETURN;
    M_L_.PURGED; PC_-1;
    WHILE .L NEQ 0 DO
	BEGIN
	IF (T_DTYPE(.L)) NEQ 0 THEN
	    BEGIN MACRO CONTINUE=EXITBLOCK$;
	    IF .L[NAMEXP] OR NOT .L[DEBUGF] THEN CONTINUE;
	    IF .T LSS 0		! LEFT HALF SET BY DTYPE
		THEN (T_.T<RIGHTPART>; L_.L[BINDLEXF]);
	    IF .PC NEQ 0 THEN (OUTCSECT(MSG(.S)); CSFLAG_1; PC_0);
	    CRLF;  PLACENXTDLAB(.M); TAB;
	    SELECT .T OF
	      NSET
		5: IF .L[SREGF] NEQ SP THEN T_6;
		14: IF .L[SREGF] EQL SP THEN T_15;
		16: IF .L[REGF] NEQ SP THEN T_17
	      TESN;
	    NAME_.M[NAMEPTR];OUTDLAB(.NAME[DCHAIN]);NAME[DCHAIN]_.DLABEL;
	    OUTDNUM(.M[UNIQENAMEF]);
	    OUTDNUM(.T); CRLF; TAB;
	    IF .MODDONE THEN OUTPUT("0") ELSE OUTDLAB(ABS(.CODENAME[3]));
	    CASE .T OF
		SET

		0;	! 0, UNUSED TYPE

		0;	! 1, MODULE NAME

		BEGIN	! 2, ROUTINE
		ODADR(.L);
		OUTLINKTB;
		CRLF; OUTS('?I$');
		OUTNAME(.L);
		OUTPUT("-");
		OUTNAME(.L);
		OUTDNUM(.L[RNPARMSF]+.L[REGSTOSAVE]^8); 
		OUTDNUM(.GT[.L[LNKGNMF],LNKGTF]);
		END;

		BEGIN	! 3, OWN
		ODADR(.L); OUTLINKTB;
		CRLF; TAB; OUTOCT(.L[NCONTIGLOCS],1)
		END;

		BEGIN	! 4, GLOBAL
		OUTPUT(","); OUTPXLIM(.L[NAMEPTR],NAMESIZE);
		OUTLINKTB; CRLF; TAB; OUTOCT(.L[NCONTIGLOCS],1)
		END;

		BEGIN	! 5, STACK LOCAL
		T_.CODENAME[4];		! POINTER TO PARENT ROUTINE'S ENTRY
		IF .T NEQ 0 THEN T_BITCOUNT(.T[REGSTOSAVE]);
			! NOTE TO WHOEVER PUT IN THAT CODE FOR
			! THE $SAV-N PC WORD: DEBSW *FORCES*
			! INLINE REGISTER SAVING. -TL
		OUTDNUM(.L[OFFSETF]-(.T+.VTN)*2);
		OUTDNUM(0);
		CRLF; TAB; OUTOCT(.L[NCONTIGLOCS],1)
		END;

		BEGIN	! 6, REGISTER LOCAL
		OUTDNUM(.L[SREGF]);
		END;

		BEGIN	! 7, REGISTER
		OUTDNUM(.L[SREGF]);
		END;

		BEGIN	! 8, SIMPLE BIND
		LT_.L[BINDLEXF];
		IF .LT[LTYPF] EQL LITTYP THEN OUTDNUM(LITVALUE(.LT)) ELSE
			BEGIN
			OUTPUT(",");
			OUTNAME(.LT);
			OUTNAMEDISP(.LT);
			END;
		END;

		BEGIN	! 9, LABEL
		ODADR(.L);
		OUTLINKTB;
		END;

		0;	! 10, UNUSED

		0;	! 11, LINKAGE

		0;	! 12, STRUCTURE

		0;	! 13, MACRO

		BEGIN	! 14, DYNAMIC BIND (IN A REGISTER)
		OUTDNUM(.L[SREGF])
		END;

		BEGIN	! 15, DYNAMIC BIND (IN A STACK TEMPORARY)
		T_.CODENAME[4];
		IF .T NEQ 0 THEN T_BITCOUNT(.T[REGSTOSAVE]);
		OUTDNUM(.L[OFFSETF]-(.T+.VTN)*2);
		END;

		BEGIN	! 16, STACK FORMAL
		OUTDNUM(.L[OFFSETF]);
		END;

		BEGIN	! 17, REGISTER FORMAL
		OUTDNUM(.L[SREGF]);
		END;


		TES;
	    END;
	M_L_.M[THREAD];
	END;
    END;


ROUTINE OUTSTRNAME(L)=
    BEGIN MAP STVEC L; LOCAL C1,C2,CP;
    OUTS('^''');
    OUTXSTRING((.L)<29,7>,9,9);
    OUTS('''');
    END;


ROUTINE OUTDEBNAMTAB=
    BEGIN LOCAL STVEC L, PC;
    IF NOT .MODDONE THEN RETURN;
    IF NOT .DEBFLG THEN RETURN;
    PC_-1; CRLF;
    INCR I FROM 0 TO 124 DO
	BEGIN
	L_.HT[.I,NAMEF];
	WHILE .L NEQ 0 DO
	    BEGIN
	    IF .L[DCHAIN] NEQ 0 THEN
		BEGIN
		IF .PC NEQ 0 THEN
 			BEGIN
			CRLF; IF NOT .LSTFLG AND NOT .TTYLST THEN	! MACRO MUST NOT CROSS PAGE
				IF .NLINES GTR 44 THEN PAGE();
			OUTCSECT(MSG(.N)); CSFLAG_1;PC_0; CRLF; CRLF;
			OUTS('.MACR $NTE X,Y'); CRLF;
			OUTS('.RAD50 /X/'); CRLF;
			OUTS('.WORD Y'); CRLF;
			OUTS('.ENDM'); CRLF; CRLF;
			OUTS('$NMTAB:');
			END;
		CRLF; TAB; OUTS('$NTE'); TAB;
		OUTSTRNAME(.L); OUTPUT(",");
		OUTDLAB(.L[DCHAIN]);
		L[DCHAIN]_0;
		END;
	    L_.L[NAMELINK];
	    END;
	END;
    END;



ROUTINE OUT11STR(LEX)=
    !
    ! ROUTINE TO OUTPUT BLIS11 STRING.
    !
    !  LEXEME ASSUMED OF TYPE LSLEXTYP OR LITTYP.
    !  NOTE:  BLIS11 CHARACTER SEQUENCE IS LOW-ORDER 8 BITS
    !  FOLLOWED BY HIGH-ORDER 8 BITS.
    !
    BEGIN
    ROUTINE OUTWRD(LEX)=
	BEGIN
	MAP LEXEME LEX;
	OUTPUT(LITVALUE(.LEX[ADDRF]) AND #177);
	OUTPUT(LITVALUE(.LEX[ADDRF])^(-8));
	END;

    MAP LEXEME LEX;
    LOCAL STVEC HEAD:CUR;
    IF .LEX[LTYPF] EQL LITTYP THEN RETURN OUTWRD(.LEX);
    HEAD_.LEX[ADDRF];
    CUR_.HEAD[TOPF];
    INCR I FROM 1 TO .HEAD[LSLENGTH] DO
	(OUTWRD(.CUR[LEXEMEF]); CUR_.CUR[NEXTF]);
    END;




GLOBAL ROUTINE FINALDRIV=
    BEGIN
    LOCAL SAVLST;
    FINAL();
    SAVLST_.LSTFLG; LSTFLG_0; !ALWAYS LIST CODE
    OUTCODE();
    FELIST(.NLHEAD);
    FERASEDET(.NLHEAD);
    FELIST(.BRAK1);
    FERASEDET(.BRAK1);
    OUTVARS();
    OUTDEBSYMTAB();
    OUTDEBNAMTAB();
    LSTFLG_.SAVLST;
    NOVALUE
    END;

END
END
END
ELUDOM