      HED NEWID * NEWID CREATES NEW ENTRIES IN THE SYSTEM ID TABLE. THE INPUT * FORMAT IS AS FOLLOWS: * *     NEWID IDCODE,PASSWORD,TIME,DISC * * THESE PROVIDE, RESPECTIVELY, WORDS 0,1-3,4, AND 6 OF THE ID ENTRY.* WORDS 5 AND 7 ARE INTIALIZED TO ZERO.       SPC 2       ORG LIBRA * INPUT ID-TABLE *      LDA IDLEN     A=LENGTH OF IDTABLE.      STA WORD      ADA .-8       AND M64       ADA ADLEN     TEST FOR ENOUGH       ADA P5440      ROOM LEFT      SSA       JMP NEWI2       LDA IDLOC     CALL DISC DRIVER TO       LDB LIBDI      INPUT IDTABLE.       ADB .+8       JSB DISC,I* * * NOW INTERPRET PARAMETERS*       JSB GETID     GET       RSS       JMP LFRER     ID ENTRY.       CPA .+54B     TEST FOR COMMA.       CLA,RSS       OK      JMP LFRER     NOT OK      LDB ID      STB LTEMP * * NOW SCAN PASSWORD *       STA T35LC       JSB NEWIP       STA LTEMP+1       JSB NEWIP       STA LTEMP+2       JSB NEWIP       STA LTEMP+3 * * GET THE ALLOWED TIME*       LDA T35LC     CHECK FOR       CPA .+54B      COMMA      JMP NEWI4       JSB T35CH,I   GET NEXT CHAR.      JMP LFRER       CPA .+54B     MUST BE A COMMA.      RSS       JMP LFRER * NEWI4 JSB NEWI#     GET THE ALLOTTED TIME       STA LTEMP+4     IN MINUTES.       LDA T35LC       CPA .+54B       RSS       JMP LFRER *       JSB NEWI#     GET THE DISC ALLOWED.       STA LTEMP+6       LDA T35LC     MUST BE END OF      CPA .+15B      LINE.      RSS       JMP LFRER *       LDA ENDSK     TEST FOR DISC INPUT DONE.       SZA       JMP *-2 *       LDB IDLEN     SET B TO POINT TO LAST ID ENTRY.      CMB,INB       ADB LIBD      RSS NEWI7 ADB .-8       POINT TO NEXT ENTRY.      CPB LIBD      DONE WITH ID TABLE?       JMP NEWI5     YES.      LDA 1,I       GET TABLE ID.       ADA MID       SUBTRACT TEST ID.       SZA,RSS       TEST FOR EQUAL      JMP NEWI6     GO PRINT MESSAGE.       SSA,RSS       IF LESS WE FOUND A HOLE.      JMP NEWI7     ELSE LOOP.* * SLIDE ID TABLE UP * NEWI5 LDA LIBD      MOVE THE      STA MOVED      FIRST PART       ADA .+8         OF THE ID       STA MOVES        TABLE      STB LTEMP+7   SAVE LOCATION.      CMB,INB       COMPUTE LENGTH OF MOVE.       ADB LIBD      JSB MOVEW       CLB       STB LTEMP+5       STB LTEMP+7       LDA DLTEM     MOVE THE      STA MOVES     NEW PART      LDB .-8         IN.       JSB MOVEW *       LDA IDLEN     MODIFY IDLEN.       ADA .-8       STA IDLEN       IOR M64       TEST IF IDT HAS JUST OVERFLOWED       CPA .-8        A SECTOR.      RSS           IT HAS--HAVE TO MOVE ADT.       JMP NEWI1     IT HASN'T--JUST WRITE BACK IDT.       LDA ADLEN     READ IN ADT.      STA WORD      LDA IDLEN     COMPUTE PROPER CORE LOC TO READ       AND M64        INTO.      CMA,INA       ADA LIBDI       STA 1       LDA ADLOC       JSB DISCL       ISZ ADLOC     BUMP ADT DISC ADDRESS.      LDA IDLEN     COMPUTE TOTAL WORDS TO WRITE OUT      AND M64       ADA ADLEN       RSS NEWI1 LDA IDLEN       STA WORD      LDA IDLOC     OUTPUT      LDB LIBD       TO       JSB DISC,I    DISC.       JMP LENDNEWI2 LDA NEWIA     OUTPUT TABLE FULL MESSAGE       LDB NEWIB       JMP NEWI8 NEWI6 LDA NEWIE     OUTPUT DUPLICATE ENTRY MESSAGE.       LDB NEWIF * NEWI8 STA MOVES     SET UP FOR MOVE       LDA T35B1      ROUTINE      STA MOVED     MOVE STRING       STB LTEMP      INTO BUFFER.       JSB MOVEW       LDA LTEMP       ALS       CMA,INA       CALL      LDB T35B1      DRIVER.NEWI9 JSB TTY35,I       JMP LENDR     TERMINATE.* * OUTPUT MESSAGES * NEWIA DEF *+1       OCT 5111      ASC 6,D TABLE FULLNEWIB EQU .-*+NEWIA+1 NEWIE DEF *+1       OCT 5104      ASC 7,UPLICATE ENTRYNEWIF EQU .-*+NEWIE+1 NEWI# NOP           SCAN FOR A NUMBER.      CLA           INITIALIZE      STA NEWIT      TO ZERO.       JSB T35CH,I   GET NEXT CHARACTER      JMP NEWIZ     DONE      ADA M72B      TEST FOR DIGIT      SSA,RSS       JMP NEWIZ     NOT A DIGIT       ADA .+10      CLE,SSA       JMP NEWIZ       LDB NEWIT       ELB,ELB       SEZ,SLB,RSS       RSS       JMP LFRER       ADB NEWIT       ELB       SEZ,SLB,RSS       RSS       JMP LFRER       ADA 1       SEZ       JMP LFRER       JMP NEWI#+2 NEWIZ LDA NEWIT       JMP NEWI#,I NEWIP NOP           GET NEXT 2 PASSWORD LETTERS.      CLA       LDB T35LC     IF LAST CHARACTER A       CPB .+54B       COMMA, RETURN ZERO.       JMP NEWIP,I       JSB T35CH,I   GET NEXT CHAR.      JMP LFRER       CPA .+54B     IF A COMMA      JMP NEWIP+1       ALF,ALF       SAVE 1ST      STA NEWIT      CHAR.      JSB T35CH,I       JMP LFRER       CPA .+54B     IF COMMA TAKE AS      CLA            ZERO.      ADA NEWIT       JMP NEWIP,I NEWIT BSS 1 $NEW  EQU *       HED KILLID* THE KILLID ROUTINE IS USED TO REMOVE ID CODES FROM THE SYSTEM * IDTABLE. THE FORMAT IS: * *     KILLID - IDCODE * * IDCODE A000 CANNOT BE KILLED BY THIS COMMAND. * * KILLID PERFORMS THE FOLLOWING FUNCTIONS:* * 1. THE ID-CODE IS REMOVED FROM THE IDT. * 2. ANY USERS LOGGED ON WITH THIS NUMBER ARE DUMPED. * 3. ALL LIBRARY SPACE ALLOCATED TO THIS ID IS RETURNED TO THE*    SYSTEM.      SPC 2       ORG LIBRA       JSB GETID     TRANSLATE THE IDCODE.       JMP LFRER     ERROR IF NO CR FOLLOWD.       LDA ID        TEST FOR A000.      CPA A000      JMP KID31 * * READ IN IDT.*       LDA IDLEN       STA WORD      LDA IDLOC       LDB LIBDI       JSB DISCL * * SEARCH IDT. *       LDB IDLEN       CMB,INB       ADB LIBD      LDA IDKID33 CPB LIBD      TEST FOR NOT THERE.       JMP KID32       ADB .-8       TEST FOR FOUND.       CPA 1,I       RSS           FOUND IT.       JMP KID33 * * REMOVE ID FROM TABLE. *       STB MOVED       ADB .+8       STB MOVES       ADB MLIBD       ADB IDLEN       JSB MOVEW * * WRITE BACK TO DISC. *       LDA IDLEN       ADA .+8       STA IDLEN       STA WORD      LDA IDLOC       LDB LIBD      JSB DISCL * * SEARCH TTY TABLES FOR ANY USER TO BE DUMPED.*       LDA .-16      SET COUNTER.      STA KIDC      CCA           SET KIDT TO SAY NONE      STA KIDT       FOUND YET.       LDB DTTY0       ADB .+?ID KID34 LDA 1,I       GET ID FROM TABLE.      CPA ID        IS IT THIS USER?      JMP KID35     YES--GO DUMP HIM. KID37 ADB .+TTY01-TTY00       ISZ KIDC      ANY MORE TO TEST?       JMP KID34     YES.      JMP KID36     NO--TRANSFER TO NEXT PART.* * DUMP THE USER.* KID35 STB KIDB      SAVE POINTER TO TABLE.      CLF 0         INHIBIT INTERRUPT.      CLA           CLEAR USER'S ID.      STA 1,I       ADB .+?STAT-?ID       LDA .-2       SET USER'S STATUS TO -2 TO FORCE      STA 1,I       DISCONNECT.       ADB .+?MASK-?STAT       LDA 1,I       SET MPCOM BIT TO TELL SYSTEM TO       IOR MPCOM      HANDLE IT.       STA MPCOM       ADB .+?LINK-?MASK       JSB KIDEQ,I   REMOVE FROM QUEUE.      STF 0       ISZ KIDT      IS FUSS TABLE IN CORE?      JMP KID38     YES.      LDA M128      NO--READ IT IN.       STA WORD      LDA FUSS,I      LDB LIBDI       JSB DISCL * KID38 LDA KIDC      COMPUTE LOCATION OF USER'S FUSS       ADA .+16       AREA.      ALF,RAR       ADA LIBD      STA KIDP      LDB .-8       ZERO OUT USER'S FUSS AREA.      CLA       STA KIDP,I      ISZ KIDP      INB,SZB       JMP *-3 *       LDB KIDB      GET POINTER AGAIN.      JMP KID37     GO TEST NEXT USER.* KID36 LDA FUSS,I    WRITE BACK FUSS       LDB LIBD       IF ANY USERS       ISZ KIDT        WERE DUMPED.      JSB DISCL * * IF REMOVAL OF THE ID HAS RELEASED A SECTOR, WE CAN* MOVE THE ADT DOWN ONE SECTOR. *       LDA IDLEN     TEST IF IDT IS NOW AN EXACT       AND B77        NUMBER OF SECTORS.       SZA       JMP KID40     IT ISN'T.       LDA ADLEN     READ ADT.       STA WORD      LDA ADLOC       LDB LIBDI       JSB DISCL       CCA           DECREMENT ADLOC.      ADA ADLOC     WRITE ADT BACK.       STA ADLOC       LDB LIBD      JSB DISCL * * WE HAVE NOW GOTTEN RID OF THE USER. THE NEXT STEP IS TO CALL* THE KILLID OVERLAY TO RELEASE ANY SYSTEM SPACE CONSUMED BY THE* USER. * KID40 LDA M252      SET WORD COUNT.       STA WORD      DLD LIB,I     GET DISC ADDRESS      LDA 1          OF OVERLAY.      LDB #LIBI       JMP LIBRA+254 KIDEQ DEF DEQUE * KID31 LDA KIDM1     PRINT "A000 NOT ALLOWED"      LDB .-17      JMP *+3 KID32 LDA KIDM2     PRINT "NO SUCH ID"      LDB .-11      STB KIDC      STA MOVES       LDA T35B1       STA MOVED       BRS       JSB MOVEW       LDA KIDC      CMA,INA       LDB T35B1       JSB TTY35,I       JMP LENDR * KIDM1 DEF *+1       OCT 5101      ASC 8,000 NOT ALLOWED KIDM2 DEF *+1       OCT 5116      ASC 5,O SUCH ID *       ORG LIBRA+254 PERFORM OVERLAY.      JSB DISCL       JMP LIBRA $KID  EQU *       HED KILLID OVERLAY SECTION* THE KILLID OVERLAY IS CALLED BY KILLID AFTER IT HAS TAKEN CARE OF * THE EASY PART OF KILLID. THIS SECTION HAS THE JOB OF REMOVING ALL * FILES BELONGING TO THE ID BEING KILLED FROM THE USER LIBRARY, AND * UPDATING THE ADT APPROPRIATELY.       ORG LIBRA KID24 LDA DIRD3     TEST INDIVIDUAL DIRECTORIES.KID4  STA KIDI      KIDI POINTS TO THE ONE TESTED.      DLD KIDI,I    GET LENGTH AND FIRST ID.      STB KIDT      SAVE FIRST ID FOR LATER.      ADB MID       B=FIRST ID- KEYID       SZA           FORGETTRACK IF IT'S EMPTY       CMB,SSB,INB,SZB  OR IF FIRSTID>KEYID      RSS       JMP KID2KID1  LDA KIDI      CPA DIRD0       JMP LEND      ADA .-7       BUMP TO NEXT TRACK.       JMP KID4* * PROCESS DIRECTORY TRACK IN ORDER TO REMOVE KEY ID ENTRIES. THE* DIRECTORY IS READ INTO THE BEGINNING OF THE WORKSPACE AND IS* SCANNED IN REVERSE ORDER. A TABLE OF PATCHES IS BUILT UP FROM THE * OTHER END. THE FOLLOWING POINTERS ARE USED: * * KIDP1 => DIRECTORY ENTRY BEING TESTED * KIDP2 => FIRST ENTRY FOLLOWING LAST KID ENTRY * KIDP3 => LAST ENTRY IN DIRECTORY* KIDP4 => LAST ENTRY IN PATCH TABLE* KIDK  = -# OF WORDS AVAILABLE FOR PATCH TABLE.* KID2  STA WORD      SET UP LENGTH FOR DISC TRANSFER.      ADA P5440     GET # OF WORDS LEFT       CMA,INA         AS NEGATIVE IN KIDK.      STA KIDK      ADA L5432     SET KIDP3 TO POINT TO LAST      STA KIDP3      ENTRY IN DIRECTORY.      STA KIDP1     SET POINTER TO CURRENT ENTRY.       LDA L5440     INITIALIZE PATCH TABLE      STA KIDP4      POINTER.       LDA KIDI      GET DIRECTORY       ADA .+6        DISC ADDRESS       LDA 0,I         IN A,       LDB LIBDI       ADDRESS OF WORKSPACE      JSB DISCL       IN B, & READ DISC.* KID7  LDA KIDP1,I   GET ID OF NEXT ENTRY      ELA,CLE,ERA       ADA MID       COMPARE WITH KEY ID.      SSA           TEST FOR <      JMP KID6      SZA           TEST FOR >      JMP KID8* * FOUND AN ENTRY FOR KID. NOW REMOVE IT.* KID5  LDB KIDP1     IF THIS IS THE FIRST      ADB .+8        SUCH ENTRY, SET KIDP2 AS       LDA KIDP4       STATED ABOVE.       CPA L5440       STB KIDP2       LDA KIDI,I    ADJUST THE DIRECTORY LENGTH.      ADA .+8       STA KIDI,I*       ADB .-2       SAVE DISC LOC & LENGTH OF AREA      DLD 1,I        IN LTEMP.      DST LTEMP       LDB KIDK      TEST FOR ANY ROOM IN      SZB            PATCH AREA.      JMP KID9* * MAKE ROOM BY PUSHING UP PARTIALLY EXAMINED DIRECTORY. *       LDB KIDP1     SET UP      STB MOVED      DEST AND       LDB KIDP2       SOURCE.       STB MOVES       CMB           COMPUTE #       ADB KIDP3      OF WORDS       CMB             TO MOVE       ADB .-8          AND      JSB MOVEW        DO IT. *       LDB KIDP2     SET B=-# OF WORDS       CMB,INB        GAINED.      ADB KIDP1       LDA KIDP1     ADJUST KIDP2,KIDP3, AND KIDK.       STA KIDP2       LDA KIDP3       ADA 1       STA KIDP3 * KID9  ADB .+2       TAKE 2 WORDS FROM       STB KIDK       PATCH TABLE.       LDB KIDP4     MOVE PATCH POINTER      ADB .-2       BACK2 WORDS.      STB KIDP4       LDB LTEMP+1   GET NEGATIVE WORD LENGTH.       ASR 6         CONVERT TO POSITIVE       CMB,INB        SECTORS.       LDA LTEMP     GET DISC ADDRESS.       DST KIDP4,I   STORE PATCH.* KID8  LDB KIDP1     TEST FOR FINISHED       CPB LIBD       EXAMINING DIRECTORY ENTRIES.       JMP KID6      ADB .-8       IF NOT, MOVE POINTER BACK TO      STB KIDP1     NEXT ENTRY.       JMP KID7* * THE PATCH TABLE IS NOW BUILT. THE NEXT STEP IS TO FIXUP THE DIREC.* KID6  LDA KIDP4     IF THE PATCH TABLE IS EMPTY, WE       CPA L5440      DIDN'T DO ANYTHING SO SKIP THIS      JMP KID18     SECTION.*       LDA KIDI,I      SZA,RSS       IF LENGTH=0 WE DONT HAVE TO       JMP KID10      WRITE IT BACK OUT.       STA WORD      SET UP FOR DISC DRIVER. * * WE FIRST HAVE TO CLOSE UP THE HOLE. THER ARE 2* CASES, DEPENDING UPON WHITHER THE HOLE IS AT THE* BEGINNING OR IN THE MIDDLE. *       LDA KIDP2     WE WILL MOVE FROM KIDP2 IN      STA MOVES      ANY CASE.      LDB KIDT      GET FIRST ID IN B.      CPB ID        IF = HOLE IS AT BEGINNING       JMP KID11     GO SET NEW FIRST ID.      LDA KIDP1     SET DEST. TO BE RIGHT AFTER       ADA .+8        LAST ENTRY EXAMINED.       CPA MOVES     FORGET IT IF SAME AS SOURCE.      JMP KID12       LDB KIDP3     COMPUTE # OF WORDS TO MOVE.       CMB,INB       ADB KIDP2       ADB .-8       JMP KID13     GO MOVE IT. * KID11 LDA KIDI      SET UP NEW FIRST ID.      INA       LDB .-5 KID13 STA MOVED       JSB MOVEW * * NOW WRITE DIRECTORY BACK TO DISC. * KID12 LDB LIBD      DETERMINE CORE ADDRESS.       LDA ID      CPA KIDT      LDB KIDP2       LDA KIDI      GET DISC ADDRESS.       ADA .+6       LDA 0,I       JSB DISCL     WRITE DISC. * KID10 LDA ADLEN     READ IN ADT.      STA WORD      LDA ADLOC       LDB LIBDI       JSB DISCL * * GO THROUGH THE PATCH TABLE ONE ELEMENT AT A TIME, * POINTING TO IT WITH KIDP4.* KID20 LDB LIBD      SCAN ADT FOR FIRST ENTRY BEYOND KID14 LDA 1,I       PATCH.      CMA,CLE,INA       ADA KIDP4,I       SZA,RSS       IF = FORGET THE WHOLE PATCH.THIS      JMP KID17     MIGHT HAPPEN IF ADT+PATCHTABLE*                                       IS TOO BIG.       SEZ,RSS       JMP *+3       ADB .+2       JMP KID14 * * FOUND FIRST ENTRY BEYOND PATCH. *       STB KIDP1     SAVE ADDRESS OF THAT ENTRY.       LDB KIDP4     SET A=LOC(PATCH)+LEN(PATCH)       INB                -LOC(NEXT ENTRY)=0 IF      ADA 1,I              ADJACENT.      ADA .-1       STA KIDK      LDB KIDP1     NOW DETERMINE IF PREVIOUS       ADB .-2        ENTRY IS ADJACENT TO NEW       DLD 1,I         ENTRY.      ADB 0       STB KIDJ      DLD KIDP4,I       CPA KIDJ      JMP KID15     IT IS.* * THE NEW ENTRY IS NOT ADJACENT TO THE PREVIOUS ENTRY.*       ISZ KIDK      ADJACENT TO NEXT AREA?      JMP KID16       NO. *       STA KIDP1,I   RESET FOLLOWING ENTRY SO ITS AD-      ISZ KIDP1      DRESS IS THAT OF THE NEW ONE &       ADB KIDP1,I     ITS SIZE IS THE SUM.      STB KIDP1,I       JMP KID17 * KID16 DST LTEMP     SAVE NEW ENTRY.       LDA ADLEN       ADA .-2       GET ADLEN-2       STA 1         SAVE IN B.      AND M64       COMPUTE REQUIRED WORDS ON DISC      ADA IDLEN      FOR ADT AND IDTABLE.       ADA P5440     MAKE SURE IT WILL FIT.      SSA           OK      JMP KID17     FORGET IT IF NO FIT.      CMB           SET DEST FOR MOVE TO      ADB LIBD        LIBUS-ADLEN+1       STB MOVED       ADB .-2       SET SOURCE TO LIBUS-ADLEN-1       STB MOVES       CMB           #OF WORDS =-(LIBUS-ADLEN-P1)      ADB KIDP1       JSB MOVEB       DLD LTEMP     NOW SET NEW ENTRY       DST KIDP1,I    INTO TABLE,      LDA .-2         BUMP ADLEN.       JMP KID21 * KID15 ISZ KIDK      ADJACENT TO PREVIOUS AREA---      JMP KID19     ---BUT NOT TO FOLLOWING ONE.      LDA KIDP1     WE ARE GOING TO COMBINE 3 AREAS.      STA MOVED       INA       ADB 0,I       ADD LENGTH OF FOLLOWING AREA.       ADA .-2       ADB 0,I       ADD LENGTH OF PRECEDING AREA      STB 0,I       SET AS NEW LENGTH.      ADA .+3       SET B=SOURCE OF SLIDE.      STA MOVES       LDB ADLEN     COMPUTE       ADB MLIBD     LENGTH OF MOVE.       ADB 0       JSB MOVEW       LDA .+2       DECREMENT KID21 ADA ADLEN        ADLEN.       STA ADLEN       JMP KID17 * KID19 CCA           ADJUST LENGTH OF PREVIOUS AREA      ADA KIDP1      BY ADDING LENGTH OF NEW AREA.      ADB 0,I       STB 0,I * KID17 LDA KIDP4     BUMP KIDP4 TO POINT AT NEW      ADA .+2        PATCH ENTRY.       CPA L5440     TEST FOR DONE.      JMP *+3       STA KIDP4       JMP KID20 * * WRITE ADT TO DISC *       LDB ADLEN       STB WORD      LDA ADLOC       LDB LIBD      JSB DISCL *       LDA KIDT      IF FIRST DISC ENTRY       CPA ID         WAS NOT ID, WERE DONE.       JMP KID1KID18 CLF 0       CLA       STA LIB       JMP LEND$$KID EQU *       ORG LTEMP KIDP  BSS 1 KIDC  BSS 1 KIDB  BSS 1 KIDI  BSS 1 KIDJ  BSS 1 KIDK  BSS 1 KIDP1 BSS 1 KIDP2 BSS 1 KIDP3 BSS 1 KIDP4 BSS 1 KIDT  BSS 1 