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, Length, Match, ROPE],
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: LIST OF ROPE, newMsgSet: ROPE, removeFromOld, checkOnlyTitle: BOOLEAN _ FALSE] RETURNS [msgsMoved: LIST OF ROPE _ NIL] ~ {
patternRE: ACFind.Ref ~ ACFind.Create[keys: pattern, caseSensitive: FALSE];
msgSets: LIST OF ROPE _ NIL;
count: INT _ 0;
CMSProc: PROC[] RETURNS[doReset: BOOL] = {
doReset _ TRUE;
WalnutOps.CreateMsgSet[newMsgSet, WalnutOps.MsgSetsInfo[].version];
FOR mss: LIST OF ROPE _ WalnutOps.MsgSetNames[].mL, mss.rest UNTIL mss=NIL DO
FOR each: LIST OF ROPE _ fromMsgSets, each.rest UNTIL each=NIL DO
IF Rope.Match[pattern: each.first, object: mss.first, case: FALSE] THEN {
msgSets _ CONS[mss.first, msgSets];
EXIT;
};
ENDLOOP;
ENDLOOP;
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."];
};

[] _ WalnutWindow.QueueCall[CMSProc] };
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: WSLoad <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: WSDump <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][t]] <new message set name> _ <keyword(s) or '*> IN <message set(s) to sample>.";
ResortCmd: Commander.CommandProc ~ {
arg: LIST OF ROPE _ CommandTool.ParseToList[cmd].list;
pattern: LIST OF ROPE _ NIL;
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 OR arg.rest = NIL OR NOT Rope.Equal[arg.rest.first, "_"] THEN GOTO NoPattern;
to _ arg.first;
arg _ arg.rest.rest;
IF Rope.Equal[s1: arg.first, s2: "*"] THEN {
pattern _ LIST[""];
arg _ arg.rest;
}
ELSE UNTIL arg=NIL OR Rope.Equal[s1: arg.first, s2: "IN"] DO
pattern _ CONS[arg.first, pattern];
arg _ arg.rest;
ENDLOOP;
IF arg = NIL OR arg.rest = NIL OR NOT Rope.Equal[s1: arg.first, s2: "IN"] THEN GOTO NoPattern;
[] _ ReSort[pattern, arg.rest --from--, to, deleteFromOld, checkOnlyTitle];
EXITS
NoPattern => RETURN [msg: resortMsg];
};
SetTrigger: Commander.CommandProc ~ {
tokens: LIST OF ROPE _ CommandTool.ParseToList[cmd].list;
priority: INT _ 10;
usageMessage: ROPE ~ "Usage: WSSetTrigger [-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: WSDeleteTrigger 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", SetTrigger, "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, June 23, 1986 5:56:23 pm PDT
Eric Nickell, June 25, 1986 3:57:00 pm PDT
Willie-Sue, July 12, 1985 11:16:15 am PDT
Donahue, May 12, 1986 7:53:15 am 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 LIST OF ROPE, and pattern may be "".
fromMsgSetsRE: ACFind.Ref ~ ACFind.Create[keys: fromMsgSets, caseSensitive: FALSE];
Add to msgSets any names matching the fromMsgSets pattern.
FindMsgSetName: ACFind.ActionProc = {
[position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]
pos _ position - 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] ;
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]
from _ arg;
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)

Κ˜š
œ™Icodešœ
Οm
œ=™HJš
œ6™6J™(J™*K™)K™$—J˜š
Οk	˜	Kšœžœ!˜-Jšœžœ˜Jšœ
žœ˜(Jšœžœ˜ Kšœžœ˜)Kšžœ
žœ	˜Kšœžœ˜Kšœžœ˜$Kšœžœ
˜Kšœžœ$žœ˜4Kšœžœ5˜AKšœžœ˜Kšœžœ˜*Kšœžœ˜"Kšœ
žœj˜yJš
œ
˜
Kšœ
žœ'˜9Kšœžœ
˜$Kšœžœ)˜=Jš
œ˜—J˜šœžœ
ž˜!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šœ&žœ
žœ
žœ™JKšœDžœ˜KKšœLžœ™SKš	œ	žœ
žœ
žœžœ
˜Kšœžœ˜šŸœžœžœ
žœ˜*Kšœ
žœ
˜K˜CK™:š
žœžœ
žœ
žœ(žœžœ
ž˜M–@ -- [position: INT, keyFound: ROPE] RETURNS [quit: BOOL _ FALSE]šΠbnœ™%Kš
‘<™<K–[base: 
ROPE]™'Kšžœžœ
™
K™—Kšœžœžœ
žœ
™Kšžœ7žœžœžœ™lš
žœžœ
žœ
žœžœžœ
ž˜A–6[pattern: 
ROPE, object: 
ROPE, case: 
BOOL _ TRUE]šžœ:žœžœ˜IKšœ
žœ˜#Kšžœ
˜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]šžœAžœ˜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˜—K˜Kš
œ'˜'—–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šœžœ!˜3šžœ
žœ
ž˜Kšœžœ˜!šžœ,˜3Kšžœ$žœ˜5Kšžœžœ
˜)Kš
œ˜——š
ž˜Kšœ
žœ˜%—Jš
œ˜—šŸœ˜*Jšœžœ
žœ
žœ%˜9Kšœžœ!˜3šžœ
žœ
ž˜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]šœžœc˜ršŸ	œ˜$Kšœžœ
žœ
žœ%˜6Kš	œ	žœ
žœ
žœžœ
˜Kšœžœ
˜	Kšœžœžœ
˜,K˜Kšžœžœ
žœ
žœ˜!šžœžœ˜"–[base: 
ROPE]š	žœžœ
žœžœž˜2– [base: 
ROPE, index: 
INT _ 0]šžœž˜$Kšœžœ
˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—K˜Kš
œ˜—Kšžœžœ
žœžœ
žœ
žœ!žœ
žœ˜ZK˜K˜–-[s1: 
ROPE, s2: 
ROPE, case: 
BOOL _ TRUE]šžœ$žœ˜,Kšœ
žœ˜K˜K˜
—š	žœ
žœžœ
žœ%ž˜<Kšœ
žœ˜#K˜Kšžœ
˜—Kšžœžœ
žœžœ
žœ
žœ%žœ
žœ˜^Jš
œ™KšœΟcœ%˜Kš
ž˜Kšœ
žœ˜%—K˜—šŸ
œ˜%Jšœžœ
žœ
žœ%˜9Kšœ
žœ˜Kšœžœ?˜QK˜šžœ
žœ
ž˜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šœžœ6˜HK˜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™—…—%Ά>