Trailing-Edge
-
PDP-10 Archives
-
decuslib10-04
-
43,50325/deb2.bli
There are no other files named deb2.bli in the archive.
! File: DEB2.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 DEB2(TIMER=EXTERNAL(SIX12))=
BEGIN
SWITCHES NOLIST;
REQUIRE COMMON.BEG;
REQUIRE IOMACS.BEG;
REQUIRE GTST.BEG;
REQUIRE ST.BEG;
REQUIRE GTX.BEG;
REQUIRE LDSFT.BEG;
REQUIRE LDSF.BEG;
REQUIRE ONCDEB.BEG;
REQUIRE STRUCT.BEG;
REQUIRE FLOW.BEG;
REQUIRE DTC.BEG;
REQUIRE TN.BEG;
SWITCHES NOLIST;
BEGIN
REQUIRE DEBUG.BEG;
GLOBAL PADDR,PNAME;
STRUCTURE NODENAMES[I,J]=ST[.(.NODENAMES)<0,18>,NODEX]<.I,.J>;
STRUCTURE PBLOKFLD[A,B,C]=.A<.B,.C>;
BIND PBLOKFLD STFLD=0:GTFLD=0:TNFLD=0;
STRUCTURE LEXEMEFLD[A,B]=0<.A,.B>;
BIND LEXEMEFLD LEXFLD=0;
MACRO PZ(STR)=PLIT ASCIZ 'STR'$;
BIND DUMMY=PLIT( DFLDTBL GLOBALLY NAMES
PZ(RNPARMSF), STFLD[RNPARMSF],
PZ(SREGF), STFLD[SREGF],
PZ(STOPNCSEBIT), STFLD[STOPNCSEBIT],
PZ(LABUSEDF), STFLD[LABUSEDF],
PZ(LEFTBIT), STFLD[LEFTBIT],
PZ(DEADF), STFLD[DEADF],
PZ(ALIVEF), STFLD[ALIVEF],
PZ(BLF), STFLD[BLF],
PZ(THREAD), STFLD[THREAD],
PZ(STELINK), STFLD[STELINK],
PZ(NAMEPTR), STFLD[NAMEPTR],
PZ(LNKGTF), STFLD[LNKGTF],
PZ(SUBTYPEM), STFLD[SUBTYPEM],
PZ(SIZESTRM), STFLD[SIZESTRM],
PZ(LNKGNMF), STFLD[LNKGNMF],
PZ(LABCELLF), STFLD[LABCELLF],
PZ(ENABLOCF), STFLD[ENABLOCF],
PZ(LNKGDESCF), STFLD[LNKGDESCF],
PZ(BODYSTRM), STFLD[BODYSTRM],
PZ(STREAMF), STFLD[STREAMF],
PZ(LINKFLD), STFLD[LINKFLD],
PZ(WHICHF), STFLD[WHICHF],
PZ(STRUORIACT), STFLD[STRUORIACT],
PZ(NUMPARM), STFLD[NUMPARM],
PZ(NUMFIXED), STFLD[NUMFIXED],
PZ(NUMITED), STFLD[NUMITED],
PZ(SAVLEVEL), STFLD[SAVLEVEL],
PZ(LVLINC), STFLD[LVLINC],
PZ(NCONTIGLOC), STFLD[NCONTIGLOC],
PZ(RETLAB), STFLD[RETLAB],
PZ(RECCOUNTF), STFLD[RECCOUNTF],
PZ(BINDLEXF), STFLD[BINDLEXF],
PZ(UNIQENAMEF), STFLD[UNIQENAMEF],
PZ(BITS), STFLD[BITS],
PZ(UNIQBIT), STFLD[UNIQBIT],
PZ(GLBIND), STFLD[GLBIND],
PZ(NOUPLEVEL), STFLD[NOUPLEVEL],
PZ(UNLIMACTS), STFLD[UNLIMACTS],
PZ(COUNTED), STFLD[COUNTED],
PZ(PRNEXF), STFLD[PRNEXF],
PZ(PRNF), STFLD[PRNF],
PZ(NAMEXP), STFLD[NAMEXP],
PZ(REQINIT), STFLD[REQINIT],
PZ(RELEASEINIT), STFLD[RELEASEINIT],
PZ(RELEASEACTS), STFLD[RELEASEACTS],
PZ(ITSAPLIT), STFLD[ITSAPLIT],
PZ(HAVNOACTS), STFLD[HAVNOACTS],
PZ(REGSTOSAVE), STFLD[REGSTOSAVE],
PZ(REGFORMLST), STFLD[REGFORMLST],
PZ(VCHGLSTF), STFLD[VCHGLSTF],
PZ(NAMEXPTR), STFLD[NAMEXPTR],
PZ(VUSELSTF), STFLD[VUSELSTF],
PZ(LSTWORD), STFLD[LSTWORD],
PZ(INITP), STFLD[INITP],
PZ(NXTHREAD), STFLD[NXTHREAD],
PZ(TYPEF), STFLD[TYPEF],
PZ(MODE), STFLD[MODE],
PZ(POSF), STFLD[POSF],
PZ(SIZEF), STFLD[SIZEF],
PZ(REGF), STFLD[REGF],
PZ(OFFSETF), STFLD[OFFSETF],
PZ(CRLEVEL), GTFLD[CRLEVEL],
PZ(OCCF), GTFLD[OCCF],
PZ(GTHREAD), GTFLD[GTHREAD],
PZ(LABELF), GTFLD[LABELF],
PZ(CSPARENT), GTFLD[CSPARENT],
PZ(CSTHREAD), GTFLD[CSTHREAD],
PZ(GTLDF), GTFLD[GTLDF],
PZ(XGTLDF), GTFLD[XGTLDF],
PZ(ABCF), GTFLD[ABCF],
PZ(LONF), GTFLD[LONF],
PZ(FONF), GTFLD[FONF],
PZ(PCSTHREAD), GTFLD[PCSTHREAD],
PZ(INNEROMEGENT), GTFLD[INNEROMEGENT],
PZ(DTDELETE), GTFLD[DTDELETE],
PZ(COMPLEXITY), GTFLD[COMPLEXITY],
PZ(RUCOMPL), GTFLD[RUCOMPL],
PZ(CSCOMPL), GTFLD[CSCOMPL],
PZ(FLOLSTF), GTFLD[FLOLSTF],
PZ(FPARENT), GTFLD[FPARENT],
PZ(FSTHREAD), GTFLD[FSTHREAD],
PZ(STATE), GTFLD[STATE],
PZ(MKLEVEL), GTFLD[MKLEVEL],
PZ(ENDOFPCS), GTFLD[ENDOFPCS],
PZ(LABELTF), GTFLD[LABELTF],
PZ(LABELFF), GTFLD[LABELFF],
PZ(LABELW), GTFLD[LABELW],
PZ(BITGF), GTFLD[BITGF],
PZ(MUSTGENCODE), GTFLD[MUSTGENCODE],
PZ(DONTUNLINK), GTFLD[DONTUNLINK],
PZ(ENABIT), GTFLD[ENABIT],
PZ(OMEGABIT), GTFLD[OMEGABIT],
PZ(RHOBIT), GTFLD[RHOBIT],
PZ(ADDCOPIED), GTFLD[ADDCOPIED],
PZ(MAXRHOBIT), GTFLD[MAXRHOBIT],
PZ(COPIED), GTFLD[COPIED],
PZ(CSP), GTFLD[CSP],
PZ(CODED), GTFLD[CODED],
PZ(BOGUSBIT), GTFLD[BOGUSBIT],
PZ(CORCSEF), GTFLD[CORCSEF],
PZ(FP), GTFLD[FP],
PZ(PURGEBIT), GTFLD[PURGEBIT],
PZ(TPATH), GTFLD[TPATH],
PZ(CHPDFR), GTFLD[CHPDFR],
PZ(BOUND), GTFLD[BOUND],
PZ(JM), GTFLD[JM],
PZ(MM), GTFLD[MM],
PZ(RM), GTFLD[RM],
PZ(JMMM), GTFLD[JMMM],
PZ(RMMM), GTFLD[RMMM],
PZ(JRMMBITS), GTFLD[JRMMBITS],
PZ(ALPHABIT), GTFLD[ALPHABIT],
PZ(CHIBIT), GTFLD[CHIBIT],
PZ(FLOLSTBIT), GTFLD[FLOLSTBIT],
PZ(PRLGBIT), GTFLD[PRLGBIT],
PZ(XOPF), GTFLD[XOPF],
PZ(PSLGBIT), GTFLD[PSLGBIT],
PZ(CXBITS), GTFLD[CXBITS],
PZ(DELAYED), GTFLD[DELAYED],
PZ(NODEX), GTFLD[NODEX],
PZ(NODESIZEF), GTFLD[NODESIZEF],
PZ(DOTTEDTHING), GTFLD[DOTTEDTHING],
PZ(STOREDINTHING), GTFLD[STOREDINTHING],
PZ(OPR1), GTFLD[OPR1],
PZ(XOPR1), GTFLD[XOPR1],
PZ(OPR1OF1), GTFLD[OPR1OF1],
PZ(OPR2), GTFLD[OPR2],
PZ(XOPR2), GTFLD[XOPR2],
PZ(OPR3), GTFLD[OPR3],
PZ(XOPR3), GTFLD[XOPR3],
PZ(OPR4), GTFLD[OPR4],
PZ(XOPR4), GTFLD[XOPR4],
PZ(OPR5), GTFLD[OPR5],
PZ(OPR6), GTFLD[OPR6],
PZ(OPR7), GTFLD[OPR7],
PZ(NSRFF), GTFLD[NSRFF],
PZ(NSRFRF), GTFLD[NSRFRF],
PZ(NSRFFF), GTFLD[NSRFFF],
PZ(NSLF), GTFLD[NSLF],
PZ(NSSLF), GTFLD[NSSLF],
PZ(NSSPF), GTFLD[NSSPF],
PZ(NKNEGF), GTFLD[NKNEGF],
PZ(NKNOTF), GTFLD[NKNOTF],
PZ(NIDTF), GTFLD[NIDTF],
PZ(NIMMF), GTFLD[NIMMF],
PZ(NRWORDF), GTFLD[NRWORDF],
PZ(RCMOF), GTFLD[RCMOF],
PZ(RCMTF), GTFLD[RCMTF],
PZ(RCNTF), GTFLD[RCNTF],
PZ(RCOPTF), GTFLD[RCOPTF],
PZ(RCAF), GTFLD[RCAF],
PZ(RCSF), GTFLD[RCSF],
PZ(RCCF), GTFLD[RCCF],
PZ(ROTHER), GTFLD[ROTHER],
PZ(RCBITS), GTFLD[RCBITS],
PZ(GCODEF), GTFLD[GCODEF],
PZ(LABELREQDF), GTFLD[LABELREQDF],
PZ(SYMOFFF), GTFLD[SYMOFFF],
PZ(SYMRESULT), GTFLD[SYMRESULT],
PZ(BNDTYP), TNFLD[BNDTYP],
PZ(REQD), TNFLD[REQD],
PZ(LDF), TNFLD[LDF],
PZ(PREFF), TNFLD[PREFF],
PZ(LONFU), TNFLD[LONFU],
PZ(LONLU), TNFLD[LONLU],
PZ(FONFU), TNFLD[FONFU],
PZ(FONLU), TNFLD[FONLU],
PZ(TNLITBIT), TNFLD[TNLITBIT],
PZ(TNLITLEX), TNFLD[TNLITLEX],
PZ(TNPERMIT), TNFLD[TNPERMIT],
PZ(BNDLSTHDR), TNFLD[BNDLSTHDR],
PZ(XUSECOMPLEXITY), TNFLD[XUSECOMPLEXITY],
PZ(USECOMPLEXITY), TNFLD[USECOMPLEXITY],
PZ(LEXPART), LEXFLD[LEXPART],
PZ(LEXABCF), LEXFLD[LEXABCF],
PZ(ADDRF), LEXFLD[ADDRF],
PZ(LTYPF), LEXFLD[LTYPF],
PZ(LEXW), LEXFLD[LEXW],
PZ(DELIND), LEXFLD[DELIND],
PZ(SRFRF), LEXFLD[SRFRF],
PZ(SRFFF), LEXFLD[SRFFF],
PZ(SLF), LEXFLD[SLF],
PZ(SSLF), LEXFLD[SSLF],
PZ(SSPF), LEXFLD[SSPF],
PZ(KNEGF), LEXFLD[KNEGF],
PZ(KNOTF), LEXFLD[KNOTF],
PZ(IDTF), LEXFLD[IDTF],
PZ(IMMF), LEXFLD[IMMF],
PZ(RWORDF), LEXFLD[RWORDF],
0, 0);
FORWARD GTA,GTB,GTC,STA,ST1,ST2,ST3,ST4,ST5,ST6,ST7,ST8,ST9,ST10,ST11,ST12;
MACRO
COMMA=OUTPUT(",")$,
NXPRNT=
BEGIN
OUTSSTR('NODEX = ',8);
OUTOCT(.NODE[NODEX],1);
OUTBLANK(1);
IF .NODE[NODEX] LEQ MAXOPERATOR
THEN OUTXSTRING(OPPRNT[.NODE[NODEX]]<29,7>,5,5)
ELSE OUTXSTRING(OBPRNT[.NODE[NODEX]]<29,7>,5,5);
CRLF
END$,
NAMPRNT=
BEGIN
OUTSSTR(' NAME = ',9);
OUTXSTRING(NT[.NODE[NAMEPTR],ACCUM1]<29,7>,10,1);
CRLF
END$,
PRBITS(FLD)=OUTBITS(.NODE[FLD])$,
PRNTIT(STR,NAME)=
BEGIN
OUTS(STR);
OUTS(' = ');
OUTOCT(.NODE[NAME],1);
CRLF
END$;
ROUTINE OUTBITS(VAL)=
BEGIN
OUTS('BITS = ');
DECR I FROM 2 TO 0
DO (OUTNUM(.VAL<.I*6,6>,2,6);
IF .I NEQ 0 THEN COMMA);
CRLF
END;
ROUTINE PRRWD(VAL)=
BEGIN
MAP LEXEME VAL;
OUTOCT(.VAL[SRFF],1); COMMA;
OUTOCT(.VAL[SLF],1); COMMA;
OUTOCT(.VAL[SSLF],1); COMMA;
OUTOCT(.VAL[SSPF],1); COMMA;
OUTOCT(.VAL[KNEGF],1); COMMA;
OUTOCT(.VAL[KNOTF],1); COMMA;
OUTOCT(.VAL[IDTF],1); COMMA;
OUTOCT(.VAL[IMMF],1); COMMA;
OUTOCT(.VAL[LTYPF],1); COMMA;
OUTOCT(.VAL[ADDRF],6);
END;
ROUTINE FLDPRNT(NAME1,NAME2,NODE)=
INCR I FROM 0 TO .DFLDTBL[-1]-1 BY 2
DO IF .NAME1 EQL @(.DFLDTBL[.I])
THEN IF (IF .NAME2 EQL 0
THEN TRUE
ELSE .NAME2 EQL @(.DFLDTBL[.I]+1))
THEN BEGIN
OUTXSTRING((.DFLDTBL[.I])<29,7>,15,0);
OUTS(' = ');
OUTOCT(.(.NODE+.DFLDTBL[.I+1]),1)
END;
ROUTINE OUTFLDPLIT(NODE,PLINT)=
(STRUCTURE PBLOCK[I]=(..PBLOCK+.I)<0,36>;
MAP PBLOCK PLINT;
INCR I FROM 0 TO .PLINT[-1]-1 BY 2
DO (FLDPRNT(.PLINT[.I],.PLINT[.I+1],.NODE); CRLF));
ROUTINE PRNTNODE(NODE,TYPE)=
BEGIN
BIND STVEC NODE1=NODE;
IF .NODE EQL 0 THEN NODE_.PADDR;
NODE_.NODE<0,18>;
CASE .TYPE OF
SET
GTA(.NODE); ! GT DURING LEXSYN/FLOW
GTB(.NODE); ! GT AFTER FLOW
GTC(.NODE); ! GT AFTER TNBIND
STA(.NODE) ! ALL TYPES OF ST
TES;
IF .TYPE LSS 3
THEN (OUTXSTRING(PLIT('OPERANDS:')<29,7>,9,9);
CRLF;
INCR I TO .NODE1[NODESIZEF]-1
DO (PRRWD(.NODE1[OPERAND(.I)]);CRLF));
PADDR_.NODE;
END;
ROUTINE GTA(LEX)=
BEGIN
BIND STVEC NODE=LEX;
MAP LEXEME LEX;
OUTFLDPLIT(.LEX,PLIT(
'GTLDF',0,
'OCCF', 0,
'GTHRE','AD',
'CSPAR','ENT',
'CSTHR','EAD',
'FPARE','NT',
'FSTHR','EAD',
'PCSTH','READ',
'XGTLD','F',
'ABCF', 0,
'INNER','OMEGE',
'CRLEV','EL',
'MKLEV','EL',
'ENDOF','PCS'));
PRBITS(BITGF);
IF .NODE[FLOLSTBIT] THEN PRNTIT('FLOLSTF',FLOLSTF);
NXPRNT;
PRNTIT('NODESIZEF',NODESIZEF);
END;
ROUTINE GTB(LEX)=
BEGIN
BIND STVEC NODE=LEX;
MAP LEXEME LEX;
OUTFLDPLIT(.NODE,PLIT(
'GTLDF',0,
'OCCF', 0,
'CSPAR','ENT',
'CSTHR','EAD',
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'CSCOM','PL',
'RUCOM','PL',
'REGF', 0,
'OFFSE','TF'));
OUTSSTR('STATE = ',8);PRRWD(.NODE[STATE]);CRLF;
PRBITS(BITGF);
NXPRNT;
PRNTIT('NODESIZEF',NODESIZEF);
END;
ROUTINE GTC(LEX)=
BEGIN
BIND STVEC NODE=LEX;
MAP LEXEME LEX;
OUTFLDPLIT(.NODE,PLIT(
'GTLDF',0,
'OCCF', 0,
'LABEL','F',
'CSPAR','ENT',
'CSTHR','EAD',
'LONF', 0,
'FONF', 0,
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'CSCOM','PL',
'DTDEL','ETE',
'REGF', 0,
'OFFSE','TF'));
OUTSSTR('STATE = ',8);PRRWD(.NODE[STATE]);CRLF;
PRNTIT('LABELTF',LABELTF);
PRNTIT('LABELFF',LABELFF);
PRBITS(BITGF);
NXPRNT;
PRNTIT('NODESIZEF',NODESIZEF);
END;
ROUTINE STA(LEX)=
BEGIN
BIND STVEC NODE=LEX;
MAP LEXEME LEX;
IF .NODE[TYPEF] GEQ LOWNAMETYPE THEN NAMPRNT;
SELECT .NODE[TYPEF] OF
NSET
FORWT: ST1(.LEX);
ROUTINET: ST1(.LEX);
GROUTINET: ST1(.LEX);
FORMALT: ST2(.LEX);
GLOBALT: ST2(.LEX);
LOCALT: ST2(.LEX);
OWNT: ST2(.LEX);
REGT: ST2(.LEX);
EXTERNALT: ST3(.LEX);
MBINDT: ST4(.LEX);
LABELT: ST5(.LEX);
DELMT: ST11(.LEX);
SFCONVT: ST11(.LEX);
SFEXPNDT: ST11(.LEX);
STRUFT: ST11(.LEX);
UNDECTYPE: ST6(.LEX);
LNKGNMT: ST7(.LEX);
MACROT: ST8(.LEX);
MACRFT: ST9(.LEX);
STRUCTURET: ST10(.LEX);
SPECFUNT: ST12(.LEX)
TESN;
END;
ROUTINE GENST(NODE)=
BEGIN
MAP STVEC NODE;
OUTFLDPLIT(.NODE,PLIT(
'BLF', 0,
'TYPEF',0,
'THREA','D',
'STELI','NK',
'NAMEP','TR'));
END;
ROUTINE ST1(LEX)=
BEGIN
BIND STVEC NODE=LEX;
MAP LEXEME LEX;
PRNTIT('RNPARMSF',RNPARMSF);
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'LNKGN','MF',
'STRUO','RIACT',
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'RETLA','B',
'UNIQE','NAMEF'));
PRBITS(BITS);
OUTSSTR('REGSTOSAVE = ',13); OUTNUM(.NODE[REGSTOSAVE],2,6); CRLF;
OUTFLDPLIT(.NODE,PLIT(
'REGFO','RMLST',
'NXTHR','EAD'));
IF .NODE[NAMEXP] THEN PRNTIT('NAMEXPTR',NAMEXPTR);
END;
ROUTINE ST2(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'LNKGN','MF',
'STRUO','RIACT',
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'NCONT','IGLOC',
'REGF', 0,
'OFFSE','TF',
'UNIQE','NAMEF'));
PRBITS(BITS);
IF .NODE[NAMEXP]
THEN OUTFLDPLIT(.NODE,PLIT(
'NAMEX','PTR',
'NXTHR','EAD',
'INITP',0))
ELSE OUTFLDPLIT(.NODE,PLIT(
'VCHGL','STF',
'VUSEL','STF',
'NXTHR','EAD',
'INITP',0));
END;
ROUTINE ST3(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'LNKGN','MF',
'STRUO','RIACT',
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'NCONT','IGLOC',
'REGF', 0,
'OFFSE','TF'));
PRBITS(BITS);
IF .NODE[NAMEXP]
THEN PRNTIT('NAMEXPTR',NAMEXPTR)
ELSE (PRNTIT('VCHGLSTF',VCHGLSTF);
PRNTIT('VUSELSTF',VUSELSTF));
PRNTIT('NXTHREAD',NXTHREAD);
END;
ROUTINE ST4(LEX)=
BEGIN
BIND STVEC NODE=LEX;
PRNTIT('SREGF',SREGF);
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'LNKGN','MF',
'STRUO','RIACT',
'MODE', 0,
'POSF', 0,
'SIZEF',0,
'NCONT','IGLOC',
'BINDL','EXF'));
PRBITS(BITS);
END;
ROUTINE ST5(LEX)=
BEGIN
BIND STVEC NODE=LEX;
OUTFLDPLIT(.NODE,PLIT(
'STOPN','CSEBI',
'LABUS','EDF',
'LEFTB','IT',
'DEADF',0,
'ALIVE','F'));
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'LABCE','LLF',
'LINKF','LD',
'LVLIN','C',
'SAVLE','VEL',
'UNIQE','NAMEF'));
END;
ROUTINE ST6(LEX)=GENST(.LEX);
ROUTINE ST7(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
PRNTIT('LNKGTF',LNKGTF);
PRNTIT('LNKGDESCF',LNKGDESCF);
END;
ROUTINE ST8(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'SUBTY','PEM',
'STREA','MF',
'NUMFI','XED',
'NUMIT','ED',
'RECCO','UNTF'));
END;
ROUTINE ST9(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
PRNTIT('STREAMF',STREAMF);
END;
ROUTINE ST10(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
OUTFLDPLIT(.NODE,PLIT(
'SIZES','TRM',
'BODYS','TRM',
'NUMPA','RM'));
END;
ROUTINE ST11(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
PRNTIT('WHICHF',WHICHF);
END;
ROUTINE ST12(LEX)=
BEGIN
BIND STVEC NODE=LEX;
GENST(.NODE);
PRNTIT('LNKGTF',LNKGTF);
PRNTIT('WHICHF',WHICHF);
END;
GLOBAL ROUTINE GTLEX(N)=(LOCAL SAV[16];SAVALL;PRNTNODE(.N,0);RESALL);
GLOBAL ROUTINE GTDELAY(N)=(LOCAL SAV[16];SAVALL;PRNTNODE(.N,1);RESALL);
GLOBAL ROUTINE GTBIND(N)=(LOCAL SAV[16];SAVALL;PRNTNODE(.N,2);RESALL);
GLOBAL ROUTINE STPRNT(N)=(LOCAL SAV[16];SAVALL;PRNTNODE(.N,3);RESALL);
GLOBAL ROUTINE PRWD(WRD)=(LOCAL SAV[16];SAVALL;PRRWD(.WRD);CRLF;RESALL);
GLOBAL ROUTINE TNPRNT(TN)=
BEGIN
MAP GTVEC TN;
MACRO NODE=TN$; ! TO GET THE PRNTIT MACRO
IF .TN EQL 0 THEN TN_.PADDR;
TN_.TN<0,18>;
IF .TN[REQD] NEQ 0 THEN PRNTIT('BNDTYP',BNDTYP);
OUTFLDPLIT(.TN,PLIT(
'REQD', 0,
'LDF', 0,
'PREFF',0,
'LONFU',0,
'LONLU',0,
'FONFU',0,
'FONLU',0));
IF .TN[REQD] EQL 0
THEN PRNTIT('TNPERMIT',TNPERMIT)
ELSE (PRNTIT('TNLITBIT',TNLITBIT);
IF .TN[TNLITBIT]
THEN PRNTIT('TNLITLEX',TNLITLEX)
ELSE OUTFLDPLIT(.TN,PLIT(
'MODE', 0,
'BNDLS','THDR',
'REGF', 0,
'OFFSE','TF')));
PRNTIT('XUSECOMPLEXITY',XUSECOMPLEXITY);
PRNTIT('USECOMPLEXITY',USECOMPLEXITY);
PADDR_.TN;
END;
GLOBAL ROUTINE PRBYTE(ADR,P,S)=
BEGIN
OUTOCT(.(.ADR)<.P,.S>,1);
CRLF
END;
GLOBAL ROUTINE PRTNLST(L)=
BEGIN
LOCAL GTVEC T;
STRUCTURE TNLSTHDR[I,J,K,L]=.TNLSTHDR<.K,.L>;
LOCAL TNREPR TR;
BIND TNLSTHDR LHEAD=.L;
TR_.LHEAD[RLINK];
UNTIL .TR[RLINK] EQL .LHEAD[RLINK] DO
BEGIN
T_.TR[TNPTR];
OUTOCT(.T,1);
OUTS(': ['); OUTOCT(.T[LONFU],1); OUTPUT("-"); OUTOCT(.T[LONLU],1);
OUTPUT(":"); OUTOCT(.T[FONFU],1); OUTPUT("-"); OUTOCT(.T[FONLU],1);
OUTS('] $'); OUTOCT(.T[XUSECOMPLEXITY],1); OUTPUT("-"); OUTOCT(.T[USECOMPLEXITY],1);
CRLF;
TR_.TR[RLINK];
END;
CRLF;
NOVALUE
END;
END
END