! 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