DIRECTORY
BasicTime USING [GMT, nullGMT, Unpacked, Now, Unpack],
DefaultRegistry USING [UsersRegistry],
GVBasics USING [ItemType, RName],
GVMailParse,
GVNames,
GVSend USING [Abort, AddRecipient, AddToItem, CheckValidity, Create, Handle,
Send, SendFailed, StartItem, StartSend, StartSendInfo],
Icons,
List USING [Append],
Menus,
IO,
Rope,
RuntimeError USING [BoundsFault],
WalnutDocumentRope USING[ Create ],
TiogaOps,
ViewerOps,
ViewerTools,
UserCredentials USING [Get],
WalnutSendOps,
WalnutSendInternal,
WalnutParse USING [MessageFieldIndex, MessageInfo];

WalnutSendMailImpl: CEDAR MONITOR
IMPORTS
BasicTime, DefaultRegistry,
GVMailParse, GVNames, GVSend, List, IO, Rope, RuntimeError,
WalnutDocumentRope, TiogaOps,
ViewerOps, ViewerTools,
UserCredentials,
WalnutSendInternal,
WalnutSendOps
EXPORTS
WalnutSendInternal, WalnutSendOps, WalnutParse =

BEGIN OPEN WalnutSendInternal;


defaultRegistry: PUBLIC ROPE_ DefaultRegistry.UsersRegistry[];

messageParseArray: PUBLIC ARRAY WalnutParse.MessageFieldIndex OF WalnutParse.MessageInfo _
[	["Reply-to", simpleRope],		-- this is really wrong, a special case for now
["Sender", simpleRope],
["From", simpleRope],
["To", rNameList],
["cc", rNameList],
["c", rNameList],
["bcc", rNameList],
["Date", simpleRope],
["Subject", simpleRope],
["Categories", rCatList],
["In-reply-to", simpleRope],
["VoiceFileID", simpleRope]
];

Send: PUBLIC PROC[v: Viewer, doClose: BOOL_ FALSE] RETURNS[sent: BOOL] =
{ oldMenu: Menus.Menu = v.menu;
v.inhibitDestroy_ TRUE;
BEGIN ENABLE UNWIND => GOTO out;
ViewerOps.SetMenu[v, sendingMenu];
IF needToAuthenticate THEN
{ SenderReport["Authenticating user ..."];
IF ~AuthenticateUser[] THEN
{ViewerOps.BlinkIcon[v, IF v.iconic THEN 0 ELSE 1];
ViewerOps.SetMenu[v, oldMenu];
v.inhibitDestroy_ FALSE;
RETURN[FALSE]
};
SenderReport[" ...ok\n"];
};
sent_ InternalSendMsg[v, doClose];
EXITS
out => NULL;
END;
ViewerOps.SetMenu[v, oldMenu];
v.inhibitDestroy_ FALSE;
};

AppendHeaderLine: PUBLIC PROC[v: Viewer, line: ROPE, changeSelection: BOOL _ FALSE] =
BEGIN ENABLE RuntimeError.BoundsFault => GOTO exit;
text: ROPE;
i: INT_ 0;
ch: CHAR;

TRUSTED {text_ WalnutDocumentRope.Create[LOOPHOLE [TiogaOps.ViewerDoc[v]]]};
DO		-- find the double CR at the end of the headers
UNTIL (ch_ text.Fetch[i]) = '\n DO i_ i + 1; ENDLOOP;
IF (ch_ text.Fetch[i_ i + 1]) = '\n THEN EXIT;
ENDLOOP;
InsertIntoViewer[v, line, i, WalnutSendOps.labelFont, changeSelection];
ViewerTools.EnableUserEdits[v];
EXITS
exit => SenderReport[IO.PutFR["Malformed headers; append of &g not done", IO.rope[line]]];
END;

AuthenticateUser: PROC RETURNS [BOOL] =
BEGIN OPEN WalnutSendOps;
auth: GVNames.AuthenticateInfo;
IF userRName.Length[] = 0 THEN {SenderReport["Please Login\n"]; RETURN[FALSE]};

SELECT
auth_
GVNames.Authenticate[userRName, UserCredentials.Get[].password] FROM
group => SenderReport["... Can't login as group\n"];
individual => {needToAuthenticate_ FALSE; RETURN[TRUE]};
notFound => {SenderReport[userRName]; SenderReport[" is invalid - please Login\n"]};
allDown => SenderReport["... No server responded\n"];
badPwd => SenderReport["... Your Password is invalid - please Login\n"];
ENDCASE;

RETURN[FALSE];
END;

InternalSendMsg: PROC[senderV: Viewer, doClose: BOOL] RETURNS[sendOk: BOOL] =
BEGIN
status: SendParseStatus;
sPos, mPos: INT;
formatting: ROPE;
smr: SendingRec;
addedTxtLength: INT;
newTxt: ROPE;
contents, currentText: ViewerTools.TiogaContents;
senderInfo: SenderInfo_ NARROW[ViewerOps.FetchProp[senderV, $SenderInfo]];

sendOk_ FALSE;
senderInfo.aborted_ FALSE;

IF senderInfo.successfullySent AND ~senderV.newVersion THEN
{ SenderReport["\nDo you really want to send this message again?"];
IF ~Confirmation[senderInfo] THEN
{ SenderReport[" .. Not sent\n"];
senderInfo.successfullySent_ FALSE;
RETURN}
};

senderInfo.successfullySent_ FALSE;

SenderReport["... Parsing..."];

smr_ NEW[SendMsgRecObject];
TRUSTED
{smr.fullText_
WalnutDocumentRope.Create[LOOPHOLE [TiogaOps.ViewerDoc[senderV]]]};
IF smr.fullText.Length[] > LAST[CARDINAL] THEN
{ SenderReport["\nMessage is too long to send; NOT sent\n"]; RETURN};
[status, sPos, mPos]_ ParseTextToBeSent[smr];

IF (status # ok) AND (status # includesPublicDL) THEN
BEGIN
SELECT status FROM
fieldNotAllowed => 
IF sPos # mPos THEN
{ ShowErrorFeedback[senderV, sPos, mPos];
SenderReport[Rope.Substr[smr.fullText, MAX[0, sPos-1], mPos-sPos]];
SenderReport[" field is not allowed\n"]}
ELSE SenderReport[IO.PutFR["  field at pos %g is not allowed\n", IO.int[sPos]]];
syntaxError => 
IF sPos # mPos THEN
{ ShowErrorFeedback[senderV, sPos, mPos];
SenderReport["\nSyntax error on line beginning with "];
SenderReport[Rope.Substr[smr.fullText, MAX[0, sPos-1], mPos-sPos]]}
ELSE SenderReport[IO.PutFR[".....  Syntax error at position %g ", IO.int[sPos]]];
includesPrivateDL => SenderReport[" Private dl's are not yet implemented\n"];
ENDCASE => ERROR;
ViewerOps.BlinkIcon[senderV, IF senderV.iconic THEN 0 ELSE 1];
RETURN;
END;

IF CheckForAbortSend[senderInfo] THEN RETURN;

IF (status = includesPublicDL OR smr.numRecipients > maxWithNoReplyTo) AND
~smr.replyTo THEN
{ howToReply: HowToReplyTo_ self;
IF ~replyToSelf THEN
{ oldM: Menus.Menu_ senderV.menu;
IF CheckForAbortSend[senderInfo] THEN RETURN;
ViewerOps.SetMenu[senderV, replyToMenu];
SenderReport[
IO.PutFR["... %g public DLs and %g other recipients; please choose Reply-To option",
IO.int[smr.numDLs], IO.int[smr.numRecipients]]];
SenderReport[
"\nClick Self to reply-to self, All to reply-to all, Cancel to cancel Send\n"];
howToReply_ ReplyToResponse[senderInfo];
ViewerOps.SetMenu[senderV, oldM];
};
IF howToReply # all THEN
InsertIntoViewer[senderV, Rope.Concat["Reply-to: ", WalnutSendOps.userRName],
smr.endHeadersPos, WalnutSendOps.labelFont];
IF howToReply = cancel THEN
{SenderReport["\nDelivery cancelled. Reply-to: has been added\n"]; 
RETURN
}; 

IF CheckForAbortSend[senderInfo] THEN RETURN;    	 
};

IF doClose AND ~senderV.iconic THEN ViewerOps.CloseViewer[senderV];

currentText_ ViewerTools.GetTiogaContents[senderV];
newTxt _
Rope.Cat[IF smr.from = NIL THEN "From: " ELSE "Sender: ", WalnutSendOps.userRName];
addedTxtLength _ newTxt.Length[];
InsertIntoViewer[senderV, newTxt, 0, WalnutSendOps.labelFont];
newTxt _ Rope.Concat["Date: ", RFC822Date[]];
addedTxtLength _ newTxt.Length[] + addedTxtLength + 1;
InsertIntoViewer[senderV, newTxt, 0, WalnutSendOps.labelFont];

contents_  ViewerTools.GetTiogaContents[senderV];
{ last: INT_ contents.contents.Length[] - 1;
IF contents.contents.Fetch[last] = '\000 THEN		-- NULL for padding
{ smr.fullText_ Rope.Substr[contents.contents, 1, last-1];
formatting_ Rope.Concat["\000", contents.formatting] }
ELSE 
{ smr.fullText_ Rope.Substr[contents.contents, 1];
formatting _ contents.formatting } };

IF smr.subject.Length[] > 40 THEN
smr.subject_ Rope.Concat[Rope.Substr[smr.subject, 0, 35], " ..."];
smr.subject_ Rope.Cat[" \"", smr.subject, "\" "];

SenderReport["... Sending "]; SenderReport[smr.subject];
IF senderInfo.successfullySent_ sendOk_ SendIt[smr, senderInfo, formatting]
THEN
{ SenderReport[smr.subject]; SenderReport[" has been delivered\n"];
senderInfo.prevMsg_ currentText;
}
ELSE
{ DeleteChars[senderV, addedTxtLength];
SenderReport[smr.subject]; SenderReport[" NOT sent\n"];
};
END;

RFC822Date: PUBLIC PROC[gmt: BasicTime.GMT_ BasicTime.nullGMT] RETURNS[date: ROPE] =
BEGIN OPEN IO;
upt: BasicTime.Unpacked_
BasicTime.Unpack[IF gmt = BasicTime.nullGMT THEN BasicTime.Now[] ELSE gmt];
zone: ROPE;
month, tyme, year: ROPE;
timeFormat: ROPE = "%02g:%02g:%02g %g";	--  "hh:mm:ss zzz"
dateFormat: ROPE = "%2g %g %g %g";		--  "dd mmm yy timeFormat"

arpaNeg: BOOL_ upt.zone > 0;
aZone: INT_ ABS[upt.zone];
zDif: INT_ aZone / 60;
zMul: INT_ zDif * 60;
IF (zMul = aZone) AND arpaNeg THEN
{ IF upt.dst = yes THEN
SELECT zDif FROM
0 => zone_ "UT";
4 => zone_ "EDT";
5 => zone_ "CDT";
6 => zone_ "MDT";
8 => zone_ "PDT";
ENDCASE
ELSE
SELECT zDif FROM
0 => zone_ "UT";
5 => zone_ "EST";
6 => zone_ "CST";
7 => zone_ "MST";
8 => zone_ "PST";
ENDCASE;
};

IF zone = NIL THEN
{ mm: INT_ aZone - zMul;
zone_ PutFR[IF arpaNeg THEN "-%02g%02g" ELSE "+%02g%02g", int[zDif], int[mm]];
};

SELECT upt.month FROM
January => month_ "Jan";
February => month_ "Feb";
March => month_ "Mar";
April => month_ "Apr";
May => month_ "May";
June => month_ "Jun";
July => month_ "Jul";
August => month_ "Aug";
September => month_ "Sep";
October => month_ "Oct";
November => month_ "Nov";
December => month_ "Dec";
unspecified => ERROR;
ENDCASE => ERROR;

year_ Rope.Substr[PutFR[NIL, int[upt.year]], 2];
tyme_ PutFR[timeFormat, int[upt.hour], int[upt.minute], int[upt.second], rope[zone]];
date_ PutFR[dateFormat, int[upt.day], rope[month], rope[year], rope[tyme]];

END;

ShowErrorFeedback: PUBLIC PROC[v: Viewer, start, end: INT] =
BEGIN OPEN TiogaOps;
ENABLE UNWIND => GOTO exit;
startLoc, endLoc: Location;
thisV: Ref = ViewerDoc[v];
beginning: Location_ [FirstChild[thisV], 0];
startLoc_ LocRelative[beginning, start];
endLoc_ LocRelative[beginning, end];
SetSelection[viewer: v, start: startLoc, end: endLoc, which: feedback];
EXITS
exit => NULL;
END;

InsertIntoViewer: PUBLIC PROC
[v: Viewer, what: ROPE, where: INT, labelFont: ROPE _ NIL, changeSelection: BOOL _ FALSE] =
BEGIN OPEN TiogaOps;
thisV: Ref = ViewerDoc[v];
prefix: ROPE;
InsertChars: PROC[root: Ref] =
BEGIN
insertLoc: Location;
prevV: Viewer;
prevStart, prevEnd: Location;
prevLevel: SelectionGrain;
cb, pd: BOOL;
IF where < 0 THEN  insertLoc_ LastLocWithin[LastChild[thisV]]
ELSE insertLoc_ LocRelative[[FirstChild[thisV], 0], where];

[prevV, prevStart, prevEnd, prevLevel, cb, pd]_ GetSelection[primary];
ViewerTools.EnableUserEdits[v];
SelectPoint[v, insertLoc, primary];
IF labelFont # NIL THEN TiogaOps.SetLooks[labelFont, caret];
TiogaOps.InsertRope[prefix];
IF labelFont # NIL THEN TiogaOps.ClearLooks[caret];
TiogaOps.InsertRope[what];
TiogaOps.Break[];		-- make a new node
ViewerTools.InhibitUserEdits[v];
IF ~changeSelection AND (prevV # v) AND (prevV#NIL) AND ~prevV.destroyed THEN
SetSelection[prevV, prevStart, prevEnd, prevLevel, cb, pd !
TiogaOps.SelectionError => CONTINUE];  
END;
LockViewerOpen[v];
prefix _ Rope.Substr[ what, 0, Rope.Find[s1: what, s2: ":"] ];
what _ Rope.Replace[base: what, start: 0, len: prefix.Length, with: NIL];
IF thisV = NIL THEN InsertChars[thisV] ELSE CallWithLocks[InsertChars, thisV];
ReleaseOpenViewer[v];
END;

DeleteChars: PUBLIC ENTRY PROC[v: Viewer, num: INT] = 
BEGIN ENABLE UNWIND => NULL;
IF num # 0 THEN DeleteLeadingChars[v, num]
END;

DeleteLeadingChars: INTERNAL PROC[v: Viewer, num: INT] =
BEGIN OPEN TiogaOps;
thisV: Ref_ ViewerDoc[v];
DelChars: PROC[root: Ref] =
BEGIN
prevV: Viewer;
prevStart, prevEnd: Location;
prevLevel: SelectionGrain;
cb, pd: BOOL;
startLoc: Location_ [FirstChild[thisV], 0];
endLoc: Location_ LocRelative[startLoc, num];
[prevV, prevStart, prevEnd, prevLevel, cb, pd]_ GetSelection[primary];
ViewerTools.EnableUserEdits[v];
SetSelection[viewer: v, start: startLoc, end: endLoc];
Delete[];
GoToNextNode[];
Join[];
IF (prevV # v) AND (prevV#NIL) THEN
SetSelection[prevV, prevStart, prevEnd, prevLevel, cb, pd];
END;
IF thisV = NIL THEN DelChars[thisV] ELSE CallWithLocks[DelChars, thisV];
END;

SendIt: PROC[smr: SendingRec, senderInfo: SenderInfo, formatting: ROPE] RETURNS[ sent: BOOLEAN] =
{ InitSending: ENTRY PROC =
{ ENABLE UNWIND => NULL;
senderInfo.sendHandle_ GVSend.Create[];
senderInfo.validateFlag_ TRUE;
senderInfo.aborted_ FALSE;
};
FinishedSending: ENTRY PROC =
{ ENABLE UNWIND => NULL;
senderInfo.sendHandle_ NIL
};
InitSending[];
sent _ SendMessage[smr, senderInfo, formatting ! GVSend.SendFailed =>
{  IF notDelivered THEN
{ SenderReport["\nCommunication failure during send.  Retry?\n"];
IF Confirmation[senderInfo] THEN RETRY 
ELSE { sent _ FALSE; CONTINUE }
} 
ELSE {
SenderReport["\nCommunication failure, but message delivered\n"];
sent _ TRUE;
CONTINUE;
};
}];
FinishedSending[];
} ;			

SendMessage: PROC[smr: SendingRec, senderInfo: SenderInfo, formatting: ROPE]
RETURNS[ sent: BOOLEAN ] = {
DO ENABLE GVSend.SendFailed => CONTINUE;		-- try again if SendFailed
h: GVSend.Handle _ senderInfo.sendHandle;
startInfo: GVSend.StartSendInfo;
stepper: LIST OF RName;
tempInteger: INT;
numRecips: INT _ 0;
numValidRecips: INT;
firstInvalidUser: BOOL_ TRUE;
numInvalidUsers: INTEGER_ 0;

InvalidUserProc: PROC [ userNum: INT, userName: RName ] = {
IF firstInvalidUser THEN {SenderReport["\nInvalid user(s): "]; firstInvalidUser_ FALSE};
SELECT numInvalidUsers _ numInvalidUsers + 1 FROM
1 => SenderReport[userName];
IN [2..5] => {SenderReport[", "]; SenderReport[userName]};
6 => SenderReport[", ...\n"];
ENDCASE;
} ;

sent _ FALSE ;
startInfo _ GVSend.StartSend[ handle: senderInfo.sendHandle,
senderPwd: UserCredentials.Get[].password,
sender:    WalnutSendOps.userRName,
returnTo:  WalnutSendOps.userRName,
validate:  senderInfo.validateFlag
] ;
SELECT startInfo FROM
badPwd => {SenderReport["\nInvalid password\n"]; RETURN};
badSender => {SenderReport["\nInvalid sender name\n"]; RETURN};			     				   
badReturnTo => {SenderReport["\nBad return-to field\n"]; RETURN};
allDown =>	{SenderReport["\nAll servers are down\n"]; RETURN};
ok => {
stepper _ smr.to;
WHILE stepper # NIL DO 
GVSend.AddRecipient[ h, stepper.first ];
numRecips _ numRecips + 1;
stepper _ stepper.rest;
ENDLOOP;
IF CheckForAbortSend[senderInfo] THEN RETURN;
stepper _ smr.cc;
WHILE stepper # NIL DO 
GVSend.AddRecipient[ h, stepper.first ] ;
numRecips _ numRecips + 1 ;
stepper _ stepper.rest ;
ENDLOOP ;
IF CheckForAbortSend[senderInfo] THEN RETURN;
IF senderInfo.validateFlag THEN
{ IF (numValidRecips_ GVSend.CheckValidity[ h, InvalidUserProc]) = 0 THEN
{ SenderReport["\nThere were NO valid recipients; do you wish to send anyway?\n"];
IF CheckForAbortSend[senderInfo] OR ~Confirmation[senderInfo] THEN
{GVSend.Abort[h]; RETURN};
};

IF numValidRecips # numRecips THEN
{ tempInteger _ numRecips-numValidRecips;
SenderReport[IO.PutFR["\nThere were %g invalid recipients,", IO.int[tempInteger] ]];
SenderReport[" do you wish to send anyway?\n"];
IF CheckForAbortSend[senderInfo] OR ~Confirmation[senderInfo] THEN
{GVSend.Abort[h]; RETURN};
};
};

IF CheckForAbortSend[senderInfo] THEN RETURN;
SenderReport[IO.PutFR["..sending to %g recipients\n", IO.int[numValidRecips]]];
senderInfo.validateFlag_ FALSE;		-- if sending fails, don't need to re-validate
GVSend.StartItem[h, Text];
GVSend.AddToItem[h, smr.fullText];
IF formatting#NIL THEN { -- send the formatting info as a second item
GVSend.StartItem[h, WalnutSendOps.TiogaCTRL]; GVSend.AddToItem[h, formatting] };
IF smr.voiceID.Length[] # 0 THEN
{ GVSend.StartItem[h, Audio]; GVSend.AddToItem[h, smr.voiceID] };

ViewerOps.SetMenu[senderInfo.senderV, blankMenu];
IF CheckForAbortSend[senderInfo] THEN RETURN;
GVSend.Send[ h ] ;
sent_ TRUE;
RETURN;
} ;
ENDCASE ;
ENDLOOP;
} ;

CanonicalName: PUBLIC PROC [simpleName, registry: ROPE] RETURNS[name: ROPE] =
BEGIN
name_ simpleName;
IF registry.Length[] = 0 THEN name_ name.Cat[".", defaultRegistry]
ELSE name_ name.Cat[".", registry];
END;

ParseTextToBeSent:
PROC[msg: SendingRec] RETURNS[status: SendParseStatus, sPos, mPos: INT] =
BEGIN OPEN GVMailParse;
mLF: WalnutParse.MessageInfo;
tHeaders: LIST OF ROPE_ NIL;
msgText: ROPE_ msg.fullText;
lastCharPos: INT_ msgText.Length[] - 1;
lastCharIsCR: BOOL_ (msgText.Fetch[lastCharPos] = '\n);
countOfRecipients, dlCount: INT_ 0;

GetNextMsgChar: PROC[] RETURNS [ch: CHAR] =
{ IF mPos <= lastCharPos THEN ch_ Rope.Fetch[msgText, mPos]
ELSE IF (mPos=lastCharPos+1) AND ~lastCharIsCR THEN ch_ '\n
ELSE ch_ endOfInput;
mPos_ mPos + 1;
};

RNameListField: PROC[index: WalnutParse.MessageFieldIndex] =
BEGIN
fieldBody, fbEnd: LIST OF RName_ NIL;
AnotherRName: PROC[r1, r2: ROPE, isFile, isNested: BOOL] RETURNS [ROPE, BOOLEAN] =
BEGIN
name: ROPE;
name_ CanonicalName[r1, r2];
IF fbEnd=NIL THEN fbEnd_ fieldBody_ CONS[name, NIL]
ELSE fbEnd_ fbEnd.rest_ CONS[name, NIL];
IF isFile THEN status_ includesPrivateDL
ELSE IF name.Find["^"] < 0 THEN countOfRecipients_ countOfRecipients + 1
ELSE
{ IF status # includesPrivateDL THEN status_ includesPublicDL;
dlCount_ dlCount + 1
};
RETURN[NIL, FALSE]; 
END;

ParseNameList[pH, GetNextMsgChar, AnotherRName, NIL];
SELECT index FROM
toF => IF msg.to = NIL THEN msg.to_ fieldBody
ELSE IF fieldBody#NIL THEN
TRUSTED
{msg.to_ LOOPHOLE[List.Append[LOOPHOLE[msg.to], LOOPHOLE[fieldBody]]]};
ccF, cF, bccF => IF msg.cc = NIL THEN msg.cc_ fieldBody
ELSE IF fieldBody#NIL THEN
TRUSTED
{msg.cc_ LOOPHOLE[List.Append[LOOPHOLE[msg.cc], LOOPHOLE[fieldBody]]]};
fromF => msg.from_ fieldBody.first;		-- needs to be non-NIL
ENDCASE => ERROR;
END;

pH: ParseHandle;
field: ROPE_ NIL;
fieldNotRecognized: BOOL;
mPos_ 0;		-- where we are in the fulltext
status_ ok;		-- start with good status

pH_ InitializeParse[];

DO
sPos_ mPos;
[field, fieldNotRecognized]_ GetFieldName[pH, GetNextMsgChar ! ParseError =>
{ FinalizeParse[pH]; GOTO errorExit}];
IF ~fieldNotRecognized THEN EXIT;
IF Rope.Equal[field, "Sender", FALSE] OR Rope.Equal[field, "Date", FALSE] THEN
RETURN[fieldNotAllowed, sPos, mPos];

FOR i: WalnutParse.MessageFieldIndex IN WalnutParse.MessageFieldIndex DO
{ mLF_ messageParseArray[i];
IF Rope.Equal[messageParseArray[i].name, field, FALSE] THEN	-- ignore case
{ fieldNotRecognized_ FALSE;
SELECT mLF.fType FROM
simpleRope =>
SELECT i FROM
fromF => RNameListField[i ! ParseError => GOTO errorExit];
replyToF => {msg.replyTo_ TRUE; []_ GetFieldBody[pH, GetNextMsgChar, TRUE]};
subjectF => msg.subject_ GetFieldBody[pH, GetNextMsgChar];
voiceF => msg.voiceID_ GetFieldBody[pH, GetNextMsgChar];
ENDCASE => []_ GetFieldBody[pH, GetNextMsgChar, TRUE];

rCatList => []_ GetFieldBody[pH, GetNextMsgChar, TRUE];
rNameList => RNameListField[i ! ParseError => GOTO errorExit];
ENDCASE => ERROR;
EXIT
};
};
ENDLOOP;
IF fieldNotRecognized THEN
[]_ GetFieldBody[pH, GetNextMsgChar];	-- skip anything not recognized
ENDLOOP;

FinalizeParse[pH];
msg.endHeadersPos_ mPos - 1;


msg.numRecipients_ countOfRecipients; 
msg.numDLs_ dlCount;
EXITS
errorExit => RETURN[syntaxError, sPos, mPos];
END;

END.

4File: WalnutSendMailImpl.mesa 
Contents: Implementation of the WalnutMsg Send operation
Last Edited by: Willie-Sue, September 19, 1984 1:00:20 pm PDT
Last Edited by: Donahue, October 6, 1983 1:05 pm
Global types & variables
************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
first add the From:/Sender: line 
now put the date at the very front
note that there is guaranteed to be formatting since we added some to make things look nice
generates arpa standard time, dd mmm yy hh:mm:ss zzz
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
now we are positioned at the beginning of the body of the message
if any recipient is at another arpa site, all recipients should be arpa qualified
however, like Laurel, we'll only do the From/Sender field in full arpa regalia
�Êà˜J˜Jš
œ™Jš
œ8™8J˜Jš
œ=™=Jš
œ0™0J˜š
Ïk	˜	Jšœ
�œ�œ"˜6Jšœ�œ˜&Jšœ	�œ˜!J˜J˜šœ�œ@˜LJ˜7—J˜Jšœ�œ
˜J˜Jš�œ
˜J˜Jšœ
�œ˜!Jšœ�œ˜#J˜	J˜
J˜Jšœ�œ˜J˜J˜Jšœ�œ"˜3J˜—šœ�œ
�˜!š
�˜J˜Jšœ$�œ˜;J˜J˜J˜J˜J˜
—š
�˜J˜0J˜——Jš�œ
�œ˜J˜Jš
œ™J˜Jšœ�œ
�œ"˜>J˜šœ�œ
�œ�œ˜ZšœÏc/˜LJ˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜——Jš
œH™HšÏnœ�œ
�œ�œ�œ�œ�œ˜Hš
œ˜Jšœ�œ
˜Jš�œ
�œ
�œ�œ˜ ˜"š�œ�˜˜*š�œ�˜šœ�œ
�œ�œ˜3J˜Jšœ�œ
˜Jš�œ
�œ
˜
J˜——J˜J˜—J˜"——š
�˜Jšœ�œ
˜—Jš�œ
˜J˜Jšœ�œ
˜J˜J˜——Jš
œU™UšŸœ�œ
�œ�œ�œ�œ˜Uš�œ
�œ�œ˜3Jšœ�œ
˜Jšœ�œ˜
Jšœ�œ
˜	J˜Jš�œ"�œ˜Lš�œž/˜3Jš�œ�œ�œ
˜5Jš�œ"�œ
�œ
˜.—š�œ
˜J˜GJ˜—š
�˜Jšœ�œ3�œ˜Z——Jš�œ
˜J˜—Jš
œU™UšŸœ�œ
�œ�œ˜'š�œ
�œ˜J˜Jš�œ�œ"�œ
�œ˜OJ˜š
�˜˜Jšœ@�˜DJ˜4Jšœ#�œ�œ
�œ˜8J˜TJ˜5J˜H——Jš�œ
˜J˜Jš�œ
�œ˜—Jš�œ
˜J˜—š
Ÿœ�œ�œ�œ	�œ˜MJš
�˜J˜Jšœ�œ
˜Jšœ�œ
˜J˜Jšœ�œ
˜Jšœ�œ
˜
J˜1Jšœ�œ,˜JJ˜Jšœ�œ
˜Jšœ�œ
˜—˜š�œ�œ�˜;˜CJš�œ�˜!˜!Jšœ�œ
˜#Jš�œ
˜—J˜J˜——Jšœ�œ
˜#J˜J˜J˜Jšœ�œ˜š
�˜˜Jšœ�œ!˜C—š�œ�œ
�œ�˜.Jšœ=�œ˜E—J˜-—˜š�œ�œ�˜5š
�˜š�œ�˜˜š�œ
�˜˜)Jšœ'�œ˜CJ˜(—Jš�œ�œ-�œ
˜P——˜š�œ
�˜˜)J˜7Jšœ'�œ˜C—Jš�œ�œ.�œ
˜Q——J˜MJš�œ�œ
˜Jšœ�œ�œ�œ˜>—Jš�œ
˜—Jš�œ
˜J˜Jš�œ�œ
�œ
˜-J˜—š�œ�œ'�˜JJšœ
�˜˜!š�œ�˜˜!Jš�œ�œ
�œ
˜-˜(˜
š�œR˜TJš�œ�œ˜0——˜
J˜O—J˜(J˜!—J˜——š�œ�˜˜MJ˜,—Jš�œ�˜˜CJš
�˜J˜J˜——Jš�œ�œ
�œ˜3—J˜J˜Jš�œ	�œ�œ ˜CJ˜——Jš
œ!™!J˜3˜Jš	œ	�œ�œ
�œ
�œ&˜S˜!J˜>Jš
œ"™"J˜-J˜6J˜>J˜J˜1Jš
œ[™[šœ�œ!˜,š�œ'�œž˜B˜:J˜6——š�œ
˜˜2J˜%J˜———š�œ�˜!J˜B—J˜1J˜——J˜8š�œI˜Kš
�˜˜CJ˜ —J˜
—š
�˜˜'J˜7J˜———Jš�œ
˜J˜—JšŸ
œ�œ
�œ�œ�œ�œ˜Tš
œ4™4š�œ
�œ
�œ
˜˜Jšœ�œ�œ�œ˜K—Jšœ�œ
˜Jšœ�œ
˜Jšœ�œž˜:Jšœ�œž˜>J˜Jšœ	�œ˜Jšœ�œ�œ˜Jšœ�œ
˜Jšœ�œ˜š�œ�œ	�˜"šœ�œ�˜š�œ�˜J˜J˜J˜J˜J˜———š
�˜š
�˜š�œ�˜J˜J˜J˜J˜J˜Jš�œ
˜—J˜J˜Jš�œ�œ
�˜šœ�œ˜Jšœ�œ	�œ
�œ"˜NJ˜J˜—š�œ�˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜J˜Jšœ�œ
˜Jš�œ�œ
˜J˜—Jšœ�œ˜0J˜UJ˜KJ˜———Jš�œ
˜J˜—šŸœ�œ
�œ�œ˜<Jš�œ
�œ
˜š�œ
�œ�œ˜J˜J˜J˜,J˜(J˜$J˜Gš
�˜Jšœ�œ
˜
——Jš�œ
˜J˜—šŸœ�œ
�˜Jš
œ�œ	�œ
�œ�œ�œ�œ˜[š�œ
�œ
˜J˜Jšœ�œ
˜
šŸœ�œ
˜š
�˜J˜J˜J˜J˜Jšœ�œ
˜
š�œ�œ,˜=Jš�œ7˜;J˜—J˜FJ˜J˜#Jš�œ
�œ
�œ%˜<J˜Jš�œ
�œ
�œ˜3J˜Jšœž˜%J˜ š�œ�œ
�œ�œ�œ�˜M˜;Jšœ�œ˜'———Jš�œ
˜—J˜J˜>šœD�œ˜IJš�œ	�œ
�œ�œ#˜NJ˜——Jš�œ
˜J˜—š
Ÿœ�œ
�œ
�œ�œ˜6š�œ
�œ
�œ�œ
˜Jš�œ	�œ˜*—Jš�œ
˜J˜—šŸœ�œ
�œ�œ˜8š�œ
�œ
˜J˜šŸœ�œ
˜š
�˜J˜J˜J˜Jšœ�œ
˜
J˜+J˜-J˜FJ˜J˜6J˜	J˜J˜š�œ
�œ�œ�˜#J˜;——Jš�œ
˜Jš�œ	�œ
�œ�œ ˜H——Jš�œ
˜J˜—Jš
œO™Oš
Ÿœ�œ6�œ�œ�œ˜ašœŸœ�œ
�œ˜šœ�œ
�œ�œ
˜J˜'Jšœ�œ
˜Jšœ�œ
˜J˜—šŸœ�œ
�œ˜šœ�œ
�œ�œ
˜Jšœ�˜J˜——J˜˜Ešœ�œ�˜˜AJš�œ�œ
�œ
˜'Jš�œ
�œ�œ˜—J˜š�œ˜J˜AJšœ�œ
˜Jš�œ
˜	J˜——J˜J˜—J˜J˜——šŸœ�œ6�œ
˜LJš�œ�œ˜Jš�œ
�œ�œž˜DJ˜)J˜ Jšœ	�œ
�œ˜Jšœ
�œ
˜Jšœ�œ˜Jšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ˜J˜šŸœ�œ�œ˜;Jš�œ�œ9�œ˜Xš�œ'�˜1J˜Jš�œ8˜:J˜—Jš�œ
˜J˜J˜—Jšœ�œ˜˜<˜*J˜#J˜#J˜"J˜——š�œ�˜Jšœ1�œ˜9Jšœ7�œ˜NJšœ9�œ˜AJšœ6�œ˜>˜J˜š�œ�œ
�œ
˜J˜(J˜J˜—Jš�œ
˜Jš�œ�œ
�œ
˜-J˜š�œ�œ
�œ
˜J˜)J˜J˜—Jš�œ˜	š�œ�œ
�œ
˜-Jš�œ�˜šœ�œA�˜I˜Rš�œ�œ�˜BJšœ�œ˜——J˜J˜——š�œ�˜"˜)Jšœ
�œ.�œ˜TJ˜/š�œ�œ�˜BJšœ�œ˜—J˜J˜˜Jš�œ�œ
�œ
˜-Jšœ
�œ'�œ˜OJšœ�œž.˜OJ˜J˜"Jš�œ�œ
�œž,˜EJ˜P—š�œ�˜ J˜AJ˜—J˜1———Jš�œ�œ
�œ
˜-J˜Jšœ�œ
˜Jš�œ
˜J˜—Jš�œ˜	—Jš�œ
˜J˜J˜Jš
œO™OšŸ
œ�œ
�œ�œ�œ�œ˜Mš
�˜J˜š�œ�œ%˜BJš�œ˜#——Jš�œ
˜J˜—˜š�œ�œ&�œ˜Iš�œ
�œ
˜J˜Jš	œ
�œ
�œ
�œ�œ
˜Jšœ	�œ˜Jšœ
�œ˜'Jšœ�œ%˜7Jšœ�œ˜#J˜JšŸœ�œ�œ�œ˜+šœ�œ�œ˜;š�œ
�œ�œ�œ˜;Jš�œ˜—J˜—J˜J˜šŸœ�œ(˜<Jš
�˜Jšœ�œ
�œ�œ
˜%šŸœ�œ	�œ�œ�œ�œ�œ˜Rš
�˜Jšœ�œ
˜J˜š
�œ�œ
�œ�œ�œ
˜3Jš�œ�œ�œ˜(—š�œ�œ˜(š�œ
�œ�œ)˜Hš
�˜šœ�œ�œ˜>J˜—J˜———Jš�œ
�œ�œ˜Jš�œ
˜J˜——šœ0�œ˜5š�œ�˜šœ�œ
�œ
�œ˜-š�œ
�œ�œ
�˜š
�˜Jšœ	�œ
�œ
�œ˜G———šœ�œ
�œ
�œ˜7š�œ
�œ�œ
�˜š
�˜Jšœ	�œ
�œ
�œ˜G———Jšœ%ž˜;—Jš�œ�œ
˜—Jš�œ
˜J˜——J˜Jšœ�œ�œ
˜Jšœ�œ
˜Jšœ
ž˜)Jšœ
ž˜&J˜J˜J˜š
�˜J˜˜LJšœ�œ
˜&—š�œ�œ
�œ
˜!š	�œ�œ�œ�œ�˜NJš�œ˜$J˜—Jš�œ"�œ�˜H˜š�œ.�œ�œ
ž˜Jšœ�œ
˜š�œ�˜˜
š�œ�˜
Jšœ*�œ˜:Jšœ�œ'�œ˜LJ˜:J˜8—Jš�œ)�œ˜6J˜—Jšœ1�œ˜7Jšœ.�œ˜>Jš�œ�œ
˜Jš
�˜J˜———J˜—Jš�œ
˜š�œ�˜Jšœ&ž˜E———Jš�œ
˜J˜——š
œA™AJ˜J˜J˜—Jš
œQ™QJš
œN™N˜J˜&J˜š
�˜Jšœ
�œ˜-—Jš�œ
˜J˜—Jš�œ
˜J˜—…—F„^˜