Registry.bcd created 26-Oct-82 14:37:01 on 3#354# creator 25-Aug-81 8:46:36 on 3#35# source 26-Oct-82 14:35:57 on 0#0# Cross Jumped Global frame size: 15 -- Registration Server - Implementation of using heap and BTree as a registry. -- [Juniper]MS>Registry.mesa -- Randy Gobbel, 20-May-81 13:03:14 -- J. Dion, September 10, 1979. -- Andrew Birrell, 26-Oct-82 13:18:34 DIRECTORY BodyDefs USING [maxRNameLength, PackedTime, RName, RNameSize, Timestamp], HeapDefs, Inline USING[ LowHalf ], PupDefs USING [PupNameLookup], PupStream USING [PupAddress], Process USING [InitializeCondition, MsecToTicks], ProtocolDefs, RegistryDefs, Time USING [Current, Packed]; Registry: MONITOR IMPORTS BodyDefs, HeapDefs, Inline, PupDefs, Process, Time EXPORTS RegistryDefs = BEGIN HeapObjectEnded: ERROR = CODE; MangledHeapObject: ERROR = CODE; Entry point: 0, Frame size: 7 264: LIB 126 266: LI3 267: GADRB 14 271: BLTC 272: LINI 273: SG0 futureLimit: CARDINAL _ 14; 274: LIB 16 276: SG3 prevTime: Time.Packed _ Time.Current[]; 277: EFC13 300: SGDB 4 aWeeWhile: CONDITION; 302: LI0 303: LIB 144 305: NOOP 306: SGDB 12 PupDefs.PupNameLookup [@ThisMachine, "ME"]; 310: GADRB 7 312: GADRB 14 314: EFC14 Process.InitializeCondition[@aWeeWhile, Process.MsecToTicks[100]]; END. 315: LIB 144 317: EFCB 20 321: SL0 322: GADRB 12 324: LL0 325: EFC15 326: RET Instructions: 24, Bytes: 36 Copy: PUBLIC PROC[reader: HeapDefs.ReaderHandle, writer: HeapDefs.WriterHandle] = -- copies one component of an entry -- BEGIN bLength: CARDINAL = 64; buffer: ARRAY [0..bLength) OF WORD; Entry point: 27, Frame size: 79 330: SLDB 5 332: LIN1 333: SLB 107 335: LL1 336: LADRB 107 340: LI1 341: EFC0 342: POP 343: POP length: CARDINAL _ ReadComponentLength[reader]; 344: LLB 107 346: SL0 WriteComponentLength[writer, length]; 347: LL2 350: LL0 351: LFC1 WHILE length > 0 352: LL0 353: LI0 354: JULEB 57 (434) DO used: CARDINAL = HeapDefs.HeapReadData[reader, [@buffer,MIN[length,bLength]] ].used; 356: LL1 357: LADRB 7 361: NOOP 362: SLDB 110 364: LL0 365: LIB 100 367: NOOP 370: JULB 6 (377) 372: PUSH 373: PUSH 374: EXCH 375: POP 376: J2 (400) 377: PUSH 400: LLB 111 402: EXCH 403: SLB 112 405: POP 406: LLDB 110 410: LLB 112 412: EFC0 413: EXCH 414: POP 415: SLB 107 length _ length - used; 417: LL0 420: LLB 107 422: SUB 423: SL0 HeapDefs.HeapWriteData[writer, [@buffer,used] ]; ENDLOOP; END; 424: LL2 425: LADRB 7 427: LLB 107 431: EFC1 432: JB 317 (352) 434: RET Instructions: 51, Bytes: 70 Skip: PUBLIC PROC[reader: HeapDefs.ReaderHandle] = -- skips one component of an entry -- BEGIN Entry point: 11, Frame size: 11 436: SL0 437: LIN1 440: SL2 441: LL0 442: LADRB 6 444: LI1 445: EFC0 446: POP 447: POP length: CARDINAL = ReadComponentLength[reader]; 450: LL2 451: PL1 IF length > 0 --optimisation-- THEN 452: LI0 453: NOOP 454: JULEB 16 (473) HeapDefs.SetReaderOffset[reader, length + HeapDefs.GetReaderOffset[reader]]; END; 456: LL0 457: EFC7 460: LL1 461: LI0 462: DADD 463: NOOP 464: SLDB 7 466: LL0 467: NOOP 470: LLDB 7 472: EFC8 473: RET Instructions: 26, Bytes: 30 SkipIfEmpty: PUBLIC PROC[reader: HeapDefs.ReaderHandle] RETURNS[empty: BOOLEAN] = BEGIN Entry point: 23, Frame size: 11 474: PL0 pos: HeapDefs.ObjectOffset = HeapDefs.GetReaderOffset[reader]; 475: EFC7 476: SLDB 6 500: LIN1 501: SL5 502: LL0 503: LADRB 11 505: LI1 506: EFC0 507: POP 510: POP length: CARDINAL = ReadComponentLength[reader]; 511: LL5 512: PL1 IF length = 0 THEN 513: NOOP 514: JZNEB 3 (520) RETURN[TRUE] ELSE BEGIN 516: LI1 517: J7 (526) HeapDefs.SetReaderOffset[reader, pos]; 520: LL0 521: NOOP 522: LLDB 6 524: EFC8 RETURN[FALSE] END; END; 525: LI0 526: RET Instructions: 23, Bytes: 28 WriteList: PUBLIC PROC[writer: HeapDefs.WriterHandle, name: BodyDefs.RName, stamp: BodyDefs.Timestamp] = BEGIN -- writes single or zero entry list, with no deletions -- Entry point: 25, Frame size: 11 530: SLDB 7 532: SLDB 5 534: SL0 IF name = NIL THEN { 535: LL1 536: JZNEB 21 (560) 540: LI0 541: SL5 WriteEmptyList[writer]; 542: LL0 543: LADRB 11 545: LI1 546: EFC1 547: LI0 550: SL5 WriteEmptyList[writer] } ELSE { 551: LL0 552: LADRB 11 554: LI1 555: EFC1 556: JB 14 (573) WriteRNameList[writer,name]; 560: LLDB 4 562: LFCB 20 WriteStampList[writer,stamp]; }; 564: LL0 565: NOOP 566: LLDB 6 570: LL4 571: LFCB 24 573: LI0 574: SL5 WriteEmptyList[writer]; 575: LL0 576: LADRB 11 600: LI1 601: EFC1 602: LI0 603: SL5 WriteEmptyList[writer]; END; 604: LL0 605: LADRB 11 607: LI1 610: EFC1 611: RET Instructions: 38, Bytes: 50 StartSublist: PUBLIC PROC RETURNS[ writer: HeapDefs.WriterHandle] = BEGIN Entry point: 26, Frame size: 7 writer _ HeapDefs.HeapStartWrite[temp]; 612: LIB 7 614: EFC10 615: PL0 WriteComponentLength[writer, 0]; -- place holder -- END; 616: LI0 617: LFC1 620: LL0 621: RET Instructions: 7, Bytes: 8 AddNameToSublist: PUBLIC PROC[writer: HeapDefs.WriterHandle, name: BodyDefs.RName] = BEGIN Entry point: 37, Frame size: 7 622: SL1 623: PL0 HeapDefs.HeapWriteRName[writer, name]; END; 624: LL1 625: EFC2 626: RET Instructions: 5, Bytes: 6 EndSublist: PUBLIC PROC[writer: HeapDefs.WriterHandle, count: CARDINAL] RETURNS[reader: HeapDefs.ReaderHandle] = BEGIN Entry point: 33, Frame size: 15 630: SL1 631: PL0 offset: HeapDefs.ObjectOffset _ HeapDefs.GetWriterOffset[writer]; 632: EFC4 633: NOOP 634: SLDB 6 HeapDefs.SetWriterOffset[writer, HeapDefs.objectStart]; 636: LL0 637: LI0 640: DUP 641: EFC3 WriteComponentLength[writer, Inline.LowHalf[offset-SIZE[CARDINAL]]]; 642: LLDB 6 644: LI1 645: LI0 646: DSUB 647: POP 650: SLB 14 652: LL0 653: LLB 14 655: LFC1 HeapDefs.SetWriterOffset[writer, offset]; 656: LL0 657: NOOP 660: LLDB 6 662: EFC3 WriteComponentLength[writer, count * SIZE[BodyDefs.Timestamp]]; 663: NOOP 664: LLDB 4 666: DUP 667: DBL 670: ADD 671: LFC1 BEGIN stamp: BodyDefs.Timestamp = MakeTimestamp[]; 672: LFCB 23 674: SLDB 12 676: SL5 THROUGH [0..count) DO 677: LL1 700: SLB 15 702: LI0 703: NOOP 704: JB 14 (721) 706: PUSH 707: SLB 14 WriteTimestamp[writer, stamp] ENDLOOP; END; 711: LL0 712: LLDB 11 714: LL7 715: LFC2 716: LLB 14 720: INC 721: LLB 15 723: NOOP 724: JULB 361 (706) 726: LI0 727: SL5 WriteEmptyList[writer]; 730: LL0 731: LADRB 11 733: LI1 734: EFC1 735: LI0 736: SL5 WriteEmptyList[writer]; -- deletions -- 737: LL0 740: LADRB 11 742: LI1 743: EFC1 BEGIN 744: DESCB 116 746: SL6 HeapDefs.HeapEndWrite[writer, GetReader]; END; END; 747: LL0 750: LADRB 12 752: EFC12 753: LL4 754: RET Instructions: 66, Bytes: 86 GetReader: PROC[obj: HeapDefs.ObjectNumber] = { Entry point: 39, Frame size: 7 756: LINKB 6 760: SL2 761: PL1 762: PUSH reader _ HeapDefs.HeapStartRead[obj] }; 763: EFC11 764: WILP [0,4] 766: RET Instructions: 7, Bytes: 10 EnumerateRList: PUBLIC PROC[reader: HeapDefs.ReaderHandle, work: PROC[BodyDefs.RName]RETURNS[done:BOOLEAN]] = BEGIN Entry point: 18, Frame size: 47 770: SL2 771: SL0 772: LIN1 773: SL3 774: LL0 775: LADRB 7 777: LI1 1000: EFC0 1001: POP 1002: POP length: CARDINAL _ ReadComponentLength[reader]; 1003: LL3 1004: SL1 WHILE length > 0 1005: LL1 1006: LI0 1007: NOOP 1010: JULEB 37 (1050) DO name: BodyDefs.RName = [BodyDefs.maxRNameLength]; 1012: LADRB 11 1014: LI0 1015: LIB 100 1017: NOOP 1020: WSDB 0 1022: PUSH 1023: SL3 [] _ HeapDefs.HeapReadRName[reader, name]; 1024: LL0 1025: LL3 1026: EFC5 1027: POP length _ length - BodyDefs.RNameSize[name]; 1030: LL1 1031: RILP [3,0] 1033: INC 1034: LIN1 1035: SHIFT 1036: LI2 1037: ADD 1040: SUB 1041: SL1 IF work[name] THEN 1042: LL3 1043: LL2 1044: SFC 1045: NOOP 1046: JZEQB 336 (1005) EXIT; ENDLOOP; END; 1050: RET Instructions: 42, Bytes: 50 ReadPrefix: PUBLIC PROC[reader: HeapDefs.ReaderHandle, name: BodyDefs.RName] RETURNS[type: ProtocolDefs.RNameType, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 22, Frame size: 15 1052: SLDB 4 1054: LIN1 1055: SL7 1056: LL0 1057: LADRB 13 1061: LI1 1062: EFC0 1063: POP 1064: POP length: CARDINAL = ReadComponentLength[reader]; 1065: LL7 1066: SL6 1067: LL0 1070: LADRB 13 1072: LI3 1073: EFC0 1074: POP 1075: POP stamp _ ReadTimestamp[reader]; 1076: LLDB 13 1100: LLB 15 1102: SLDB 10 1104: SL3 [,] _ HeapDefs.HeapReadData[reader, [@type,SIZE[ProtocolDefs.RNameType]]]; 1105: LL0 1106: LADRB 6 1110: LI1 1111: EFC0 1112: POP 1113: POP [] _ HeapDefs.HeapReadRName[reader, name]; 1114: LLDB 4 1116: EFC5 1117: POP IF length # SIZE[ProtocolDefs.RNameType] + SIZE[BodyDefs.Timestamp] + BodyDefs.RNameSize[name] THEN 1120: RILP [1,0] 1122: INC 1123: LIN1 1124: SHIFT 1125: LI2 1126: ADD01 1127: LL6 1130: LI4 1131: SUB 1132: JEQ7 (1141) ERROR MangledHeapObject; END; 1133: NOOP 1134: DESCB 2 1136: LIN1 1137: KFCB 43 1141: NOOP 1142: LLDB 6 1144: LLDB 10 1146: RET Instructions: 48, Bytes: 62 WritePrefix: PUBLIC PROC[writer: HeapDefs.WriterHandle, type: ProtocolDefs.RNameType, stamp: POINTER TO BodyDefs.Timestamp, name: BodyDefs.RName] = BEGIN Entry point: 32, Frame size: 11 1150: SL1 1151: SL2 1152: SL3 1153: SL0 WriteComponentLength[writer, SIZE[ProtocolDefs.RNameType] + SIZE[BodyDefs.Timestamp] + BodyDefs.RNameSize[name] ]; 1154: RILP [1,0] 1156: INC 1157: LIN1 1160: SHIFT 1161: LI2 1162: ADD01 1163: LI4 1164: ADD01 1165: SL4 1166: LL0 1167: LL4 1170: LFC1 WriteTimestamp[writer, stamp^]; 1171: LL0 1172: LL2 1173: RD0 1174: RILP [2,2] 1176: LFC2 HeapDefs.HeapWriteData[writer, [@type,SIZE[ProtocolDefs.RNameType]]]; 1177: LL0 1200: LADRB 7 1202: LI1 1203: EFC1 HeapDefs.HeapWriteRName[writer, name]; END; 1204: LLDB 4 1206: EFC2 1207: RET Instructions: 28, Bytes: 32 ReadPassword: PUBLIC PROC[reader: HeapDefs.ReaderHandle] RETURNS [pw: ProtocolDefs.Password, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 28, Frame size: 19 1210: SL0 1211: LIN1 1212: SLB 14 1214: LL0 1215: LADRB 14 1217: LI1 1220: EFC0 1221: POP 1222: POP IF ReadComponentLength[reader] # SIZE [ProtocolDefs.Password] + SIZE[BodyDefs.Timestamp] THEN 1223: LLB 14 1225: LIB 7 1227: JEQ6 (1235) ERROR MangledHeapObject; 1230: DESCB 2 1232: LIN1 1233: KFCB 43 1235: LL0 1236: LADRB 14 1240: LI3 1241: EFC0 1242: POP 1243: POP stamp _ ReadTimestamp[reader]; 1244: LLDB 14 1246: LLB 16 1250: SLDB 12 1252: SL5 [] _ HeapDefs.HeapReadData [reader, [@pw, SIZE [ProtocolDefs.Password]]]; END; 1253: LL0 1254: LADRB 5 1256: LI4 1257: EFC0 1260: POP 1261: POP 1262: LI0 1263: ALLOC 1264: SLB 17 1266: LADRB 5 1270: LI4 1271: LLB 17 1273: BLT 1274: LADRB 11 1276: LI3 1277: LLB 17 1301: LI4 1302: ADD 1303: BLT 1304: LLB 17 1306: RET Instructions: 46, Bytes: 64 WritePassword: PUBLIC PROC[writer: HeapDefs.WriterHandle, pw: ProtocolDefs.Password, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 34, Frame size: 15 1310: DUP 1311: NOOP 1312: SLDB 14 1314: LLB 15 1316: LI5 1317: ADD01 1320: LI3 1321: LADRB 11 1323: BLT 1324: LLB 14 1326: INC 1327: LI4 1330: LADRB 5 1332: BLT 1333: RILP [10,0] 1335: SL0 1336: LLB 14 1340: FREE WriteComponentLength[writer, SIZE[ProtocolDefs.Password]+SIZE[BodyDefs.Timestamp]]; 1341: LL0 1342: LIB 7 1344: LFC1 WriteTimestamp[writer, stamp]; 1345: LL0 1346: LLDB 11 1350: LL7 1351: LFC2 HeapDefs.HeapWriteData [writer, [@pw, SIZE [ProtocolDefs.Password]]]; END; 1352: LL0 1353: LADRB 5 1355: LI4 1356: EFC1 1357: RET Instructions: 30, Bytes: 40 ReadConnect: PUBLIC PROC[reader: HeapDefs.ReaderHandle, connect: ProtocolDefs.Connect] RETURNS [stamp: BodyDefs.Timestamp] = BEGIN Entry point: 35, Frame size: 15 1360: SLDB 4 1362: LIN1 1363: SL5 1364: LL0 1365: LADRB 11 1367: LI1 1370: EFC0 1371: POP 1372: POP [] _ ReadComponentLength[reader]; 1373: LL0 1374: LADRB 11 1376: LI3 1377: EFC0 1400: POP 1401: POP stamp _ ReadTimestamp[reader]; 1402: LLDB 11 1404: LL7 1405: NOOP 1406: SLDB 7 1410: SL2 connect.length _ LAST[CARDINAL]; 1411: LIN1 1412: WILP [1,0] [,] _ HeapDefs.HeapReadData[reader, [@(connect.length),SIZE[CARDINAL]] ]; 1414: LLDB 4 1416: LI1 1417: EFC0 1420: POP 1421: POP IF connect.length > connect.maxlength THEN 1422: RILP [1,0] 1424: RILP [1,1] 1426: JULEB 6 (1435) ERROR MangledHeapObject; 1430: DESCB 2 1432: LIN1 1433: KFCB 43 [] _ HeapDefs.HeapReadData [reader, [@(connect.text), (1+connect.length)/2] ]; END; 1435: NOOP 1436: LLDB 4 1440: LI2 1441: ADD 1442: RILP [1,0] 1444: INC 1445: LIN1 1446: SHIFT 1447: EFC0 1450: POP 1451: POP 1452: LLDB 6 1454: LL4 1455: RET Instructions: 47, Bytes: 62 WriteConnect: PUBLIC PROC[writer: HeapDefs.WriterHandle, connect: ProtocolDefs.Connect, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 31, Frame size: 11 1456: SLDB 7 1460: SLDB 5 1462: PL0 WriteComponentLength[writer, SIZE[BodyDefs.Timestamp] + SIZE[CARDINAL] + (1+connect.length)/2]; 1463: RILP [1,0] 1465: INC 1466: LIN1 1467: SHIFT 1470: LI4 1471: ADD 1472: LFC1 WriteTimestamp[writer, stamp]; 1473: LL0 1474: LLDB 6 1476: LL4 1477: LFC2 HeapDefs.HeapWriteData[writer, [@(connect.length),SIZE[CARDINAL]] ]; 1500: LLDB 4 1502: LI1 1503: EFC1 HeapDefs.HeapWriteData [writer, [@(connect.text), (1+connect.length)/2] ]; END; 1504: LLDB 4 1506: LI2 1507: ADD 1510: RILP [1,0] 1512: INC 1513: LIN1 1514: SHIFT 1515: EFC1 1516: RET Instructions: 26, Bytes: 34 WriteStampList: PROC[writer: HeapDefs.WriterHandle, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 20, Frame size: 11 1520: SLDB 6 1522: SL1 1523: PL0 WriteComponentLength[writer, SIZE [BodyDefs.Timestamp]]; 1524: LI3 1525: LFC1 WriteTimestamp[writer, stamp]; END; 1526: LLDB 4 1530: LLDB 6 1532: LFC2 1533: RET Instructions: 9, Bytes: 12 WriteRNameList: PROC[writer: HeapDefs.WriterHandle, name: BodyDefs.RName] = BEGIN Entry point: 16, Frame size: 7 1534: SL0 1535: SL1 WriteComponentLength[writer, BodyDefs.RNameSize[name] ]; 1536: RIL0 1537: INC 1540: LIN1 1541: SHIFT 1542: LI2 1543: ADD01 1544: SL2 1545: NOOP 1546: LLDB 5 1550: LFC1 HeapDefs.HeapWriteRName[writer, name]; END; WriteEmptyList: PROC[writer: HeapDefs.WriterHandle] = INLINE BEGIN zero: CARDINAL _ 0; HeapDefs.HeapWriteData[writer, [@zero,SIZE[CARDINAL]] ]; END; ReadComponentLength: PROC[reader: HeapDefs.ReaderHandle] RETURNS[length: CARDINAL] = INLINE BEGIN length _ LAST[CARDINAL]; [,] _ HeapDefs.HeapReadData[reader, [@length,SIZE[CARDINAL]] ]; END; 1551: LL1 1552: LL0 1553: EFC2 1554: RET Instructions: 16, Bytes: 18 WriteComponentLength: PROC[writer: HeapDefs.WriterHandle, length: CARDINAL] = BEGIN Entry point: 1, Frame size: 7 1556: SL1 1557: PL0 HeapDefs.HeapWriteData[writer, [@length,SIZE[CARDINAL]] ]; END; ReadTimestamp: PROC[reader: HeapDefs.ReaderHandle] RETURNS [stamp: BodyDefs.Timestamp] = INLINE BEGIN [,] _ HeapDefs.HeapReadData [reader, [@stamp, SIZE [BodyDefs.Timestamp]] ]; END; 1560: LADRB 5 1562: LI1 1563: EFC1 1564: RET Instructions: 6, Bytes: 8 WriteTimestamp: PROCEDURE [writer: HeapDefs.WriterHandle, stamp: BodyDefs.Timestamp] = BEGIN Entry point: 2, Frame size: 11 1566: SLDB 6 1570: SL1 1571: PL0 HeapDefs.HeapWriteData [writer, [@stamp, SIZE [BodyDefs.Timestamp]]]; END; -- single-name updates -- -- RegistryDefs.UpdateInfo: TYPE = { done, noChange, outOfDate }; -- noChange => name already (not) there (timestamp may have been altered) -- outOfDate => better timestamp already in list 1572: LADRB 5 1574: LI3 1575: EFC1 1576: RET Instructions: 7, Bytes: 10 AddName: PUBLIC PROC[reader: HeapDefs.ReaderHandle, name: BodyDefs.RName, stamp: POINTER TO BodyDefs.Timestamp, writer: HeapDefs.WriterHandle] RETURNS[ info: RegistryDefs.UpdateInfo ] = BEGIN Entry point: 30, Frame size: 11 1606: SL4 1607: NOOP 1610: SLDB 5 1612: PL3 memInfo: RegistryDefs.UpdateInfo = SingleChangeToSublist[reader, name, stamp, writer, add]; 1613: NOOP 1614: LLDB 5 1616: LL4 1617: LI0 1620: LFC8 1621: SL6 delMemInfo: RegistryDefs.UpdateInfo = SingleChangeToSublist[reader, name, stamp, writer, remove]; 1622: LL3 1623: NOOP 1624: LLDB 5 1626: LL4 1627: LI1 1630: LFC8 1631: SL0 info _ SELECT memInfo FROM done => IF delMemInfo = outOfDate THEN outOfDate ELSE done, noChange => IF delMemInfo = noChange THEN noChange ELSE ERROR, outOfDate => IF delMemInfo = noChange THEN outOfDate ELSE ERROR, ENDCASE => ERROR; END; 1632: LL6 1633: LI3 1634: JIW* 700 ( 1642) ( 1652) ( 1662) 1640: JB 30 (1671) 1642: LL0 1643: LI2 1644: JEQB 20 (1665) 1646: LI0 1647: NOOP 1650: JB 22 (1673) 1652: LL0 1653: LI1 1654: JNE4 (1660) 1655: LI1 1656: JB 14 (1673) 1660: KFCB 46 1662: LL0 1663: LI1 1664: JNE3 (1667) 1665: LI2 1666: J5 (1673) 1667: KFCB 46 1671: KFCB 46 1673: SL5 1674: PUSH 1675: RET Instructions: 43, Bytes: 62 RemoveName: PUBLIC PROC[reader: HeapDefs.ReaderHandle, name: BodyDefs.RName, stamp: POINTER TO BodyDefs.Timestamp, writer: HeapDefs.WriterHandle] RETURNS[ info: RegistryDefs.UpdateInfo ] = BEGIN Entry point: 21, Frame size: 11 1704: SL3 1705: SL4 1706: SL2 1707: PL1 memInfo: RegistryDefs.UpdateInfo = SingleChangeToSublist[reader, name, stamp, writer, remove]; 1710: LL2 1711: LL4 1712: LL3 1713: LI1 1714: LFC8 1715: SL0 delMemInfo: RegistryDefs.UpdateInfo = SingleChangeToSublist[reader, name, stamp, writer, add]; 1716: LLDB 5 1720: LL4 1721: LL3 1722: LI0 1723: LFC8 1724: SL6 1725: PUSH info _ SELECT delMemInfo FROM done => IF memInfo = outOfDate THEN outOfDate ELSE memInfo, noChange => IF memInfo = noChange THEN noChange ELSE ERROR, outOfDate => IF memInfo = noChange THEN outOfDate ELSE ERROR, ENDCASE => ERROR; END; 1726: LI3 1727: JIW 737 ( 1734) ( 1744) ( 1754) 1732: JB 30 (1763) 1734: LL0 1735: LI2 1736: JEQB 20 (1757) 1740: LL0 1741: NOOP 1742: JB 22 (1765) 1744: LL0 1745: LI1 1746: JNE4 (1752) 1747: LI1 1750: JB 14 (1765) 1752: KFCB 46 1754: LL0 1755: LI1 1756: JNE3 (1761) 1757: LI2 1760: J5 (1765) 1761: KFCB 46 1763: KFCB 46 1765: SL5 1766: PUSH 1767: RET Instructions: 42, Bytes: 58 SingleChangeToSublist: PROC[reader: HeapDefs.ReaderHandle, name: BodyDefs.RName, stamp: POINTER TO BodyDefs.Timestamp, writer: HeapDefs.WriterHandle, change: {add,remove} ] RETURNS[ info: RegistryDefs.UpdateInfo ] = BEGIN Entry point: 8, Frame size: 67 2004: SL6 2005: SL0 2006: SL7 2007: SL3 2010: SL1 2011: NOOP 2012: DESCB 120 2014: SLB 22 beforeCount: CARDINAL _ 0; 2016: LI0 2017: SLB 15 afterCount: CARDINAL _ 0; 2021: LI0 2022: SLB 14 member: BodyDefs.RName = [BodyDefs.maxRNameLength]; 2024: LADRB 34 2026: LI0 2027: LIB 100 2031: NOOP 2032: WSDB 0 2034: PUSH 2035: SL2 2036: LIN1 2037: SLB 23 2041: LL1 2042: LADRB 23 2044: LI1 2045: EFC0 2046: POP 2047: POP originalLength: CARDINAL = ReadComponentLength[reader]; 2050: LLB 23 2052: SLB 16 2054: PUSH length: CARDINAL _ originalLength; 2055: SL5 lengthPos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer]; 2056: LL0 2057: EFC4 2060: SLDB 17 WriteComponentLength[writer, IF change = add THEN length + BodyDefs.RNameSize[name] ELSE length - BodyDefs.RNameSize[name] ]; 2062: LL6 2063: NOOP 2064: JZNEB 15 (2102) 2066: RILP [3,0] 2070: INC 2071: LIN1 2072: SHIFT 2073: LI2 2074: ADD01 2075: LL5 2076: ADD01 2077: NOOP 2100: JB 12 (2113) 2102: LL5 2103: RILP [3,0] 2105: INC 2106: LIN1 2107: SHIFT 2110: LI2 2111: ADD 2112: SUB 2113: SLB 76 2115: LL0 2116: LLB 76 2120: LFC1 info _ done; -- copy preceding names -- 2121: LI0 2122: SL4 WHILE length > 0 DO 2123: LL5 2124: LI0 2125: NOOP 2126: JULEB 100 (2227) [] _ HeapDefs.HeapReadRName[reader, member]; 2130: LLDB 5 2132: EFC5 2133: POP length _ length - BodyDefs.RNameSize[member]; 2134: LL5 2135: RILP [2,0] 2137: INC 2140: LIN1 2141: SHIFT 2142: LI2 2143: ADD 2144: SUB 2145: SL5 SELECT CompareRNames[member, name] FROM less => BEGIN 2146: LLDB 6 2150: LFCB 15 2152: LI3 2153: JIW 774 ( 2160) ( 2172) ( 2204) 2156: JB 46 (2225) HeapDefs.HeapWriteRName[writer, member]; 2160: LL0 2161: LL2 2162: EFC2 beforeCount _ beforeCount + 1; END; equal => BEGIN 2163: LLB 15 2165: INC 2166: SLB 15 2170: JB 332 (2123) IF change = add THEN { 2172: LL6 2173: NOOP 2174: JZNEB 37 (2234) info _ noChange; 2176: LI1 2177: SL4 HeapDefs.HeapWriteRName[writer, name] }; 2200: LL0 2201: LL3 2202: JB 20 (2223) EXIT END; greater => BEGIN IF change = add THEN 2204: LL6 2205: NOOP 2206: JZNEB 5 (2214) HeapDefs.HeapWriteRName[writer, name] ELSE 2210: LL0 2211: LL3 2212: EFC2 2213: J3 (2216) info _ noChange; 2214: LI1 2215: SL4 afterCount _ 1; 2216: LI1 2217: SLB 14 HeapDefs.HeapWriteRName[writer, member]; 2221: LL0 2222: LL2 2223: EFC2 EXIT END; ENDCASE => 2224: J8 (2234) ERROR; REPEAT FINISHED => 2225: KFCB 46 IF change = add THEN 2227: LL6 2230: JZEQB 347 (2200) HeapDefs.HeapWriteRName[writer, name] ELSE info _ noChange; ENDLOOP; -- copy following names -- 2232: LI1 2233: SL4 WHILE length > 0 DO 2234: LL5 2235: LI0 2236: JULEB 31 (2270) [] _ HeapDefs.HeapReadRName[reader, member]; 2240: LLDB 5 2242: EFC5 2243: POP length _ length - BodyDefs.RNameSize[member]; 2244: LL5 2245: RILP [2,0] 2247: INC 2250: LIN1 2251: SHIFT 2252: LI2 2253: ADD 2254: SUB 2255: SL5 HeapDefs.HeapWriteRName[writer, member]; 2256: LL0 2257: LL2 2260: EFC2 afterCount _ afterCount + 1; ENDLOOP; 2261: LLB 14 2263: INC 2264: SLB 14 2266: JB 345 (2234) SELECT info FROM done => NULL; noChange => 2270: LL4 2271: NOOP 2272: JZEQB 12 (2305) 2274: PUSH 2275: LI1 2276: JNE5 (2303) ResetLength[]; ENDCASE => 2277: LADRB 22 2301: SFC 2302: J3 (2305) ERROR; -- stamp list length -- 2303: KFCB 46 2305: LL4 2306: LI1 2307: NOOP 2310: JNEB 17 (2330) 2312: LIN1 2313: SLB 23 2315: LL1 2316: LADRB 23 2320: LI1 2321: EFC0 2322: POP 2323: POP 2324: LLB 23 2326: JB 43 (2372) 2330: LL6 2331: NOOP 2332: JZNEB 21 (2354) 2334: LIN1 2335: SLB 23 2337: LL1 2340: LADRB 23 2342: LI1 2343: EFC0 2344: POP 2345: POP 2346: LLB 23 2350: LI3 2351: ADD01 2352: JB 17 (2372) 2354: LIN1 2355: SLB 23 2357: LL1 2360: LADRB 23 2362: LI1 2363: EFC0 2364: POP 2365: POP WriteComponentLength[writer, IF info = noChange THEN ReadComponentLength[reader] ELSE IF change = add THEN ReadComponentLength[reader] + SIZE[BodyDefs.Timestamp] ELSE ReadComponentLength[reader] - SIZE[BodyDefs.Timestamp] ]; 2366: LLB 23 2370: LI3 2371: SUB 2372: SLB 76 2374: LL0 2375: LLB 76 2377: LFC1 THROUGH [1..beforeCount] DO 2400: LLB 15 2402: SLB 77 2404: LI1 2405: LLB 77 2407: NOOP 2410: JUGB 43 (2454) 2412: PUSH 2413: J3 (2416) 2414: PUSH 2415: INC 2416: SLB 76 2420: LL1 2421: LADRB 23 2423: LI3 2424: EFC0 2425: POP 2426: POP WriteTimestamp[writer, ReadTimestamp[reader] ]; ENDLOOP; 2427: NOOP 2430: LLDB 23 2432: LLB 25 2434: SLDB 101 2436: SLB 100 2440: LL0 2441: NOOP 2442: LLDB 100 2444: LLB 102 2446: LFC2 2447: NOOP 2450: LLDB 76 2452: JULB 341 (2414) IF change = add THEN BEGIN 2454: LL6 2455: NOOP 2456: JZNEB 121 (2600) IF info = done THEN 2460: LL4 2461: NOOP 2462: JZNEB 11 (2474) WriteTimestamp[writer, stamp^] ELSE 2464: LL0 2465: LL7 2466: RD0 2467: RILP [7,2] 2471: LFC2 2472: JB 163 (2656) BEGIN 2474: LL1 2475: LADRB 31 2477: LI3 2500: EFC0 2501: POP 2502: POP prev: BodyDefs.Timestamp = ReadTimestamp[reader]; best: BodyDefs.Timestamp; 2503: NOOP 2504: LLDB 31 2506: LLB 33 2510: SLDB 27 2512: SLB 26 SELECT CompareTimestamps[stamp^, prev ] FROM less => { 2514: LI0 2515: ALLOC 2516: SLB 76 2520: LL7 2521: LI3 2522: LLB 76 2524: BLT 2525: LADRB 26 2527: LI3 2530: LLB 76 2532: LI3 2533: ADD 2534: BLT 2535: LLB 76 2537: LFCB 14 2541: LI3 2542: JIW* 777 ( 2550) ( 2561) ( 2561) 2546: JB 20 (2567) best _ prev; 2550: LADRB 26 2552: LI3 2553: LADRB 23 2555: BLT info _ outOfDate }; equal => 2556: LI2 2557: SL4 2560: J9 (2571) best _ stamp^; greater => 2561: LL7 2562: LI3 2563: LADRB 23 2565: BLT 2566: J3 (2571) best _ stamp^; ENDCASE => ERROR; 2567: KFCB 46 WriteTimestamp[writer, best]; END; END ELSE 2571: LL0 2572: LLDB 23 2574: LLB 25 2576: JB 272 (2471) IF info = noChange THEN NULL ELSE 2600: LL4 2601: LI1 2602: JEQB 53 (2656) BEGIN 2604: LL1 2605: LADRB 26 2607: LI3 2610: EFC0 2611: POP 2612: POP prev: BodyDefs.Timestamp = ReadTimestamp[reader]; 2613: NOOP 2614: LLDB 26 2616: LLB 30 2620: SLDB 24 2622: SLB 23 IF CompareTimestamps[stamp^, prev ] = less THEN 2624: LI0 2625: ALLOC 2626: SLB 76 2630: LL7 2631: LI3 2632: LLB 76 2634: BLT 2635: LADRB 23 2637: LI3 2640: LLB 76 2642: LI3 2643: ADD 2644: BLT 2645: LLB 76 2647: LFCB 14 2651: NOOP 2652: JZNEB 3 (2656) info _ outOfDate; END; 2654: LI2 2655: SL4 THROUGH [1..afterCount] DO 2656: LLB 14 2660: SLB 77 2662: LI1 2663: LLB 77 2665: NOOP 2666: JUGB 43 (2732) 2670: PUSH 2671: J3 (2674) 2672: PUSH 2673: INC 2674: SLB 76 2676: LL1 2677: LADRB 23 2701: LI3 2702: EFC0 2703: POP 2704: POP WriteTimestamp[writer, ReadTimestamp[reader] ]; ENDLOOP; END; -- General merge algorithm -- Inlist: TYPE = RECORD [ RNameReader, TimestampReader: HeapDefs.ReaderHandle, RNameWordsLeft, TimestampWordsLeft: CARDINAL, RNameStart, TimestampStart: HeapDefs.ObjectOffset, name: BodyDefs.RName, stamp: BodyDefs.Timestamp, empty: BOOLEAN]; Outlist:TYPE = RECORD [ RNameWriter, TimestampWriter: HeapDefs.WriterHandle, RNameStart: HeapDefs.ObjectOffset, RNameWordsUsed, TimestampWordsUsed: CARDINAL]; 2705: NOOP 2706: LLDB 23 2710: LLB 25 2712: SLDB 101 2714: SLB 100 2716: LL0 2717: NOOP 2720: LLDB 100 2722: LLB 102 2724: LFC2 2725: NOOP 2726: LLDB 76 2730: JULB 341 (2672) 2732: LL4 2733: RET Instructions: 346, Bytes: 484 ResetLength: PROC = BEGIN -- length didn't change after all -- Entry point: 40, Frame size: 7 2734: LINKB 16 now: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer]; 2736: RIL0 2737: EFC4 2740: SLDB 5 HeapDefs.SetWriterOffset[writer, lengthPos]; 2742: RIL0 2743: LL0 2744: RDB 13 2746: EFC3 WriteComponentLength[writer, originalLength]; 2747: RIL0 2750: RILP [0,12] 2752: LFC1 HeapDefs.SetWriterOffset[writer, now]; END; 2753: RIL0 2754: LLDB 5 2756: EFC3 2757: RET Instructions: 15, Bytes: 20 MergeLists: PUBLIC PROC[reader1, reader2: HeapDefs.ReaderHandle, writer: HeapDefs.WriterHandle] RETURNS [newer1, newer2: BOOLEAN] = BEGIN -- allocate buffers for R-Names locally, to avoid FSP fragmentation -- Entry point: 24, Frame size: 203 2760: SL3 2761: SL4 2762: SL2 name1: BodyDefs.RName = [BodyDefs.maxRNameLength]; 2763: LADRB 103 2765: LI0 2766: LIB 100 2770: WSDB 0 2772: PUSH 2773: SLB 63 name2: BodyDefs.RName = [BodyDefs.maxRNameLength]; 2775: LADRB 145 2777: LI0 3000: LIB 100 3002: WSDB 0 3004: PUSH 3005: SL5 name3: BodyDefs.RName = [BodyDefs.maxRNameLength]; 3006: LADRB 207 3010: LI0 3011: LIB 100 3013: NOOP 3014: WSDB 0 3016: PUSH 3017: SL6 name4: BodyDefs.RName = [BodyDefs.maxRNameLength]; addlist1, addlist2, dellist1, dellist2: Inlist; n1, n2: BOOLEAN; 3020: LADRB 251 3022: LI0 3023: LIB 100 3025: NOOP 3026: WSDB 0 3030: PUSH 3031: SL7 CreateInlist [@addlist1, name1, reader1]; 3032: LADRB 46 3034: LLB 63 3036: LL2 3037: LFC5 CreateInlist [@dellist1, name2, reader1]; 3040: LADRB 31 3042: LL5 3043: LL2 3044: LFC5 CreateInlist [@addlist2, name3, reader2]; 3045: LADRB 14 3047: LL6 3050: LL4 3051: LFC5 CreateInlist [@dellist2, name4, reader2]; 3052: LADRB 64 3054: LL7 3055: LL4 3056: LFC5 [newer1, newer2] _ MergeSublists [@addlist1, @addlist2, @dellist1, @dellist2, writer]; 3057: LADRB 46 3061: LADRB 14 3063: LADRB 31 3065: LADRB 64 3067: LL3 3070: LFCB 16 3072: SLDB 4 ResetInlist [@addlist1]; 3074: LADRB 46 3076: LFCB 11 ResetInlist [@dellist1]; 3100: LADRB 31 3102: LFCB 11 ResetInlist [@addlist2]; 3104: LADRB 14 3106: LFCB 11 ResetInlist [@dellist2]; 3110: LADRB 64 3112: LFCB 11 [n1, n2] _ MergeSublists [@dellist1, @dellist2, @addlist1, @addlist2, writer]; 3114: LADRB 31 3116: LADRB 64 3120: LADRB 46 3122: LADRB 14 3124: LL3 3125: LFCB 16 3127: NOOP 3130: SLDB 101 newer1 _ newer1 OR n1; 3132: LL0 3133: NOOP 3134: JZNEB 5 (3142) 3136: LLB 101 3140: JZEQB 3 (3144) 3142: LI1 3143: J2 (3145) 3144: LI0 3145: SL0 newer2 _ newer2 OR n2; 3146: LL1 3147: NOOP 3150: JZNEB 5 (3156) 3152: LLB 102 3154: JZEQB 3 (3160) 3156: LI1 3157: J2 (3161) 3160: LI0 3161: SL1 DeleteInlist [@addlist1]; 3162: LADRB 46 3164: LFC6 DeleteInlist [@dellist1]; 3165: LADRB 31 3167: LFC6 DeleteInlist [@addlist2]; 3170: LADRB 14 3172: LFC6 DeleteInlist [@dellist2]; END; 3173: LADRB 64 3175: LFC6 3176: LLDB 4 3200: RET Instructions: 96, Bytes: 146 MergeSublists: PROCEDURE [add1, add2, del1, del2: POINTER TO Inlist, writer: HeapDefs.WriterHandle] RETURNS [newer1, newer2: BOOLEAN] = BEGIN outlist: Outlist; Entry point: 14, Frame size: 19 3202: SL6 3203: NOOP 3204: SLDB 6 3206: SLDB 4 CreateOutlist [@outlist, writer]; 3210: LADRB 13 3212: LL6 3213: LFCB 17 newer1 _ newer2 _ FALSE; 3215: LI0 3216: SL4 3217: PUSH 3220: SL5 UNTIL CompareElements [add1, add2] = Null DO 3221: NOOP 3222: LLDB 4 3224: LFC3 3225: LI3 3226: JEQB 147 (3376) WHILE CompareElements [add1, add2] = Less DO 3230: LLDB 4 3232: LFC3 3233: NOOP 3234: JZNEB 41 (3276) WHILE CompareElements [del2, add1] = Less DO 3236: LL3 3237: LL0 3240: LFC3 3241: NOOP 3242: JZNEB 5 (3250) Get [del2] ENDLOOP; 3244: LL3 3245: LFC4 3246: JB 367 (3236) IF ~(CompareElements [del2, add1] = Equal AND Newer [del2, add1]) THEN BEGIN 3250: LL3 3251: LL0 3252: LFC3 3253: LI1 3254: JNE8 (3264) 3255: LL3 3256: LL0 3257: LFCB 12 3261: NOOP 3262: JZNEB 7 (3272) Put [add1, @outlist]; 3264: LL0 3265: LADRB 13 3267: LFC7 newer1 _ TRUE END; 3270: LI1 3271: SL5 Get [add1] ENDLOOP; 3272: LL0 3273: LFC4 3274: JB 333 (3230) IF CompareElements [add1, add2] = Equal THEN BEGIN 3276: LLDB 4 3300: LFC3 3301: LI1 3302: JNEB 30 (3333) IF Newer [add1, add2] THEN BEGIN 3304: LLDB 4 3306: LFCB 12 3310: JZEQB 10 (3321) Put [add1, @outlist]; 3312: LL0 3313: LADRB 13 3315: LFC7 newer1 _ TRUE END ELSE BEGIN 3316: LI1 3317: SL5 3320: J7 (3327) Put [add2, @outlist]; 3321: LL1 3322: LADRB 13 3324: LFC7 newer2 _ TRUE END; 3325: LI1 3326: SL4 Get [add1]; 3327: LL0 3330: LFC4 Get [add2] END; 3331: LL1 3332: LFC4 WHILE CompareElements [add2, add1]= Less DO 3333: LL1 3334: LL0 3335: LFC3 3336: JZNEB 262 (3221) WHILE CompareElements [del1, add2]= Less DO 3340: LL2 3341: LL1 3342: LFC3 3343: NOOP 3344: JZNEB 5 (3352) Get [del1] ENDLOOP; 3346: LL2 3347: LFC4 3350: JB 367 (3340) IF ~(CompareElements [del1, add2]= Equal AND Newer [del1, add2]) THEN BEGIN 3352: LL2 3353: LL1 3354: LFC3 3355: LI1 3356: JNE8 (3366) 3357: LL2 3360: LL1 3361: LFCB 12 3363: NOOP 3364: JZNEB 344 (3331) Put [add2, @outlist]; 3366: LL1 3367: LADRB 13 3371: LFC7 newer2 _ TRUE END; 3372: LI1 3373: SL4 Get [add2] ENDLOOP; ENDLOOP; 3374: JB 334 (3331) DeleteOutlist [@outlist, writer] END; 3376: LADRB 13 3400: LL6 3401: LFCB 21 3403: LL5 3404: LL4 3405: RET Instructions: 102, Bytes: 132 CreateInlist: PROCEDURE [inlist: POINTER TO Inlist, name: BodyDefs.RName, reader: HeapDefs.ReaderHandle] = BEGIN Entry point: 5, Frame size: 11 3406: SL1 3407: SL2 3410: SL0 inlist.name _ name; 3411: LL2 3412: WILP [0,10] inlist.RNameReader _ HeapDefs.CopyReader[reader]; 3414: LL1 3415: EFC9 3416: WILP [0,0] inlist.RNameStart _ HeapDefs.GetReaderOffset[reader]; 3420: LL1 3421: EFC7 3422: LL0 3423: NOOP 3424: WDB 4 Skip[reader]; 3426: LL1 3427: LFCB 13 inlist.TimestampReader _ HeapDefs.CopyReader [reader]; 3431: LL1 3432: EFC9 3433: WILP [0,1] inlist.TimestampStart _ HeapDefs.GetReaderOffset[reader]; 3435: LL1 3436: EFC7 3437: LL0 3440: WDB 6 Skip[reader]; 3442: LL1 3443: LFCB 13 3445: LIN1 3446: SL3 3447: RIL0 3450: LADRB 7 3452: LI1 3453: EFC0 3454: POP 3455: POP inlist.RNameWordsLeft _ ReadComponentLength[inlist.RNameReader]; 3456: LL3 3457: WILP [0,2] 3461: LIN1 3462: SL3 3463: RILP [0,1] 3465: LADRB 7 3467: LI1 3470: EFC0 3471: POP 3472: POP inlist.TimestampWordsLeft _ ReadComponentLength[inlist.TimestampReader]; 3473: LL3 3474: WILP [0,3] Get[inlist]; END; 3476: LL0 3477: LFC4 3500: RET Instructions: 47, Bytes: 60 ResetInlist: PROCEDURE [inlist: POINTER TO Inlist] = BEGIN Entry point: 9, Frame size: 7 3502: SL0 HeapDefs.SetReaderOffset[inlist.RNameReader, inlist.RNameStart]; 3503: RIL0 3504: LL0 3505: NOOP 3506: RDB 4 3510: EFC8 HeapDefs.SetReaderOffset[inlist.TimestampReader, inlist.TimestampStart]; 3511: RILP [0,1] 3513: LL0 3514: RDB 6 3516: EFC8 3517: LIN1 3520: SL1 3521: RIL0 3522: LADRB 5 3524: LI1 3525: EFC0 3526: POP 3527: POP inlist.RNameWordsLeft _ ReadComponentLength[inlist.RNameReader]; 3530: LL1 3531: WILP [0,2] 3533: LIN1 3534: SL1 3535: RILP [0,1] 3537: LADRB 5 3541: LI1 3542: EFC0 3543: POP 3544: POP inlist.TimestampWordsLeft _ ReadComponentLength[inlist.TimestampReader]; 3545: LL1 3546: WILP [0,3] Get[inlist]; END; 3550: LL0 3551: LFC4 3552: RET Instructions: 33, Bytes: 42 DeleteInlist: PROCEDURE [inlist: POINTER TO Inlist] = BEGIN Entry point: 6, Frame size: 7 3554: SL0 HeapDefs.HeapEndRead[inlist.RNameReader]; 3555: RIL0 3556: EFC6 HeapDefs.HeapEndRead[inlist.TimestampReader]; END; 3557: RILP [0,1] 3561: EFC6 3562: RET Instructions: 6, Bytes: 8 CreateOutlist: PROCEDURE [outlist: POINTER TO Outlist, writer: HeapDefs.WriterHandle] = BEGIN Entry point: 15, Frame size: 7 3564: SLDB 4 outlist.RNameWriter _ writer; 3566: LL1 3567: WILP [0,0] outlist.RNameStart _ HeapDefs.GetWriterOffset[writer]; 3571: LL1 3572: EFC4 3573: LL0 3574: WDB 2 WriteComponentLength[outlist.RNameWriter, 0]--placeholder--; 3576: RIL0 3577: LI0 3600: LFC1 outlist.RNameWordsUsed _ 0; 3601: LI0 3602: WILP [0,4] outlist.TimestampWriter _ HeapDefs.HeapStartWrite[temp]; 3604: LIB 7 3606: EFC10 3607: WILP [0,1] outlist.TimestampWordsUsed _ 0; END; 3611: LI0 3612: WILP [0,5] 3614: RET Instructions: 18, Bytes: 26 DeleteOutlist: PROCEDURE [outlist: POINTER TO Outlist, writer: HeapDefs.WriterHandle] = BEGIN Entry point: 17, Frame size: 11 3616: SLDB 4 3620: DESCB 114 3622: SL6 TimestampStart: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[outlist.RNameWriter]; -- write component length for RName list -- 3623: RIL0 3624: EFC4 3625: NOOP 3626: SLDB 6 HeapDefs.SetWriterOffset[outlist.RNameWriter, outlist.RNameStart]; 3630: RIL0 3631: LL0 3632: RDB 2 3634: EFC3 WriteComponentLength[outlist.RNameWriter, outlist.RNameWordsUsed]; 3635: RIL0 3636: RILP [0,4] 3640: LFC1 HeapDefs.SetWriterOffset[outlist.RNameWriter, TimestampStart]; 3641: RIL0 3642: LLDB 6 3644: EFC3 IF outlist.RNameWriter # writer THEN 3645: RIL0 3646: LL1 3647: JEQ3 (3652) ERROR; -- write component length for timestamp list -- 3650: KFCB 46 WriteComponentLength[writer, outlist.TimestampWordsUsed]; -- append timestamp list -- 3652: LL1 3653: RILP [0,5] 3655: LFC1 HeapDefs.HeapEndWrite[outlist.TimestampWriter, CopyToWriter]; END; 3656: RILP [0,1] 3660: LADRB 12 3662: EFC12 3663: RET Instructions: 28, Bytes: 38 CopyToWriter: PROC [object: HeapDefs.ObjectNumber] = BEGIN Entry point: 38, Frame size: 79 3664: LINKB 6 3666: SL4 3667: PL3 3670: PUSH reader: HeapDefs.ReaderHandle = HeapDefs.HeapStartRead [object]; bLength: CARDINAL = 64; buffer: ARRAY [0..bLength) OF WORD; 3671: EFC11 3672: SL2 length: CARDINAL _ outlist.TimestampWordsUsed; 3673: RIL0 3674: RB 5 3676: SL1 WHILE length > 0 3677: LL1 3700: LI0 3701: NOOP 3702: JULEB 61 (3764) DO used: CARDINAL = HeapDefs.HeapReadData[reader, [@buffer,MIN[length,bLength]] ].used; 3704: LL2 3705: LADRB 11 3707: SLB 112 3711: POP 3712: LL1 3713: LIB 100 3715: NOOP 3716: JULB 6 (3725) 3720: PUSH 3721: PUSH 3722: EXCH 3723: POP 3724: J2 (3726) 3725: PUSH 3726: LLB 112 3730: EXCH 3731: SLB 113 3733: POP 3734: LL2 3735: NOOP 3736: LLDB 112 3740: EFC0 3741: EXCH 3742: POP 3743: SLB 111 length _ length - used; 3745: LL1 3746: LLB 111 3750: SUB 3751: SL1 HeapDefs.HeapWriteData[writer, [@buffer,used] ]; ENDLOOP; 3752: RILP [0,1] 3754: LADRB 11 3756: LLB 111 3760: EFC1 3761: NOOP 3762: JB 314 (3677) HeapDefs.HeapEndRead[reader]; END; 3764: LL2 3765: EFC6 3766: RET Instructions: 51, Bytes: 68 Get: PROCEDURE [inlist: POINTER TO Inlist] = BEGIN Entry point: 4, Frame size: 11 3770: SL0 IF inlist.RNameWordsLeft > 0 THEN BEGIN 3771: RILP [0,2] 3773: LI0 3774: JULEB 132 (4127) [] _ HeapDefs.HeapReadRName [inlist.RNameReader, inlist.name]; 3776: RIL0 3777: RILP [0,10] 4001: EFC5 4002: POP 4003: RILP [0,1] 4005: LADRB 5 4007: LI3 4010: EFC0 4011: POP 4012: POP inlist.stamp _ ReadTimestamp [inlist.TimestampReader]; 4013: NOOP 4014: LLDB 5 4016: LL3 4017: LL0 4020: SL4 4021: PUSH 4022: WDB 12 4024: WILP [4,11] IF inlist.TimestampWordsLeft < SIZE[BodyDefs.Timestamp] OR inlist.RNameWordsLeft < BodyDefs.RNameSize[inlist.name] THEN 4026: RILP [0,3] 4030: LI3 4031: NOOP 4032: JULB 15 (4050) 4034: RILP [0,10] 4036: R0 4037: INC 4040: LIN1 4041: SHIFT 4042: LI2 4043: ADD01 4044: RILP [0,2] 4046: JULEB 6 (4055) ERROR MangledHeapObject; 4050: DESCB 2 4052: LIN1 4053: KFCB 43 inlist.TimestampWordsLeft _ inlist.TimestampWordsLeft - SIZE[BodyDefs.Timestamp]; 4055: RILP [0,3] 4057: LI3 4060: SUB 4061: WILP [0,3] inlist.RNameWordsLeft _ inlist.RNameWordsLeft - BodyDefs.RNameSize[inlist.name]; 4063: RILP [0,2] 4065: RILP [0,10] 4067: R0 4070: INC 4071: LIN1 4072: SHIFT 4073: LI2 4074: ADD 4075: SUB 4076: WILP [0,2] IF (inlist.TimestampWordsLeft = 0 OR inlist.RNameWordsLeft = 0) AND inlist.TimestampWordsLeft + inlist.RNameWordsLeft # 0 THEN 4100: RILP [0,3] 4102: JZEQB 5 (4110) 4104: RILP [0,2] 4106: JZNEB 16 (4125) 4110: RILP [0,3] 4112: RILP [0,2] 4114: ADD01 4115: NOOP 4116: JZEQB 6 (4125) ERROR MangledHeapObject; 4120: DESCB 2 4122: LIN1 4123: KFCB 43 inlist.empty _ FALSE; END ELSE 4125: LI0 4126: J2 (4130) inlist.empty _ TRUE; END; 4127: LI1 4130: WILP [0,14] 4132: RET Instructions: 69, Bytes: 100 Put: PROCEDURE [inlist: POINTER TO Inlist, outlist: POINTER TO Outlist] = BEGIN Entry point: 7, Frame size: 7 4134: SL0 4135: SL1 IF inlist.empty THEN 4136: RILP [1,14] 4140: JZEQB 6 (4147) ERROR HeapObjectEnded; 4142: DESCB 0 4144: LIN1 4145: KFCB 43 HeapDefs.HeapWriteRName [outlist.RNameWriter, inlist.name]; 4147: RIL0 4150: RILP [1,10] 4152: EFC2 outlist.RNameWordsUsed _ outlist.RNameWordsUsed + BodyDefs.RNameSize [inlist.name]; 4153: RILP [1,10] 4155: R0 4156: INC 4157: LIN1 4160: SHIFT 4161: LI2 4162: ADD01 4163: RILP [0,4] 4165: ADD01 4166: WILP [0,4] WriteTimestamp [outlist.TimestampWriter, inlist.stamp]; 4170: RILP [0,1] 4172: LL1 4173: NOOP 4174: RDB 11 4176: RILP [1,13] 4200: LFC2 outlist.TimestampWordsUsed _ outlist.TimestampWordsUsed + SIZE [BodyDefs.Timestamp]; END; 4201: RILP [0,5] 4203: LI3 4204: ADD01 4205: WILP [0,5] 4207: RET Instructions: 31, Bytes: 44 CompareElements: PROCEDURE [e1, e2: POINTER TO Inlist] RETURNS [{Less, Equal, Greater, Null}] = BEGIN Entry point: 3, Frame size: 7 4216: SL0 4217: SL1 IF e1.empty THEN 4220: RILP [1,14] 4222: JZEQB 11 (4234) IF e2.empty THEN 4224: RILP [0,14] 4226: JZEQB 31 (4260) RETURN [Null] ELSE 4230: LI3 4231: NOOP 4232: JB 31 (4264) RETURN [Greater] ELSE IF e2.empty THEN 4234: RILP [0,14] 4236: JZNEB 15 (4254) RETURN [Less] ELSE SELECT CompareRNames [e1.name, e2.name] FROM less => 4240: RILP [1,10] 4242: RILP [0,10] 4244: LFCB 15 4246: LI3 4247: JIW 2104 ( 4254) ( 4256) ( 4260) 4252: JB 7 (4262) RETURN[Less]; equal => 4254: LI0 4255: J7 (4264) RETURN[Equal]; greater => 4256: LI1 4257: J5 (4264) RETURN[Greater]; ENDCASE => 4260: LI2 4261: J3 (4264) ERROR; END; 4262: KFCB 46 4264: RET Instructions: 25, Bytes: 46 Newer: PROCEDURE [e1, e2: POINTER TO Inlist] RETURNS [BOOLEAN] = BEGIN Entry point: 10, Frame size: 7 4266: SLDB 4 RETURN [CompareTimestamps [e1.stamp, e2.stamp] = greater] END; 4270: LI0 4271: ALLOC 4272: SL2 4273: LL0 4274: LIB 11 4276: ADD01 4277: LI3 4300: LL2 4301: BLT 4302: LL1 4303: LIB 11 4305: ADD01 4306: LI3 4307: LL2 4310: LI3 4311: ADD 4312: BLT 4313: LL2 4314: LFCB 14 4316: LI2 4317: JEQ3 (4322) 4320: LI0 4321: J2 (4323) 4322: LI1 4323: RET Instructions: 26, Bytes: 30 CompareRNames: PUBLIC PROC[n1, n2: BodyDefs.RName] RETURNS [RegistryDefs.Comparison] = BEGIN Entry point: 13, Frame size: 11 4324: SLDB 5 length: CARDINAL = MIN [n1.length, n2.length]; i: CARDINAL; 4326: RILP [1,0] 4330: RILP [2,0] 4332: JULB 6 (4341) 4334: PUSH 4335: PUSH 4336: EXCH 4337: POP 4340: J2 (4342) 4341: PUSH 4342: PL3 FOR i IN [0 .. length) DO 4343: SL6 4344: LI0 4345: NOOP 4346: JB 105 (4454) 4350: PUSH 4351: SL0 BEGIN ch1: CHARACTER = IF n1[i] IN CHARACTER['A .. 'Z] THEN (n1[i] - 'A) + 'a ELSE n1[i]; 4352: LL1 4353: LL0 4354: RSTR 4 4356: LIB 101 4360: JLB 17 (4400) 4362: PUSH 4363: LIB 132 4365: NOOP 4366: JGB 11 (4400) 4370: LL1 4371: LL0 4372: RSTR 4 4374: LIB 40 4376: ADD01 4377: J5 (4404) 4400: LL1 4401: LL0 4402: RSTR 4 4404: SL4 ch2: CHARACTER = IF n2[i] IN CHARACTER['A .. 'Z] THEN (n2[i] - 'A) + 'a ELSE n2[i]; 4405: LL2 4406: LL0 4407: NOOP 4410: RSTR 4 4412: LIB 101 4414: JLB 17 (4434) 4416: PUSH 4417: LIB 132 4421: NOOP 4422: JGB 11 (4434) 4424: LL2 4425: LL0 4426: RSTR 4 4430: LIB 40 4432: ADD01 4433: J5 (4440) 4434: LL2 4435: LL0 4436: RSTR 4 4440: SL5 IF ch1 < ch2 THEN 4441: NOOP 4442: LLDB 10 4444: JLB 21 (4466) RETURN [less]; IF ch1 > ch2 THEN 4446: LLDB 10 4450: JGB 26 (4477) RETURN [greater]; END ENDLOOP; 4452: LL0 4453: INC 4454: LL6 4455: NOOP 4456: JULB 271 (4350) IF n1.length < n2.length THEN 4460: RILP [1,0] 4462: RILP [2,0] 4464: JUGEB 3 (4470) RETURN [less] ELSE 4466: LI0 4467: J9 (4500) IF n1.length = n2.length THEN 4470: RILP [1,0] 4472: RILP [2,0] 4474: JNE3 (4477) RETURN [equal] ELSE 4475: LI1 4476: J2 (4500) RETURN [greater]; END; 4477: LI2 4500: RET Instructions: 78, Bytes: 110 CompareTimestamps: PUBLIC ENTRY PROC[t1, t2: BodyDefs.Timestamp] RETURNS [RegistryDefs.Comparison] = BEGIN -- Garbage check: treat timestamps more than 14 days future as 0 -- Entry point: 12, Frame size: 15 4502: DUP 4503: NOOP 4504: SLDB 14 4506: LLB 15 4510: LI3 4511: ADD01 4512: LI3 4513: LADRB 7 4515: BLT 4516: LLB 14 4520: LI3 4521: LADRB 4 4523: BLT 4524: LLB 14 4526: FREE 4527: GADRB 3 4531: ME 4532: JZEQB 374 (4527) latest: Time.Packed = LOOPHOLE[ prevTime + (LONG[futureLimit] * 24) * 60 * 60 ]; 4534: LG3 4535: LI0 4536: LIB 30 4540: LI0 4541: KFCB 64 4543: LIB 74 4545: LI0 4546: KFCB 64 4550: LIB 74 4552: LI0 4553: KFCB 64 4555: NOOP 4556: LGDB 4 4560: DADD 4561: NOOP 4562: SLDB 12 IF t1.time > latest THEN 4564: LLDB 5 4566: LLDB 12 4570: DUCOMP 4571: LI0 4572: JGB 67 (4662) RETURN [less]; IF t2.time > latest THEN 4574: LLDB 10 4576: LLDB 12 4600: DUCOMP 4601: LI0 4602: JGB 77 (4702) RETURN [greater]; IF t1.time < t2.time THEN 4604: LLDB 5 4606: LLDB 10 4610: DUCOMP 4611: LI0 4612: JLB 47 (4662) RETURN [less]; IF t1.time > t2.time THEN 4614: LLDB 5 4616: LLDB 10 4620: DUCOMP 4621: LI0 4622: JGB 57 (4702) RETURN [greater]; IF t1.net < t2.net THEN 4624: LL0 4625: LINB 370 4627: SHIFT 4630: LL3 4631: LINB 370 4633: SHIFT 4634: JLB 25 (4662) RETURN [less]; IF t1.net > t2.net THEN 4636: LL0 4637: LINB 370 4641: SHIFT 4642: LL3 4643: LINB 370 4645: SHIFT 4646: JGB 33 (4702) RETURN [greater]; IF t1.host < t2.host THEN 4650: LL0 4651: LIB 377 4653: AND 4654: LL3 4655: LIB 377 4657: AND 4660: JGEB 7 (4670) RETURN [less]; 4662: GADRB 3 4664: MXD 4665: LI0 4666: JB 24 (4713) IF t1.host > t2.host THEN 4670: LL0 4671: LIB 377 4673: AND 4674: LL3 4675: LIB 377 4677: AND 4700: JLEB 6 (4707) RETURN [greater]; 4702: GADRB 3 4704: MXD 4705: LI2 4706: J5 (4713) RETURN [equal] END; 4707: GADRB 3 4711: MXD 4712: LI1 4713: RET Instructions: 94, Bytes: 138 MakeTimestamp: PUBLIC ENTRY PROCEDURE RETURNS [stamp: BodyDefs.Timestamp] = BEGIN newTime: Time.Packed; Entry point: 19, Frame size: 11 4714: GADRB 3 4716: ME 4717: NOOP 4720: JZEQB 373 (4714) WHILE (newTime _ Time.Current[]) = prevTime DO 4722: EFC13 4723: NOOP 4724: SLDB 7 4726: PUSH 4727: PUSH 4730: LGDB 4 4732: DUCOMP 4733: NOOP 4734: JZNEB 21 (4756) WAIT aWeeWhile -- ensure uniqueness of timestamps -- ENDLOOP; 4736: GADRB 3 4740: GADRB 12 4742: DUP 4743: R1 4744: MXW 4745: GADRB 3 4747: GADRB 12 4751: MRE 4752: JZEQB 372 (4745) 4754: JB 345 (4722) stamp.net _ ThisMachine.net; 4756: LG4 4757: LINB 370 4761: SHIFT 4762: LADRB 4 4764: LI0 4765: NOOP 4766: WSTR 0 stamp.host _ ThisMachine.host; 4770: LG4 4771: LIB 377 4773: AND 4774: LADRB 4 4776: LI0 4777: NOOP 5000: WSTR 1 stamp.time _ prevTime _ newTime; END; ThisMachine: PupStream.PupAddress; -- regPurger subroutines -- 5002: LLDB 7 5004: SGDB 4 5006: PUSH 5007: PUSH 5010: SLDB 5 5012: GADRB 3 5014: MXD 5015: NOOP 5016: LLDB 4 5020: LL2 5021: RET Instructions: 48, Bytes: 70 CheckStampList: PUBLIC PROC[reader: HeapDefs.ReaderHandle, limit: BodyDefs.PackedTime] RETURNS[old: BOOLEAN] = BEGIN Entry point: 29, Frame size: 19 5022: SLDB 5 5024: SL0 5025: LIN1 5026: SL5 5027: LL0 5030: LADRB 11 5032: LI1 5033: EFC0 5034: POP 5035: POP length: CARDINAL = ReadComponentLength[reader]; 5036: LL5 5037: PL3 THROUGH [0..length/SIZE[BodyDefs.Timestamp]) DO 5040: LI3 5041: DIV 5042: SLB 15 5044: LI0 5045: NOOP 5046: JB 42 (5111) 5050: PUSH 5051: SLB 14 5053: LL0 5054: LADRB 11 5056: LI3 5057: EFC0 5060: POP 5061: POP IF ReadTimestamp[reader].time < limit THEN 5062: LLDB 11 5064: LL7 5065: NOOP 5066: SLDB 16 5070: POP 5071: NOOP 5072: LLDB 16 5074: LLDB 5 5076: DUCOMP 5077: LI0 5100: JGEB 5 (5106) RETURN[TRUE] ENDLOOP; 5102: LI1 5103: NOOP 5104: JB 12 (5117) 5106: LLB 14 5110: INC 5111: LLB 15 5113: NOOP 5114: JLB 333 (5050) RETURN[FALSE] END; 5116: LI0 5117: RET Instructions: 47, Bytes: 62 FilterStampList: PUBLIC PROC[reader: HeapDefs.ReaderHandle, limit: BodyDefs.PackedTime, writer: HeapDefs.WriterHandle] = BEGIN Entry point: 36, Frame size: 23 5120: SL0 5121: NOOP 5122: SLDB 11 5124: SL1 5125: NOOP 5126: DESCB 122 5130: SLB 16 namePos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer]; 5132: LL0 5133: EFC4 5134: SLDB 13 nameLength: CARDINAL _ 0; stampLength: CARDINAL; 5136: LI0 5137: SL4 stampReader: HeapDefs.ReaderHandle = HeapDefs.CopyReader[reader]; 5140: LL1 5141: EFC9 5142: PL2 Skip[stampReader]; 5143: LFCB 13 5145: LIN1 5146: SLB 17 5150: LL2 5151: LADRB 17 5153: LI1 5154: EFC0 5155: POP 5156: POP stampLength _ ReadComponentLength[stampReader]; 5157: LLB 17 5161: SL3 WriteComponentLength[writer, 0]; 5162: LL0 5163: LI0 5164: LFC1 EnumerateRList[reader, Action]; 5165: LL1 5166: LADRB 16 5170: LFCB 22 BEGIN newPos: HeapDefs.ObjectOffset = HeapDefs.GetWriterOffset[writer]; 5172: LL0 5173: EFC4 5174: SLDB 17 HeapDefs.SetWriterOffset[writer, namePos]; 5176: LL0 5177: NOOP 5200: LLDB 13 5202: EFC3 WriteComponentLength[writer, nameLength]; 5203: LL0 5204: LL4 5205: LFC1 HeapDefs.SetWriterOffset[writer, newPos]; END; 5206: LL0 5207: NOOP 5210: LLDB 17 5212: EFC3 HeapDefs.HeapEndRead[stampReader]; 5213: LL2 5214: EFC6 WriteComponentLength[writer, stampLength]; 5215: LL0 5216: LL3 5217: LFC1 5220: LIN1 5221: SLB 17 5223: LL1 5224: LADRB 17 5226: LI1 5227: EFC0 5230: POP 5231: POP THROUGH [0..ReadComponentLength[reader]/SIZE[BodyDefs.Timestamp]) 5232: LLB 17 5234: LI3 5235: DIV 5236: SLB 26 5240: LI0 5241: NOOP 5242: JB 45 (5310) 5244: PUSH 5245: SLB 25 DO 5247: LL1 5250: LADRB 22 5252: LI3 5253: EFC0 5254: POP 5255: POP stamp: BodyDefs.Timestamp = ReadTimestamp[reader]; 5256: LLDB 22 5260: LLB 24 5262: SLDB 20 5264: SLB 17 IF stamp.time >= limit THEN 5266: LLDB 20 5270: LLDB 11 5272: DUCOMP 5273: LI0 5274: JLB 10 (5305) WriteTimestamp[writer, stamp]; ENDLOOP; END; 5276: LL0 5277: NOOP 5300: LLDB 17 5302: LLB 21 5304: LFC2 5305: LLB 25 5307: INC 5310: LLB 26 5312: JLB 331 (5244) 5314: RET Instructions: 93, Bytes: 126 Action: PROC[name: BodyDefs.RName] RETURNS[done:BOOLEAN] = BEGIN Entry point: 41, Frame size: 15 5316: LINKB 12 5320: SL1 5321: RILP [0,2] 5323: LADRB 12 5325: LI3 5326: EFC0 5327: POP 5330: POP stamp: BodyDefs.Timestamp = ReadTimestamp[stampReader]; 5331: NOOP 5332: LLDB 12 5334: LLB 14 5336: SLDB 10 5340: SL3 done _ FALSE; 5341: LI0 5342: SL2 IF stamp.time >= limit THEN BEGIN 5343: NOOP 5344: LLDB 10 5346: LL0 5347: NOOP 5350: RDB 5 5352: DUCOMP 5353: LI0 5354: JLB 21 (5376) HeapDefs.HeapWriteRName[writer, name]; 5356: RIL0 5357: LL1 5360: EFC2 nameLength _ nameLength + BodyDefs.RNameSize[name]; END ELSE 5361: RILP [1,0] 5363: INC 5364: LIN1 5365: SHIFT 5366: LI2 5367: ADD01 5370: RILP [0,4] 5372: ADD01 5373: WILP [0,4] 5375: J7 (5404) stampLength _ stampLength - SIZE[BodyDefs.Timestamp]; END; 5376: RILP [0,3] 5400: LI3 5401: SUB 5402: WILP [0,3] 5404: LL2 5405: RET Instructions: 42, Bytes: 56 Total instructions: 1932, Bytes: 2642