DIRECTORY
DefaultRemoteNames USING [Get],
GVAnswer USING [MakeHeader],
GVMailParse,
Menus,
IO,
Rope,
RuntimeError USING [BoundsFault],
TiogaOps USING [ Pattern, Ref, Location, ViewerDoc,
CreateSimplePattern,
GetSelection, InsertRope, SelectDocument, SelectPoint,
SelectionRoot, SelectionSearch, SetSelection, ToPrimary],
ViewerOps,
ViewerClasses,
ViewerTools,
WalnutDocumentRope,
WalnutParseMsg USING [SendParseStatus, Parse],
WalnutSendInternal,
WalnutSendOps;

WalnutSendOpsImpl: CEDAR MONITOR
IMPORTS
DefaultRemoteNames, IO, Rope, RuntimeError,
GVAnswer, GVMailParse,
Menus, TiogaOps, ViewerOps,
WalnutDocumentRope, WalnutParseMsg, WalnutSendInternal, WalnutSendOps
EXPORTS
WalnutSendInternal, WalnutSendOps
SHARES Menus =

BEGIN OPEN WalnutSendOps, WalnutSendInternal;


ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;
STREAM: TYPE = IO.STREAM;
TiogaContents: TYPE = ViewerTools.TiogaContents;

nullIndex:  INT = LAST[INT];

defaultRegistry: PUBLIC ROPE _ DefaultRemoteNames.Get[].registry;

Answer: PUBLIC PROC[msgHeaders: ROPE, who: Viewer_ NIL] RETURNS [v: Viewer] = {
notOk: BOOL;
errorIndex: INT;
answer: ROPE;
answerForm: WalnutSendOps.Form;
AnswerGetChar: PROC[pos: INT] RETURNS[CHAR] = {RETURN[msgHeaders.Fetch[pos]]};

[notOk, answer, errorIndex]_ GVAnswer.MakeHeader[AnswerGetChar, msgHeaders.Length[],
simpleUserName, defaultRegistry];

IF notOk THEN {
start, end: INT_ errorIndex;
BEGIN ENABLE RuntimeError.BoundsFault => {start_ 0; end_ 1; CONTINUE};
IF start = nullIndex THEN start_ 0
ELSE
{UNTIL msgHeaders.Fetch[start] = '\n DO start_ start - 1; ENDLOOP;
start_ start + 1};
IF end = nullIndex THEN end_ start + 1
ELSE
{UNTIL msgHeaders.Fetch[end] = '\n DO end_ end + 1; ENDLOOP;
end_ end - 1};
END;
IF who # NIL THEN ShowErrorFeedback[who, start, end];
SenderReport[IO.PutFR[
"\nSyntax error in line starting at pos %g (in message being answered)",
IO.int[start]]];
RETURN
};

answerForm _ NEW[ WalnutSendOps.FormRec _
[formText: answerText, fields: ParseAnswerHeader[answer] ] ];
v_ BuildSendViewer[TRUE, FALSE, answerForm, who]; 
ClearFileAssoc[v];
GrabFocus[v];
};

ParseAnswerHeader: PROC[header: ROPE] RETURNS[fields: LIST OF ROPE] = {
HeaderLines: ARRAY[0..3] OF Rope.ROPE;
startPos: INT _ Rope.Find[header, ": ", 0];
endOfLine: INT _ Rope.Find[header, "\n", startPos];
FOR i: INT IN [0..3] DO
HeaderLines[i] _ Rope.Substr[header, startPos+2, endOfLine-startPos-2];
startPos _ Rope.Find[header, ": ", endOfLine];
IF startPos = -1 THEN EXIT ELSE endOfLine _ Rope.Find[header, "\n", startPos]
ENDLOOP;
RETURN[ LIST[ HeaderLines[0], HeaderLines[1], HeaderLines[2], HeaderLines[3] ] ]
};

Forward: PUBLIC PROC[msg: Viewer, who: Viewer_ NIL]
RETURNS[v: Viewer] = TRUSTED {
forwardForm: WalnutSendOps.Form =
NEW[WalnutSendOps.FormRec _ [formText: forwardText, fields: NIL]];
messagePattern: TiogaOps.Pattern = TiogaOps.CreateSimplePattern["ForwardedMessage"];
headerPattern: TiogaOps.Pattern = TiogaOps.CreateSimplePattern["MessageHeader"];
pstart, pend: TiogaOps.Location;
root: TiogaOps.Ref;
found: BOOL; 
v_ BuildSendViewer[TRUE, FALSE, forwardForm, who];
ClearFileAssoc[v];
TiogaOps.SelectDocument[v];
root _ TiogaOps.SelectionRoot[];
pstart _ TiogaOps.Location[ root, 0 ];
TiogaOps.SelectPoint[ v, pstart ];
found _ TiogaOps.SelectionSearch[pattern: headerPattern];
IF found THEN
{ [ ,pstart, pend, , , ] _ TiogaOps.GetSelection[];
TiogaOps.SetSelection[viewer: v, start: pstart, end: pend,
level: word, pendingDelete: TRUE];
TiogaOps.InsertRope[ msg.name ] };
found _ TiogaOps.SelectionSearch[pattern: messagePattern];
IF NOT found THEN RETURN;
[ ,pstart, pend, , , ] _ TiogaOps.GetSelection[];
TiogaOps.SetSelection[ viewer: v, start: pstart, end: pend, level: node, pendingDelete: TRUE ];
TiogaOps.SelectDocument[ viewer: msg, which: secondary ];
TiogaOps.ToPrimary[];
UnsetNewVersion[v];
GrabFocus[v]
};

ClearFileAssoc: PUBLIC PROC[v: Viewer] = {
IF v.file # NIL THEN v.file_ NIL;
v.name_ sendCaption;
ViewerOps.PaintViewer[v, caption];
};

SenderNewVersion: PUBLIC PROC[viewer: Viewer] = {
OPEN Menus;
menu: Menus.Menu = viewer.menu;
firstForm: Menus.MenuEntry = Menus.GetLine[formsMenu, 0];

getEntry: Menus.MenuEntry_ Menus.FindEntry[menu, "Get"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, TRUE];
getEntry_ Menus.FindEntry[menu, "Default"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, TRUE];
getEntry_ Menus.FindEntry[menu, "PrevMsg"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, TRUE];

FOR i: Menus.MenuLine IN [1..5) DO
thisLine: Menus.MenuEntry = Menus.GetLine[menu, i];
IF thisLine = NIL THEN EXIT;
IF firstForm = NIL THEN EXIT;
IF Rope.Equal[thisLine.name, firstForm.name] THEN
FOR entry: MenuEntry _ thisLine, entry.link UNTIL entry = NIL DO
SetGuarded[entry, TRUE]
ENDLOOP;
ENDLOOP;
ViewerOps.PaintViewer[viewer, menu];		-- show as guarded
viewer.newVersion_ TRUE;
};

UnsetNewVersion: PUBLIC PROC[viewer: Viewer] = {
OPEN Menus;
menu: Menu = viewer.menu;
firstForm: Menus.MenuEntry = Menus.GetLine[formsMenu, 0];

getEntry: Menus.MenuEntry_ Menus.FindEntry[menu, "Get"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, FALSE];
getEntry_ Menus.FindEntry[menu, "Default"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, FALSE];
getEntry_ Menus.FindEntry[menu, "PrevMsg"];
IF getEntry # NIL THEN Menus.SetGuarded[getEntry, FALSE];

FOR i: Menus.MenuLine IN [1..5) DO
thisLine: Menus.MenuEntry = Menus.GetLine[menu, i];
IF thisLine = NIL THEN EXIT;
IF firstForm = NIL THEN EXIT;
IF Rope.Equal[thisLine.name, firstForm.name] THEN
FOR entry: MenuEntry _ thisLine, entry.link UNTIL entry = NIL DO
SetGuarded[entry, FALSE]
ENDLOOP;
ENDLOOP;
ViewerOps.PaintViewer[viewer, menu];		-- show as unguarded
viewer.newVersion_ FALSE;
ViewerOps.PaintViewer[viewer, caption];
};


TiogaTextFromStrm: PUBLIC PROC [strm: IO.STREAM, startPos: INT_ 0, len: INT_ LAST[INT]] RETURNS [contents: TiogaContents] = {
ENABLE IO.EndOfStream => GOTO TooShort;
fulltext: ROPE _ RopeFromStream[strm, startPos, len];
formatPos: INT _ Rope.Index[fulltext, 0, "\000\000"];

contents_ NEW[ViewerTools.TiogaContentsRec];

contents.contents_ Rope.Substr[fulltext, 0, formatPos];
IF formatPos < Rope.Length[fulltext] THEN contents.formatting_ Rope.Substr[fulltext, formatPos];

EXITS TooShort => RETURN[NIL];
};

RopeFromStream: PUBLIC PROC [strm: STREAM, startPos, len: INT] RETURNS [contents: ROPE] = {

rem: INT _ IO.GetLength[strm] - startPos;
IF rem < len THEN len _ rem;
IF len < 2048 THEN TRUSTED {
nat: NAT _ len;
text: Rope.Text _ Rope.NewText[nat];
IO.SetIndex[strm, startPos];
[] _ IO.GetBlock[strm, LOOPHOLE[text], 0, nat];
RETURN [text];
};
rem _ len/2;
len _ len - rem;
contents _ RopeFromStream[strm, startPos, len];
contents _ Rope.Concat[contents, RopeFromStream[strm, startPos+len, rem] ];
};

GetFieldBody: PUBLIC PROC[text, fieldName: ROPE] RETURNS[fieldBody: ROPE] = {
OPEN GVMailParse;
mPos: INT_ 0;
lastCharPos: INT_ text.Length[];
pH: GVMailParse.ParseHandle_ GVMailParse.InitializeParse[];

NextChar: PROC[] RETURNS [ch: CHAR] =
{ IF mPos > lastCharPos THEN ch_ endOfInput ELSE ch_ text.Fetch[mPos];
mPos_ mPos + 1;
};

BEGIN
field: ROPE_ NIL;
DO
found, fieldNotRecognized: BOOL_ TRUE;
[field, found]_
GVMailParse.GetFieldName[pH, NextChar ! ParseError => GOTO parseErrorExit];
IF ~found THEN EXIT;

IF Rope.Equal[fieldName, field, FALSE] THEN	-- ignore case
{ fieldBody_ GVMailParse.GetFieldBody[pH, NextChar]; EXIT}
ELSE []_ GVMailParse.GetFieldBody[pH, NextChar, TRUE];
ENDLOOP;

GVMailParse.FinalizeParse[pH];
EXITS
parseErrorExit => { GVMailParse.FinalizeParse[pH]; RETURN[NIL]};
END;
};

GetRecipients: PUBLIC PROC[sender: Viewer]
RETURNS[rList: LIST OF ROPE, parseError: BOOL] = {
text: ROPE;
status: WalnutParseMsg.SendParseStatus;
sPos, mPos: INT;
TRUSTED
{text_ WalnutDocumentRope.Create[LOOPHOLE [TiogaOps.ViewerDoc[sender]]]};
[status, sPos, mPos, rList]_ WalnutParseMsg.Parse[text];
IF (status # ok) AND (status # includesPublicDL) THEN
BEGIN
SELECT status FROM
fieldNotAllowed =>
IF sPos # mPos THEN
{ ShowErrorFeedback[sender, sPos, mPos];
SenderReport[Rope.Substr[text, 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[sender, sPos, mPos];
SenderReport["\nSyntax error on line beginning with "];
SenderReport[Rope.Substr[text, 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[sender, IF sender.iconic THEN 0 ELSE 1];
RETURN[NIL, TRUE]
END;
RETURN[rList, FALSE]
};

END.



BWalnutSendOpsImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Willie-Sue, May 3, 1985 3:04:59 pm PDT

Contents: More procs for WalnutSend
Created by Willie-Sue, December 13, 1983
************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
returns NIL IF endOfStream encountered during read
Reads arbitrary length ROPE from a stream.  If some caller catches the error, then the caller can diagnose it.  Otherwise we do something more or less reasonable here.
Short enough to make in one piece
The rope is too large to make in one piece, so we divide the length in two and recursviely call ourselves.  This gets at least 1024 characters in each piece in a balanced binary tree, so the recursion is quite acceptable even for large messages.
Do this first to ensure that the evaluation order is OK.
expects text to be the text of a message; parses the header fields looking for a field named fieldName and returns the value of the fieldBody, or NIL if no such fieldName is found
expects sender to contain a message to be sent; will parse the headers and return a list of all the recipients of the message;  if an error occurs while parsing the viewer, parseError=TRUE is returned, and the viewer will have the offending field underlined.
Κ
›˜š
Οb™Jšœ
Οm
œ1™<Icode™&—J™Jš
œ#™#Jš
œ(™(J˜š
Οk	˜	KšœŸœ˜Jšœ	Ÿœ˜J˜J˜JšŸœ
˜J˜Jšœ
Ÿœ˜!šœ	Ÿœ%˜3J˜J˜6J˜9—J˜
J˜J˜J˜JšœŸœ˜.J˜J˜J˜JšœŸœ
Ÿ˜ š
Ÿ˜JšœŸœ˜+J˜J˜Jš
œE˜E—š
Ÿ˜J˜!—JšŸœ˜—˜JšŸœ
Ÿœ#˜-—J˜Jš
œH™HJ˜JšŸœŸœŸœ
˜JšœŸœ˜$JšŸœŸœŸœ
Ÿœ
˜JšœŸœ˜0J˜JšœŸœŸœ
Ÿœ˜J˜JšœŸœ
Ÿœ%˜AJ˜šΟnœŸœ
Ÿœ
ŸœŸœŸœ˜OJšœŸœ
˜JšœŸœ
˜JšœŸœ
˜
J˜Jš 
œŸœŸœŸœ
ŸœŸœ˜NJ˜˜TJ˜!J˜—šŸœŸœ˜JšœŸœ
˜šŸœ
Ÿœ0Ÿœ˜FšŸœŸœ	˜"Jš
Ÿ˜—šœ
ŸœŸœŸœ
˜BJ˜—šŸœŸœ˜&Jš
Ÿ˜—šœ
ŸœŸœŸœ
˜<J˜—JšŸœ
˜—JšŸœŸœ
Ÿœ$˜5šœ
Ÿœ˜˜HJšŸœ˜——Jš
Ÿ˜Jš
œ˜—J˜šœ
Ÿœ˜)J˜=—JšœŸœŸœ˜2J˜J˜
Jš
œ˜—J˜š œŸœ	ŸœŸœ	Ÿœ
Ÿœ
Ÿœ˜GJšœ
ŸœŸœŸœ
˜&Jšœ
Ÿœ˜+JšœŸœ%˜3šŸœŸœ
ŸœŸ˜J˜GJ˜.JšŸœŸœ
Ÿœ
Ÿœ.˜M—JšŸœ
˜JšŸœŸœD˜Pš
œ˜J˜——š œŸœ
ŸœŸœŸœŸœ˜RJ˜!JšŸœ9Ÿœ˜BJ˜TJ˜PJ˜ J˜JšœŸœ˜
JšœŸœŸœ˜2J˜J˜J˜ J˜&J˜"J˜9šŸœŸ˜
˜3˜:JšœŸœ˜"—J˜"——J˜:JšŸœ
ŸœŸœ
Ÿœ
˜J˜1JšœXŸœ˜_J˜9J˜J˜J˜Jš
œ˜J˜—š œŸœ
Ÿœ˜*JšŸœ
Ÿœ
Ÿœ	Ÿœ
˜!J˜J˜"Jš
œ˜J˜—š œŸœ
Ÿœ˜1šŸœ˜J˜J˜9J˜J˜8JšŸœŸœ
ŸœŸœ˜8J˜+JšŸœŸœ
ŸœŸœ˜8J˜+JšŸœŸœ
ŸœŸœ˜8J˜šŸœŸœŸ˜"J˜3JšŸœŸœ
Ÿœ
Ÿœ
˜JšŸœ
Ÿœ
Ÿœ
Ÿœ
˜JšŸœ+Ÿ˜1šŸœ)Ÿœ	Ÿœ
Ÿ˜@JšœŸœ
˜JšŸœ
˜—JšŸœ
˜—Jšœ&Οc˜8JšœŸœ
˜—Jš
œ˜J˜—š œŸœ
Ÿœ˜0JšŸœ˜J˜J˜9J˜J˜8JšŸœŸœ
ŸœŸœ˜9J˜+JšŸœŸœ
ŸœŸœ˜9J˜+JšŸœŸœ
ŸœŸœ˜9J˜šŸœŸœŸ˜"J˜3JšŸœŸœ
Ÿœ
Ÿœ
˜JšŸœ
Ÿœ
Ÿœ
Ÿœ
˜JšŸœ+Ÿ˜1šŸœ)Ÿœ	Ÿœ
Ÿ˜@JšœŸœ
˜JšŸœ
˜—JšŸœ
˜—Jšœ&‘˜:JšœŸœ
˜J˜'Jš
œ˜J˜—Jš
œE™EJ˜š œŸœ
ŸœŸœ
ŸœŸœ
ŸœŸœ
ŸœŸœ˜}Kš
œ2™2KšŸœ
ŸœŸœ
˜'Kšœ
Ÿœ$˜5KšœŸœ'˜5K˜Kšœ
Ÿœ˜,K˜Kš
œ7˜7KšŸœ#Ÿœ7˜`K˜KšŸœ
Ÿœ
Ÿœ˜Kš
œ˜K˜—š œŸœ
ŸœŸœŸœŸœŸœ˜[KšœŸœŒ
™§
K˜KšœŸœŸœ˜)KšŸœŸœ˜šŸœŸœ
Ÿœ˜Kš
œ!™!KšœŸœ˜K˜$KšŸœ˜KšœŸœŸœ˜/KšŸœ˜K˜—Kš
œυ
™υ
K˜K˜š
œ/˜/Kš
œ8™8—Kš
œK˜KKš
œ˜—J˜š
 œŸœŸœŸœŸœ˜MJš
œ³
™³
šŸœ
˜JšœŸœ˜
Jšœ
Ÿœ˜ Jš
œ;˜;J˜Jš œŸœŸœŸœ˜%šœŸœŸœŸœ˜FJ˜—J˜J˜Jš
Ÿ˜JšœŸœŸœ
˜š
Ÿ˜JšœŸœŸœ
˜&š
œ˜Jšœ6Ÿœ˜K—JšŸœŸœ
Ÿœ
˜J˜šŸœŸœŸœ
‘˜:šœ5Ÿœ
˜:JšŸœ,Ÿœ˜6———JšŸœ
˜J˜Jš
œ˜š
Ÿ˜Jšœ3Ÿœ
Ÿœ˜@—JšŸœ
˜—Jš
œ˜J˜—š 
œŸœŸœŸœ
Ÿœ
ŸœŸœ˜]Jš
œ‚™‚JšœŸœ
˜J˜'JšœŸœ
˜š
Ÿ˜Jšœ!Ÿœ ˜I—Jš
œ8˜8JšŸœŸœŸ˜5š
Ÿ˜šŸœŸ˜š
œ˜JšŸœ
Ÿ˜š
œ(˜(JšœŸœ˜;Jš
œ(˜(—JšŸœŸœ-Ÿœ
˜P—š
œ˜JšŸœ
Ÿ˜š
œ(˜(Jš
œ7˜7JšœŸœ˜;—JšŸœŸœ.Ÿœ
˜Q—Jš
œM˜MJšŸœŸœ
˜—JšœŸœŸœŸœ˜<JšŸœ
ŸœŸœ
˜—JšŸœ
˜JšŸœŸœ
˜J˜J˜—JšŸœ
˜J˜J˜J˜—…—!τ1Ρ