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]<Grapevine>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