DIRECTORY
ACFind USING [ActionProc, Create, Find, Ref],
Basics USING [CompareCard],
Commander USING [CommandProc, Register],
CommandTool USING [ParseToList],
Convert USING [IntFromRope, RopeFromInt],
FS USING [Error],
MBQueue USING [Create, Queue],
MessageWindow USING [Append, Blink],
Process USING [Detach],
Rope USING [Cat, Equal, Fetch, Find, Length, ROPE, Substr],
SymTab USING [Create, EachPairAction, Fetch, Insert, Pairs, Ref],
UserCredentials USING [Get],
UserProfile USING [Boolean, ListOfTokens],
ViewerTools USING [TiogaContents],
WalnutOps USING [AddMsg, CreateMsgSet, GetDisplayProps, GetMsg, MsgSetNames, MsgSetsInfo, MsgsInSetEnumeration, MoveMsg],
WalnutSortDB,
WalnutWindow USING [QueueCall, SelectMsgSetsFromMSNames],
WalnutWindowInternal USING [Report],
WalnutRegistry USING [EventProc, MsgProc, ProcSet, Register],
WalnutSortMail;

WalnutSortMailImpl: CEDAR MONITOR
IMPORTS ACFind, Basics, Commander, CommandTool, Convert, FS, MBQueue, MessageWindow, Process, Rope, SymTab, UserCredentials, UserProfile, WalnutOps, WalnutRegistry, WalnutSortDB, WalnutWindow, WalnutWindowInternal
EXPORTS WalnutSortMail
= BEGIN

ROPE: TYPE ~ Rope.ROPE;
TriggerSet: TYPE ~ WalnutSortDB.TriggerSet;
Trigger: TYPE ~ WalnutSortDB.Trigger;
Error: PUBLIC ERROR [info: ROPE] = CODE;
EachMsg: WalnutRegistry.MsgProc ~ {
IF sortEnabled AND event=firstRead THEN SortMsg[IF UserProfile.Boolean[key: "WalnutSort.SelectOnTOC"] THEN WalnutOps.GetDisplayProps[msg: msgName].TOCentry ELSE WalnutOps.GetMsg[msgName].contents.contents];
};
SortMsg: PUBLIC PROC [msg: ROPE] ~ {
EachKeyword: ACFind.ActionProc ~ {
trig: REF Trigger _ NARROW[SymTab.Fetch[ts.mapping, keyFound].val];
SELECT Basics.CompareCard[trig.priority, highestPriorityFound] FROM
less => RETURN;
greater => {
highestPriorityFound _ trig.priority;
msNamesToActivate _ SymTab.Create[];
};
ENDCASE => NULL;
FOR each: LIST OF ROPE _ trig.msNames, each.rest UNTIL each=NIL DO
[] _ SymTab.Insert[msNamesToActivate, each.first, NIL];
ENDLOOP;
};

EachMSName: SymTab.EachPairAction = {
msNamesToActivateList _ CONS[key, msNamesToActivateList];
RETURN[FALSE];
};

highestPriorityFound: CARDINAL _ 0;
msNamesToActivate: SymTab.Ref;
msNamesToActivateList: LIST OF ROPE _ NIL;
finder: ACFind.Ref _ NIL;
ts: TriggerSet _ GetTriggerSet[];
finder _ NARROW[ts.clientData];
IF ACFind.Find[finder, msg, EachKeyword] THEN
[] _ SymTab.Pairs[msNamesToActivate, EachMSName]
ELSE
msNamesToActivateList _ UserProfile.ListOfTokens["WalnutSort.DefaultSelections"];
IF msNamesToActivateList # NIL THEN [] _ WalnutWindow.SelectMsgSetsFromMSNames[msNamesToActivateList];
};
ReSort: PUBLIC PROC [pattern, fromMsgSets, newMsgSet: ROPE, removeFromOld, checkOnlyTitle: BOOLEAN _ FALSE] RETURNS [msgsMoved: LIST OF ROPE _ NIL] ~ {
CreateFromRope: PROC [pattern: ROPE, ignoreCase: BOOL] RETURNS [ref: ACFind.Ref] ~ {
CheckSpecialCases: PROC [in: ROPE] RETURNS [out: ROPE] ~ {
RETURN [IF Rope.Equal[in, "*"] THEN "" ELSE in];
};
loc: INT;
list: LIST OF ROPE _ NIL;
WHILE (loc _ Rope.Find[s1: pattern, s2: "|"]) # -1 DO
list _ CONS[CheckSpecialCases[Rope.Substr[base: pattern, len: loc]], list];
pattern _ Rope.Substr[base: pattern, start: loc+1];
ENDLOOP;
list _ CONS[CheckSpecialCases[pattern], list];
ref _ ACFind.Create[keys: list, caseSensitive: ~ignoreCase];
};
patternRE: ACFind.Ref ~ CreateFromRope[pattern: pattern, ignoreCase: TRUE];
fromMsgSetsRE: ACFind.Ref ~ CreateFromRope[pattern: fromMsgSets, ignoreCase: TRUE];
msgSets: LIST OF ROPE;
count: INT _ 0;
CMSProc: PROC RETURNS[doReset: BOOL] = {
WalnutOps.CreateMsgSet[newMsgSet, WalnutOps.MsgSetsInfo[].version];
RETURN[TRUE];
};

FOR mss: LIST OF ROPE _ WalnutOps.MsgSetNames[].mL, mss.rest UNTIL mss=NIL DO
FindMsgSetName: ACFind.ActionProc = {
pos _ position+1 - Rope.Length[keyFound];
RETURN [TRUE]
};
pos: INT _ INT.LAST;
IF ACFind.Find[fromMsgSetsRE, mss.first, FindMsgSetName] AND pos=0 THEN msgSets _ CONS[mss.first, msgSets] ;
ENDLOOP;
[] _ WalnutWindow.QueueCall[CMSProc];

WalnutWindowInternal.Report["Messages moved:"];
FOR mss: LIST OF ROPE _ msgSets, mss.rest UNTIL mss=NIL DO
ms: ROPE ~ mss.first;
FOR msgs: LIST OF ROPE _ WalnutOps.MsgsInSetEnumeration[ms].mL, msgs.rest UNTIL msgs=NIL DO
FindKeyInText: ACFind.ActionProc = {
RETURN [TRUE]
};
herald, text: ROPE;
herald _ text _ WalnutOps.GetDisplayProps[msgs.first].TOCentry;
IF ~checkOnlyTitle THEN {
text _ WalnutOps.GetMsg[msgs.first].contents.contents;
};
IF ACFind.Find[self: patternRE, text: text, action: FindKeyInText] THEN {
count _ count+1;
msgsMoved _ CONS[msgs.first, msgsMoved];
WalnutWindowInternal.Report["    ", herald];
IF removeFromOld THEN [] _ WalnutOps.MoveMsg[msgs.first, [ms], [newMsgSet]]
ELSE [] _ WalnutOps.AddMsg[msgs.first, [ms], [newMsgSet]];
};
ENDLOOP;
ENDLOOP;
WalnutWindowInternal.Report[Convert.RopeFromInt[from: count], " messages moved."];
};
WatchWalnut: WalnutRegistry.EventProc = {
SELECT event FROM
stopped => WalnutSortDisable[];
started => IF Rope.Equal[user, UserCredentials.Get[].name, FALSE] THEN WalnutSortEnable[];
ENDCASE => NULL;
};

user: ROPE _ NIL;
sortEnabled: BOOLEAN _ FALSE;
queue: MBQueue.Queue ~ MBQueue.Create[];
procSet: WalnutRegistry.ProcSet ~ [
eventProc: WatchWalnut,
msgProc: EachMsg
];
WalnutSortEnable: PUBLIC ENTRY PROC ~ {
ENABLE UNWIND => NULL;
IF NOT sortEnabled THEN {
currentUser: ROPE _ UserCredentials.Get[].name;
IF NOT Rope.Equal[currentUser, user, FALSE] THEN {
user _ currentUser;
WalnutSortDB.DeclareSegment[user];
};
sortEnabled _ TRUE;
TRUSTED {Process.Detach[FORK MakeWalnutSortGetTriggerSet[]];}
};
};
WalnutSortDisable: PUBLIC ENTRY PROC ~ {
ENABLE UNWIND => NULL;
WalnutSortDB.Close[];
sortEnabled _ FALSE;
};
LoadDefinitions: Commander.CommandProc ~ {
tokens: LIST OF ROPE ~ CommandTool.ParseToList[cmd].list;
usageMessage: ROPE ~ "Usage: LoadSortDefs <filename>.\n";
SELECT TRUE FROM
tokens=NIL => msg _ usageMessage;
ENDCASE => WalnutSortDB.LoadFromFile[tokens.first !
FS.Error => {msg _ error.explanation; GOTO Complain};
ANY => {msg _ "Failed.\n"; GOTO Complain}
];
EXITS
Complain => {RETURN [$Failure, msg]};
};
DumpDefinitions: Commander.CommandProc ~ {
tokens: LIST OF ROPE ~ CommandTool.ParseToList[cmd].list;
usageMessage: ROPE ~ "Usage: DumpSortDefs <filename>.\n";
SELECT TRUE FROM
tokens=NIL => msg _ usageMessage;
ENDCASE => WalnutSortDB.DumpToFile[tokens.first !
FS.Error => {msg _ error.explanation; GOTO Complain};
ANY => {msg _ "Failed.\n"; GOTO Complain}
];
EXITS
Complain => {RETURN [$Failure, msg]};
};
MakeFinder: PROC [mapping: SymTab.Ref] RETURNS [finder: ACFind.Ref] ~ {
BuildKeyList: SymTab.EachPairAction = {
keyList _ CONS[key, keyList];
RETURN[FALSE];
};

keyList: LIST OF ROPE _ NIL;
[] _ SymTab.Pairs[x: mapping, action: BuildKeyList];
finder _ ACFind.Create[keyList];
};
GetTriggerSet: PROC RETURNS [ts: TriggerSet] ~ {
ts _ WalnutSortDB.GetTriggerSetFromDB[];
IF ts.clientData = NIL THEN ts.clientData _ MakeFinder[ts.mapping];
};
MakeWalnutSortGetTriggerSet: PROC ~ {
[] _ GetTriggerSet[ ! Error => {
MessageWindow.Append[info, TRUE];
MessageWindow.Blink[];
CONTINUE
}];
};
WalnutSort: Commander.CommandProc ~ {
tokens: LIST OF ROPE ~ CommandTool.ParseToList[cmd].list;
usageMessage: ROPE ~ "Usage: WalnutSort on|off.\n";
SELECT TRUE FROM
tokens=NIL OR 
Rope.Equal[tokens.first, "on", FALSE] => {
WalnutSortEnable[];
msg _ "Sort enabled.\n";
};
Rope.Equal[tokens.first, "off", FALSE] => {WalnutSortDisable[]; msg _ "Sort disabled.\n"};
ENDCASE => msg _ usageMessage;
};
resortMsg: ROPE ~ "WSResort [-m] <regular expression to match> [<message set(s) to sample> [<new message set name>]].";
ResortCmd: Commander.CommandProc ~ {
arg: LIST OF ROPE _ CommandTool.ParseToList[cmd].list;
pattern, from, to: ROPE;
deleteFromOld, checkOnlyTitle: BOOL _ FALSE;

IF arg = NIL THEN GOTO NoPattern;
IF Rope.Fetch[arg.first]='- THEN {
FOR k: NAT IN [0.. NAT[Rope.Length[arg.first]]) DO
SELECT Rope.Fetch[arg.first, k] FROM
'm => deleteFromOld _ TRUE;
't => checkOnlyTitle _ TRUE;
ENDCASE;
ENDLOOP;
arg _ arg.rest;
};
IF arg = NIL THEN GOTO NoPattern;
pattern _ arg.first;
from _ IF arg.rest#NIL THEN arg.rest.first ELSE "#*";
to _ IF arg.rest#NIL AND arg.rest.rest#NIL THEN arg.rest.rest.first ELSE "Temp";
[] _ ReSort[pattern, from, to, deleteFromOld, checkOnlyTitle];
EXITS
NoPattern => RETURN [msg: resortMsg];
};
TriggerCmd: Commander.CommandProc ~ {
tokens: LIST OF ROPE _ CommandTool.ParseToList[cmd].list;
priority: INT _ 10;
usageMessage: ROPE ~ "Usage: Trigger [-priority] keyword messageSetName.\n";

SELECT TRUE FROM
tokens=NIL => RETURN [msg: usageMessage];
Rope.Fetch[tokens.first]='- => {
priority _ -Convert.IntFromRope[tokens.first];
tokens _ tokens.rest;
};
ENDCASE;
IF tokens=NIL OR tokens.rest=NIL THEN RETURN [msg: usageMessage];
WalnutSortDB.DeleteTrigger[tokens.rest.first, tokens.first];
WalnutSortDB.AddTrigger[tokens.rest.first, tokens.first, priority];
};
DeleteTrigger: Commander.CommandProc ~ {
tokens: LIST OF ROPE ~ CommandTool.ParseToList[cmd].list;
usageMessage: ROPE ~ "Usage: DeleteTrigger keyword messageSetName.\n";

IF tokens=NIL OR tokens.rest=NIL THEN RETURN [msg: usageMessage];
WalnutSortDB.DeleteTrigger[tokens.rest.first, tokens.first];
};
ListTriggers: Commander.CommandProc ~ {
WalnutSortDB.DumpToStream[cmd.out];
};
Init: PROC ~ {
OPEN Commander;
Register["WalnutSort", WalnutSort, "WalnutSort on|off	--Enable/disable auto message set button selection"];
Register["WSDump", DumpDefinitions, "Dump the Walnut Sort Definitions (WSDump filename)."];
Register["WSLoad", LoadDefinitions, "Load the Walnut Sort Definitions (WSLoad filename)."];
Register["WSSetTrigger", TriggerCmd, "Create a keyword trigger (WSSetTrigger [-priority] keyword messageSetName)."];
Register["WSDeleteTrigger", DeleteTrigger, "Remove a keyword trigger (WSDeleteTrigger keyword messageSetName)."];
Register["WSListTriggers", ListTriggers, "List current triggers."];
Register["WSResort", ResortCmd, Rope.Cat["Resort Walnut messages into another message set. (", resortMsg, ")."]];
[] _ WalnutRegistry.Register[procSet: procSet, queue: queue];
};

Init[];

END.
πWalnutSortMailImpl.mesa
Copyright c 1984, 1985, 1986 by Xerox Corporation.  All rights reserved.
Created December 18, 1984 4:36:42 pm PST by Dave Rumph
Dave Rumph, January 13, 1986 3:11:46 pm PST
Eric Nickell, April 3, 1986 12:25:38 pm PST
Willie-Sue, July 12, 1985 11:16:15 am PDT
Rick Beach, May 9, 1986 2:56:43 pm PDT
PROC[msgName: Rope.ROPE, event: MsgEvent, clientData: REF ANY];
[key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL]
Don't catch WalnutSortMail.Error here because retries are attempted below its generation and Walnut has successfully established communication with the server.  Something else must be wrong.  Let the debugger help figure it out.
Here, no trigger was found - look for a default action in User Profile
Note that pattern and fromMsgSets are Regular Expressions.
Add to msgSets any names matching the fromMsgSets pattern.
[position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]

Scan the messages in each message set.
[position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]
[event: WalnutRegistry.Event, clientData: REF ANY]
Activates the WalnutSort facility.
Disables the WalnutSort facility.
[key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL]
Dave Rumph, October 15, 1985 12:55:53 pm PDT
Smoother interaction with DB when user changes.
changes to: WalnutSortEnable (calls WalnutSortDB.DeclareSegment when user changes)
Eric Nickell November 21, 1985 9:00:11 am PST
changes to: WalnutSort (changed so that WalnutSort command defaults to turning WalnutSort on)

Κ2˜š
œ™Icodešœ
Οm
œ=™HJš
œ6™6J™+J™+K™)K™&—J˜š
Οk	˜	Kšœžœ!˜-Jšœžœ˜Jšœ
žœ˜(Jšœžœ˜ Kšœžœ˜)Kšžœ
žœ	˜Kšœžœ˜Kšœžœ˜$Kšœžœ
˜Kšœžœ#žœ
˜;Kšœžœ5˜AKšœžœ˜Kšœžœ˜*Kšœžœ˜"Kšœ
žœj˜yJš
œ
˜
Kšœ
žœ'˜9Kšœžœ
˜$Kšœžœ)˜=Jš
œ˜—J˜šΠlnœžœ
ž˜!Kšžœ2žœš
˜Υ
Jšžœ˜Jšœž˜J˜Jšžœžœžœ
˜Jšœžœ˜+Jšœ	žœ˜%Icode2š	œžœ
žœžœžœ
˜(šΟnœ˜#Jšžœžœžœ
žœ™?K•StartOfExpansion
[msg: 
ROPE]šžœ
žœžœ	žœ3žœ2žœ.˜Ξ
J˜—š œžœ
žœžœ˜$šΟbœ˜"Kšœžœžœ)˜Cšžœ9ž˜CKšœžœ
˜š
œ˜Kš
œ%˜%Kš
œ$˜$Kš
œ˜—Kšžœžœ
˜—š
žœžœ
žœ
žœžœžœ
ž˜BKšœ2žœ˜7Kšžœ
˜—Kš
œ˜K˜—–; -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL]š‘
œ˜%Kš
Πck7™7Kšœžœ˜9Kšžœ
žœ˜K˜K˜—Kšœžœ˜#K˜Kš	œžœ
žœ
žœžœ
˜*Kšœžœ
˜š
œ!˜!K™δ
—Kšœ	žœ˜šžœ'ž˜-K˜0—š
ž˜K™FKš
œQ˜Q—Kšžœžœ
žœC˜fK˜—š œžœ
žœ#žœ!žœžœžœ
žœ
žœ
žœžœ˜—
Kš
œ:™:š
 œžœžœžœžœ˜Tš
 œžœžœžœžœ˜:Kšžœžœžœžœ˜0K˜—Kšœžœ
˜	Kš	œžœ
žœ
žœžœ
˜–>[s1: 
ROPE, pos1: 
INT _ 0, s2: 
ROPE, case: 
BOOL _ TRUE]šžœ.ž˜5K–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]šœžœ@˜KK–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]˜3Kšžœ
˜—Kšœžœ#˜.K˜<K˜—KšœEžœ˜KKšœMžœ˜SKšœ	žœ
žœ
žœ
˜Kšœžœ˜š œžœ
žœ
žœ˜(K˜CKšžœ
žœ˜
K˜—K˜K™:š
žœžœ
žœ
žœ(žœžœ
ž˜M–@ -- [position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]š‘œ˜%Kš
’<™<K–[base: 
ROPE]˜)Kšžœžœ
˜
K˜—Kšœžœžœ
žœ
˜Kšžœ7žœžœžœ˜lKšžœ
˜—K™Kš
œ%˜%K˜K™&K˜/š
žœžœ
žœ
žœžœžœ
ž˜:Kšœžœ
˜š
žœžœ
žœ
žœ4žœžœ
ž˜[–@ -- [position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]š‘
œ˜$Kš
’<™<Kšžœžœ
˜
K˜—Kšœžœ
˜Kš
œ?˜?šžœžœ˜Kš
œ6˜6Kš
œ˜—–?[self: 
ACFind.Ref, text: 
ROPE, action: 
ACFind.ActionProc]šžœ@žœ˜IK˜Kšœžœ˜(K–<[msg1: 
ROPE _ NIL, msg2: 
ROPE _ NIL, msg3: 
ROPE _ NIL]˜,Kšžœžœ6˜KKšžœ6˜:Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K–B[from: 
INT, base: 
Convert.Base _ 10, showRadix: 
BOOL _ TRUE]˜RK˜—–6 -- [event: WalnutRegistry.Event, clientData: REF ANY]š‘œ˜)Jš
’2™2šžœž˜Kš
œ˜K–-[s1: 
ROPE, s2: 
ROPE, case: 
BOOL _ TRUE]šœžœ.žœžœ˜ZKšžœžœ
˜—J˜J˜—Jšœžœžœ
˜Jšœ
žœžœ
˜J˜(š
œ#˜#K˜K˜Kš
œ˜—š œžœ
žœ
žœ˜'Jšžœ
žœžœ
˜J™"šžœ
žœ
žœ˜Kšœ
žœ˜/šžœ
žœžœžœ˜2Kš
œ˜Kš
œ"˜"Kš
œ˜—Kšœžœ
˜Kšžœžœ!˜=Kš
œ˜—J˜—š œžœ
žœ
žœ˜(Jšžœ
žœžœ
˜J™!J˜Jšœžœ
˜J˜—š œ˜*Jšœžœ
žœ
žœ%˜9Kšœžœ'˜9šžœ
žœ
ž˜Kšœžœ˜!šžœ,˜3Kšžœ$žœ˜5Kšžœžœ
˜)Kš
œ˜——š
ž˜Kšœ
žœ˜%—Jš
œ˜—š œ˜*Jšœžœ
žœ
žœ%˜9Kšœžœ'˜9šžœ
žœ
ž˜Kšœžœ˜!šžœ*˜1Kšžœ$žœ˜5Kšžœžœ
˜)Kš
œ˜——š
ž˜Kšœ
žœ˜%—Jš
œ˜—š 
œžœžœ˜G–; -- [key: SymTab.Key, val: SymTab.Val] RETURNS [quit: BOOL]š‘œ˜'Lš
’7™7Lšœ
žœ˜Lšžœ
žœ˜L˜L˜—Kš	œ	žœ
žœ
žœžœ
˜K–2[x: 
SymTab.Ref, action: 
SymTab.EachPairAction]š
œ4˜4Kš
œ ˜ K˜—š 
œžœ
žœ˜0Kš
œ(˜(Kšžœžœ
žœ(˜CK˜—š œžœ˜%š
œ ˜ Kšœžœ˜!Kš
œ˜Kš
ž˜Kš
œ˜—K˜—š 
œ˜%Jšœžœ
žœ
žœ%˜9Kšœžœ!˜3šžœ
žœ
ž˜Kšœžœ˜šœžœ˜*Kš
œ˜Kš
œ˜Kš
œ˜—Kšœ žœ5˜ZKšžœ˜—J˜—L–’
[name: 
ROPE, proc: 
Menus.ClickProc, clientData: 
REF ANY _ NIL, documentation: 
REF ANY _ NIL, fork: 
BOOL _ TRUE, guarded: 
BOOL _ FALSE]šœžœh˜wš 	œ˜$Kšœžœ
žœ
žœ%˜6Kšœžœ
˜Kšœžœžœ
˜,K˜Kšžœžœ
žœ
žœ˜!šžœžœ˜"–[base: 
ROPE]š	žœžœ
žœžœž˜2– [base: 
ROPE, index: 
INT _ 0]šžœž˜$Kšœžœ
˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—K˜Kš
œ˜—Kšžœžœ
žœ
žœ˜!K˜Kš	œžœ
žœ
žœžœ˜5Kš
œžœ
žœ
žœžœ
žœžœ˜PKš
œ>˜>š
ž˜Kšœ
žœ˜%—K˜—š 
œ˜%Jš	œžœ
žœ
žœžœ
˜9Kšœ
žœ˜Kšœžœ:˜LK˜šžœ
žœ
ž˜Kšœžœžœ˜)š
œ ˜ K˜.K˜Kš
œ˜—Kšžœ
˜—Kš
žœžœ
žœ
žœ
žœ˜AKš
œ<˜<K˜CKš
œ˜—–’
[name: 
ROPE, proc: 
Menus.ClickProc, clientData: 
REF ANY _ NIL, documentation: 
REF ANY _ NIL, fork: 
BOOL _ TRUE, guarded: 
BOOL _ FALSE]š 
œ˜(Jšœžœ
žœ
žœ%˜9Kšœžœ4˜FK˜Kš
žœžœ
žœ
žœ
žœ˜AK˜<Kš
œ˜—š œ˜'K˜#Kš
œ˜—š œžœ˜Kšžœ˜K˜kK˜[K˜[Kš
œt˜tKš
œq˜qKš
œC˜CK˜qK–;[procSet: 
WalnutRegistry.ProcSet, queue: 
MBQueue.Queue]˜=J˜J˜—J˜J˜Jšžœ
˜—™,K™/KšœΟrœ6™R—™-Kšœ£
œG™]—K™—…—'2>T