
<<SBImpl.mesa>>
<<Last Edited by Curry, April 23, 1986 7:13:15 pm PST>>
    <<Don Curry April 28, 1987 3:22:55 pm PDT>>
    <<Last Edited by: Don Curry May 28, 1987 11:14:23 am PDT>>
    <<Kizer, April 23, 1991 2:29 pm PDT>>
    <<Foote, April 25, 1991 9:14 am PDT>>

DIRECTORY
Basics,
Commander,
FS,
IO,
Rope,
SB;

SBImpl: CEDAR PROGRAM
IMPORTS Commander, IO, FS, Rope
EXPORTS SB =
BEGIN OPEN SB;

<<errorCalled:    BOOLEAN _ FALSE;>>
<<>>
ReadLeagueFile: PUBLIC PROC[file: IO.ROPE, log: IO.STREAM _ IO.noWhereStream]
RETURNS[league: League] = {
ENABLE FS.Error => IF error.group = user THEN
{log.PutRope[error.explanation]; CONTINUE};
SkipColon: PROC = {[ ]    _ IO.GetChar[inStm]};
key:        IO.ROPE _ NIL;
inStm:        IO.STREAM;
fullName:    IO.ROPE _    FS.ExpandName[file].fullFName;
IF (inStm _ FS.StreamOpen[fileName: fullName])=NIL THEN RETURN[NIL];
league _ NEW[LeagueRec _ [file: fullName ]];
DO
ENABLE IO.EndOfStream => EXIT;
key _ IO.GetTokenRope[inStm].token;
SELECT TRUE FROM
Rope.Equal[key, "FILE"]        => {SkipColon[]; [ ]                _ IO.GetTokenRope[inStm]};
Rope.Equal[key, "TIME"]        => {SkipColon[]; league.time    _ IO.GetTime[inStm]};
Rope.Equal[key, "YEAR"]        => {SkipColon[]; league.year    _ IO.GetInt[inStm]};
Rope.Equal[key, "TEAMS"]     => {SkipColon[]; teamNms        _ GenRopeSeq[inStm]};
Rope.Equal[key, "GROUPS"]    => {SkipColon[]; groupNms    _ GenRopeSeq[inStm]};
Rope.Equal[key, "MEMBERS"]    => {[]_IO.GetLineRope[inStm]; EXIT};
ENDCASE;
ENDLOOP;
league.teamStats        _ NEW[TeamStatSeq[teamNms.size]];
league.groupCnts    _ NEW[CardSeqRec[groupNms.size]];
DO
member:    Member _ NIL;
member2:    Member _ NIL;
done:        BOOL;
[done, member] _ GetMember[inStm];
IF done THEN EXIT;
IF member=NIL THEN LOOP;
IF member.pair=paired THEN {
[done, member2] _ GetMember[inStm];
IF done OR member2=NIL OR member2.pair=sgl THEN ERROR;
member2.sse _ member;
member.sse _ member2;
AddMember[league, member2] };
AddMember[league, member];
ENDLOOP;
inStm.Close[];
Update[league] };

CompareNames: PUBLIC PROC[first1, last1, first2, last2: IO.ROPE] RETURNS[Basics.Comparison] = {
comp: Basics.Comparison _ Rope.Compare[last1, last2, FALSE];
IF comp#equal
THEN    RETURN[comp]
ELSE    RETURN[Rope.Compare[first1, first2, FALSE] ] };

AddMember:    PUBLIC PROC[league: League, member: Member] = {
AddMem:    PROC[list: LIST OF Member, mem: Member] RETURNS[LIST OF Member] = {
IF list=NIL THEN RETURN[CONS[mem, list]];
SELECT CompareNames[list.first.fname, list.first.lname, mem.fname, mem.lname] FROM
less        => {list.rest _ AddMem[list.rest, mem];        RETURN[ list ]};
greater    => {                                                RETURN[ CONS[mem, list] ]};
ENDCASE    => ERROR };
league.members _ AddMem[league.members, member]};


FindMember: PUBLIC PROC[league: League, last, first: IO.ROPE] RETURNS[member: Member] = {
FindMem: PROC[list: LIST OF Member, lname, fname: IO.ROPE] RETURNS[member: Member] = {
IF list=NIL THEN RETURN[NIL];
SELECT CompareNames[list.first.fname, list.first.lname, fname, lname] FROM
less        => RETURN[FindMem[list.rest, lname, fname] ];
greater    => RETURN[NIL];
ENDCASE    => RETURN[list.first] };
RETURN[ FindMem[league.members, last, first] ]} ;

FindMemberName: PUBLIC PROC [league: League, name: IO.ROPE]
RETURNS[member: Member] = {
FOR lst: LIST OF Member _ league.members, lst.rest WHILE lst#NIL DO
SELECT Rope.Compare[lst.first.lname, name] FROM
less        => LOOP;
greater    => EXIT;
ENDCASE    => RETURN[lst.first] ENDLOOP;
FOR lst: LIST OF Member _ league.members, lst.rest WHILE lst#NIL DO
SELECT Rope.Compare[lst.first.fname, name] FROM
less        => LOOP;
greater    => LOOP;
ENDCASE    => RETURN[lst.first] ENDLOOP;
RETURN[NIL]} ;

DeleteMember: PUBLIC PROC[league: League, member: Member] = {
DelMem: PROC[list: LIST OF Member, mem: Member] RETURNS[LIST OF Member] = {
IF list=NIL THEN ERROR;
IF list.first#member
THEN    {list.rest _ DelMem[list.rest, mem];    RETURN[list]}
ELSE    RETURN[list.rest] };
league.members _ DelMem[league.members, member]};

Reverse: PROC [list: LIST OF Member] RETURNS[new: LIST OF Member] = 
{FOR list _ list, list.rest WHILE list#NIL DO new _ CONS[list.first, new] ENDLOOP};
TML:        TYPE = REF TMLRec;
TMLRec:    TYPE = RECORD[SEQUENCE size: Team OF LIST OF Member];

WriteTeamFile:    PUBLIC PROC[league: League, log: IO.STREAM _ IO.noWhereStream] = {
out: IO.STREAM;
root: IO.ROPE;
teamCoaches:        TML _ NEW[TMLRec[league.teamStats.size]];
teamSkeeps:        TML _ NEW[TMLRec[league.teamStats.size]];
teamMembers:    TML _ NEW[TMLRec[league.teamStats.size]];
Update[league];
root    _ league.file.Substr[len: FS.ExpandName[league.file].cp.ext.start];
out    _ FS.StreamOpen[root.Cat["teams"], $create];
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
SELECT list.first.type FROM
coach        => teamCoaches[list.first.team]        _ CONS[list.first, teamCoaches[list.first.team]];
skeep        => teamSkeeps[list.first.team]        _ CONS[list.first, teamSkeeps[list.first.team]];
player    => teamMembers[list.first.team]    _ CONS[list.first, teamMembers[list.first.team]];
ENDCASE    => Signal[] ENDLOOP;
FOR team: Team IN [0..league.teamStats.size) DO
teamCoaches[team]    _ Reverse[teamCoaches[team]];
teamSkeeps[team]    _ Reverse[teamSkeeps[team]];
teamMembers[team]    _ Reverse[teamMembers[team]] ENDLOOP;
FOR section: NAT IN [0..2) DO
firstTeam:    Team _ 1+section*league.teamStats.size/2;
out.PutRope["\n"];
FOR team: Team IN [firstTeam..firstTeam+league.teamStats.size/2) DO
IF team#firstTeam THEN out.PutRope["    "] ELSE out.PutRope["\n"];
out.PutRope[league.teamNms[team]] ENDLOOP;
PrintTML[teamCoaches, out, firstTeam, league];
PrintTML[teamSkeeps, out, firstTeam, league];
PrintTML[teamMembers, out, firstTeam, league];
ENDLOOP;
out.Close[]};

WriteTeamFileSimple:    PUBLIC PROC[league: League, log: IO.STREAM _ IO.noWhereStream] = {
out: IO.STREAM;
root: IO.ROPE;
teamCoaches:        TML _ NEW[TMLRec[league.teamStats.size]];
teamSkeeps:        TML _ NEW[TMLRec[league.teamStats.size]];
teamMembers:    TML _ NEW[TMLRec[league.teamStats.size]];
Update[league];
root    _ league.file.Substr[len: FS.ExpandName[league.file].cp.ext.start];
out    _ FS.StreamOpen[root.Cat["teams2"], $create];
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
SELECT list.first.type FROM
coach        => teamCoaches[list.first.team]        _ CONS[list.first, teamCoaches[list.first.team]];
skeep        => teamSkeeps[list.first.team]        _ CONS[list.first, teamSkeeps[list.first.team]];
player    => teamMembers[list.first.team]    _ CONS[list.first, teamMembers[list.first.team]];
ENDCASE    => Signal[] ENDLOOP;
FOR team: Team IN [0..league.teamStats.size) DO
teamCoaches[team]    _ Reverse[teamCoaches[team]];
teamSkeeps[team]    _ Reverse[teamSkeeps[team]];
teamMembers[team]    _ Reverse[teamMembers[team]] ENDLOOP;

FOR team: Team IN [1..league.teamStats.size) DO
out.PutRope["Team:  "];
out.PutRope[league.teamNms[team]];
out.PutRope["\n\nCoaches:\n"];
FOR list: LIST OF Member _ teamCoaches[team], list.rest WHILE list # NIL DO
out.PutF["  %g %g\n", IO.rope[list.first.fname], IO.rope[list.first.lname]];
ENDLOOP;
IF teamSkeeps[team] # NIL THEN out.PutRope["\nScoreKeepers:\n"] ;
FOR list: LIST OF Member _ teamSkeeps[team], list.rest WHILE list # NIL DO
out.PutF["  %g %g\n", IO.rope[list.first.fname], IO.rope[list.first.lname]];
ENDLOOP;
out.PutRope["\nPlayers:\n"];
FOR list: LIST OF Member _ teamMembers[team], list.rest WHILE list # NIL DO
out.PutF["  %g %g\n", IO.rope[list.first.fname], IO.rope[list.first.lname]];
ENDLOOP;
out.PutRope["\n\n"];
ENDLOOP;
out.Close[]};

PrintTML: PROC[tml: TML, out: IO.STREAM, firstTeam: Team, league: League] = {
DO
FOR team: Team IN [firstTeam..firstTeam+league.teamStats.size/2) DO
IF tml[team]#NIL THEN EXIT REPEAT FINISHED => EXIT ENDLOOP;
FOR team: Team IN [firstTeam..firstTeam+league.teamStats.size/2) DO
IF team#firstTeam THEN out.PutRope["    "] ELSE out.PutRope["\n"];
IF tml[team]=NIL
THEN    LOOP
ELSE    {
member: Member _ tml[team].first;
out.PutF["%g %g", IO.rope[member.fname], IO.rope[member.lname]];
tml[team] _ tml[team].rest }
ENDLOOP;
ENDLOOP;
out.PutRope["\n"]};

WriteLeagueFiles:    PUBLIC PROC[league: League, log: IO.STREAM _ IO.noWhereStream] = {
ENABLE FS.Error => IF error.group = user THEN
{log.PutRope[error.explanation]; CONTINUE};
out: IO.STREAM;
Update[league];
WriteTeamFile[league, log];
WriteTeamFileSimple[league, log];
out            _ FS.StreamOpen[league.file, $create];
out.PutF        ["\nFILE:  %g",        IO.rope[league.file] ];
out.PutF        ["\nTIME:  %g",    IO.time[league.time] ];
out.PutF        ["\nYEAR:  %g",    IO.card[league.year]];
out.PutRope    ["\nTEAMS:"];
FOR team: CARDINAL IN [0..teamNms.size) DO out.PutF[" %g", IO.rope[teamNms[team]]] ENDLOOP;
out.PutRope    ["\nGROUPS:"];
FOR group: CARDINAL IN [0..groupNms.size) DO out.PutF[" %g", IO.rope[groupNms[group]]] ENDLOOP;
out.PutRope["\n\n"];
OutJustify[out,    left,    "Team",    league.teamMax];
out.PutRope[" males  female players   keeps  points  dIndex\n"];
FOR team: Team IN [0..league.teamStats.size) DO
out.PutRope["\n"];
OutJustify[out,    left,    teamNms[team],    league.teamMax];
out.PutF ["  %3g     %3g     %3g     %3g",
IO.card[league.teamStats[team].males],
IO.card[league.teamStats[team].females],
IO.card[league.teamStats[team].players],
IO.card[league.teamStats[team].keeps]];
out.PutF ["     %3g     %3g ",
IO.card[league.teamStats[team].points],
IO.card[league.teamStats[team].dIndex]];
ENDLOOP;
out.PutF ["\n\n  %4g Score Keepers",        IO.card[league.keeps]];
out.PutF ["\n\n  %4g Male",                    IO.card[league.males]];
out.PutF [  "\n  %4g Female",                IO.card[league.females]];
out.PutF ["\n\n  %4g Total Players",        IO.card[league.players]];
out.PutF [  "\n  %4g Participants",        IO.card[league.players + league.keeps]];
out.PutF ["\n\n  %4g Paid   Players",    IO.card[league.paid]];
out.PutF [  "\n  %4g Unpaid Players",    IO.card[league.unpaid]];
out.PutF ["\n\n  %4g Dollars Paid",        IO.card[league.dollarsIn]];
out.PutF [  "\n  %4g Dollars Owed",        IO.card[league.dollarsOut]];
out.PutRope["\n\nGroup participation\n"];
FOR group: Group IN [0..league.groupCnts.size) DO
out.PutF ["\n  %4g %g",
IO.card[league.groupCnts[LOOPHOLE[group]]],
IO.rope[groupNms[LOOPHOLE[group]] ] ];
ENDLOOP;
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
list.first.marked _ FALSE; ENDLOOP;
out.PutRope["\n\n\nMEMBERS:"];
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
IF list.first.marked THEN LOOP;
IF list.first.sse#NIL
THEN {
PutMember[league, list.first,        out];    list.first.marked        _ TRUE;
PutMember[league, list.first.sse,    out];    list.first.sse.marked    _ TRUE }
ELSE    {PutMember[league, list.first, out];    list.first.marked        _ TRUE};
ENDLOOP;
out.PutRope["\nEND\n"];
out.PutRope["\n\n"];
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
list.first.marked _ FALSE; ENDLOOP;
FOR rating: Rating DECREASING IN Rating DO
out.PutF["\n\f\n   Rating = %g", IO.card[rating]];
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
IF list.first.marked OR list.first.rating#rating THEN LOOP;
IF list.first.sse#NIL
THEN {
PutMember[league, list.first,        out];    list.first.marked        _ TRUE;
PutMember[league, list.first.sse,    out];    list.first.sse.marked    _ TRUE }
ELSE    {PutMember[league, list.first, out];    list.first.marked        _ TRUE};
ENDLOOP;
ENDLOOP;
out.PutRope["\nEND\n"];
out.Close[] };


GetMember: PROC[inStm: IO.STREAM] RETURNS[done: BOOL, member: Member] = {
Break: IO.BreakProc = {
RETURN[SELECT char FROM
IN [IO.NUL .. IO.SP], ',,  ';                    => sepr,
<<'[, '], '(, '), '{, '}, '", '+, '-, '*, '/, '@, '_    => break,>>
ENDCASE                                        => other]};
Get: PROC RETURNS[rope: IO.ROPE] = {RETURN[IO.GetTokenRope[inStm, Break].token]};
AllSP: PROC[test: IO.ROPE] RETURNS[BOOL] = {
IF test=NIL THEN RETURN[FALSE];
FOR i: INT IN [0..test.Length[]) DO IF test.Fetch[i]#IO.SP THEN RETURN[FALSE] ENDLOOP;
RETURN[TRUE]};
rope: IO.ROPE;
IF IO.EndOf[inStm] THEN RETURN[TRUE, NIL];
inStm        _ IO.RIS[ IO.GetLineRope[inStm] ];
rope        _ Get[! IO.EndOfStream => rope_NIL];
IF rope=NIL THEN RETURN[FALSE, NIL];
IF Rope.Equal[rope, "END"] THEN RETURN[TRUE, NIL];
member            _ NEW[MemberRec _ [ ]];
member.lname    _ rope;
member.fname    _ Get[];
member.pair        _ LOOPHOLE[ RopeSeqIndex[Get[],    pairNms]];
member.sex        _ LOOPHOLE[ RopeSeqIndex[Get[],    sexNms]];
member.rating    _ LOOPHOLE[ RopeSeqIndex[Get[],    ratingNms]];
member.team        _ LOOPHOLE[ RopeSeqIndex[Get[],    teamNms]];
member.type        _ LOOPHOLE[ RopeSeqIndex[Get[],    typeNms]];
member.paid        _ LOOPHOLE[ RopeSeqIndex[Get[],    paidNms]];
member.group    _ LOOPHOLE[ RopeSeqIndex[Get[],    groupNms]];
member.shirt        _ LOOPHOLE[ RopeSeqIndex[Get[],    shirtNms]];
member.addr        _ Get[];
member.tnum    _ Get[];
member.pos        _ Get[];
member.atten        _ Get[];
IF IO.EndOf[inStm] THEN RETURN[FALSE, member];
DO
[ ] _ IO.SkipWhitespace[inStm];
IF IO.EndOf[inStm] THEN {IF AllSP[member.comnt] THEN ERROR; RETURN[FALSE, member]};
member.comnt    _ member.comnt.Cat[Get[]," "] 
ENDLOOP};

GetMemberOld: PROC[inStm: IO.STREAM] RETURNS[done: BOOL, member: Member] = {
Break: IO.BreakProc = {
RETURN[SELECT char FROM
IN [IO.NUL .. IO.SP], ',, ':,  ';                 => sepr,
<<'[, '], '(, '), '{, '}, '", '+, '-, '*, '/, '@, '_    => break,>>
ENDCASE                                        => other]};
Get: PROC RETURNS[rope: IO.ROPE] = {RETURN[IO.GetTokenRope[inStm, Break].token]};
AllSP: PROC[test: IO.ROPE] RETURNS[BOOL] = {
IF test=NIL THEN RETURN[FALSE];
FOR i: INT IN [0..test.Length[]) DO IF test.Fetch[i]#IO.SP THEN RETURN[FALSE] ENDLOOP;
RETURN[TRUE]};
rope: IO.ROPE;
IF IO.EndOf[inStm] THEN RETURN[TRUE, NIL];
inStm        _ IO.RIS[ IO.GetLineRope[inStm] ];
rope        _ Get[! IO.EndOfStream => {rope_NIL; CONTINUE}];
IF rope=NIL THEN RETURN[FALSE, NIL];
IF Rope.Equal[rope, "END"] THEN RETURN[TRUE, NIL];
member            _ NEW[MemberRec _ [ ]];
member.type        _ LOOPHOLE[ RopeSeqIndex[rope,                                    typeNms]];
member.team        _ LOOPHOLE[ RopeSeqIndex[Get[],    teamNms]];
member.rating    _ LOOPHOLE[ RopeSeqIndex[Get[],    ratingNms]];
member.sex        _ LOOPHOLE[ RopeSeqIndex[Get[],    sexNms]];
member.pair        _ LOOPHOLE[ RopeSeqIndex[Get[],    pairNms]];
member.paid        _ LOOPHOLE[ RopeSeqIndex[Get[],    paidNms]];
member.lname    _ Get[];
member.fname    _ Get[];
member.addr        _ Get[];
member.tnum    _ Get[];
member.group    _ LOOPHOLE[ RopeSeqIndex[Get[],    groupNms]];
member.pos        _ Get[];
member.shirt        _ LOOPHOLE[ RopeSeqIndex[Get[],    shirtNms]];
member.atten        _ Get[];
IF IO.EndOf[inStm] THEN RETURN[FALSE, member];
DO
[ ] _ IO.SkipWhitespace[inStm];
IF IO.EndOf[inStm] THEN {IF AllSP[member.comnt] THEN ERROR; RETURN[FALSE, member]};
member.comnt    _ member.comnt.Cat[Get[]," "] 
ENDLOOP};

PutMember: PROC[league: League, m: Member, out: IO.STREAM] = {
out.PutRope["\n"];
OutJustify[out,    left,    m.lname,                                        league.lnameMax];
OutJustify[out,    left,    m.fname,                                        league.fnameMax];
OutJustify[out,    right,    pairNms        [LOOPHOLE[m.pair        ]],    league.pairMax];
OutJustify[out,    right,    sexNms        [LOOPHOLE[m.sex        ]],    league.sexMax];
OutJustify[out,    right,    ratingNms    [LOOPHOLE[m.rating    ]],    league.ratingMax];
OutJustify[out,    right,    teamNms        [LOOPHOLE[m.team        ]],    league.teamMax];
OutJustify[out,    right,    typeNms        [LOOPHOLE[m.type        ]],    league.typeMax];
OutJustify[out,    right,    paidNms        [LOOPHOLE[m.paid        ]],    league.paidMax];
OutJustify[out,    right,    groupNms    [LOOPHOLE[m.group    ]],    league.groupMax];
OutJustify[out,    right,    shirtNms        [LOOPHOLE[m.shirt        ]],    league.shirtMax];
OutJustify[out,    right,    m.addr,                                        league.addrMax];
OutJustify[out,    right,    m.tnum,                                        league.tnumMax];
OutJustify[out,    right,    m.pos,                                            league.posMax];
OutJustify[out,    right,    m.atten,                                        league.attenMax];
IF m.comnt=NIL THEN RETURN;
out.PutRope[" "];
out.PutRope[m.comnt] };

Update: PUBLIC PROC[league: League] = {
maxDIndex, minTeamPts: CARDINAL _ 0;
otp: CARDINAL        _ RopeSeqIndex["OTP", groupNms];
IF otp=0 THEN ERROR;    -- where is old time player?
league.time            _ BasicTime.Now[];
FOR i: Team IN [0..league.teamStats.size) DO league.teamStats[i] _ [] ENDLOOP;
FOR i: Group IN [0..league.groupCnts.size) DO league.groupCnts[i] _ 0 ENDLOOP;
league.nextDIndex    _ 0;
league.nextDTeam    _ 0;
league.players        _ 0;
league.keeps            _ 0;
league.males            _ 0;
league.females        _ 0;
league.dollarsIn        _ 0;
league.dollarsOut    _ 0;
league.paid            _ 0;
league.unpaid        _ 0;
league.lnameMax    _ 0;
league.fnameMax    _ 0;
league.typeMax        _ 0;
league.ratingMax    _ 0;
league.teamMax        _ 0;
league.paidMax        _ 0;
league.groupMax    _ 0;
league.shirtMax        _ 0;
league.pairMax        _ 0;
league.sexMax        _ 0;
league.addrMax        _ 0;
league.tnumMax        _ 0;
league.posMax        _ 0;
league.attenMax        _ 0;
league.comntMax    _ 0;
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
teams:    TeamStats     _ league.teamStats;
m:        Member    _ list.first;
IF m.type#skeep
THEN {
league.players            _ league.players    + 1;
league.nextDIndex        _ MAX[league.nextDIndex,                    m.dIndex];
teams[m.team].dIndex    _ MAX[teams[m.team].dIndex,    m.dIndex];
IF Protected[m]
THEN    teams[m.team].prtctd _ teams[m.team].prtctd+m.rating
ELSE    teams[m.team].points _ teams[m.team].points+m.rating;
IF ~Protected[m] AND ~AutomaticMember[m] THEN
teams[m.team].minPick _ IF teams[m.team].minPick=0
THEN    m.rating
ELSE    MIN[m.rating, teams[m.team].minPick];
SELECT m.paid FROM
unpaid    => {
league.dollarsOut    _ league.dollarsOut    +
(IF m.type=coach THEN 0 ELSE IF m.group=otp THEN 40 ELSE 30);
league.unpaid        _ league.unpaid        + 1};
paid    => {
league.dollarsIn        _ league.dollarsIn    +
(IF m.type=coach THEN 0 ELSE IF m.group=otp THEN 40 ELSE 30);
league.paid            _ league.paid        + 1};
ENDCASE;    -- exempted (CZAR, CZARina and skeeps) 
teams[m.team].players     _ teams[m.team].players        + 1;
IF m.sex=male
THEN    {
league.males                         _ league.males                            + 1;
teams[m.team].males     _ teams[m.team].males        + 1}
ELSE    {
league.females                         _ league.females                            + 1;
teams[m.team].females     _ teams[m.team].females    + 1} }
ELSE {
league.keeps                            _ league.keeps    + 1;
teams[m.team].keeps     _ teams[m.team].keeps        + 1};
league.groupCnts[m.group]            _ league.groupCnts[m.group]            + 1;

league.typeNms        _ typeNms;
league.ratingNms    _ ratingNms;
league.teamNms        _ teamNms;
league.paidNms        _ paidNms;
league.groupNms    _ groupNms;
league.shirtNms        _ shirtNms;
league.pairNms        _ pairNms;
league.sexNms        _ sexNms;

league.lnameMax    _ MAX[CARD[Rope.Length[m.lname    ]],        league.lnameMax];
league.fnameMax    _ MAX[CARD[Rope.Length[m.fname    ]],        league.fnameMax];
league.addrMax        _ MAX[CARD[Rope.Length[m.addr    ]],        league.addrMax];
league.tnumMax        _ MAX[CARD[Rope.Length[m.tnum    ]],        league.tnumMax];
league.posMax        _ MAX[CARD[Rope.Length[m.pos        ]],        league.posMax];
league.attenMax        _ MAX[CARD[Rope.Length[m.atten    ]],        league.attenMax];
league.comntMax    _ MAX[CARD[Rope.Length[m.comnt    ]],        league.comntMax];
ENDLOOP;
FOR list: LIST OF Member _ league.members, list.rest WHILE list # NIL DO
m: Member _ list.first;
IF Protected[m]
AND league.teamStats[m.team].minPick > 0
AND league.teamStats[m.team].minPick <= m.rating THEN {
league.teamStats[m.team].prtctd _ league.teamStats[m.team].prtctd    - m.rating;
league.teamStats[m.team].points _ league.teamStats[m.team].points    + m.rating};
ENDLOOP;
BEGIN    -- update next draft parameters
teams: TeamStats _ league.teamStats;
league.nextDIndex _ teams[0].dIndex _ league.nextDIndex + 1;
league.nextDTeam _ 1;
IF teams[1].dIndex=0 THEN teams[1].dIndex _ league.nextDIndex;
FOR team: Team IN [2..league.teamStats.size) DO
IF teams[team].dIndex=0 THEN teams[team].dIndex _ league.nextDIndex;
IF teams[team].points    <    teams[league.nextDTeam].points OR
teams[team].points     =     teams[league.nextDTeam].points AND
teams[team].dIndex      >   teams[league.nextDTeam].dIndex 
THEN league.nextDTeam _ team; ENDLOOP;
FOR team: Team IN [1..league.teamStats.size) DO
IF teams[team].dIndex=league.nextDIndex THEN teams[team].dIndex _ 0; ENDLOOP
END;
FOR type:    CARDINAL    IN [0..typeNms.size)
DO league.typeMax        _ MAX[CARD[Rope.Length[typeNms[type]]],        league.typeMax] ENDLOOP;
FOR rating:    CARDINAL    IN [0..ratingNms.size)
DO league.ratingMax    _ MAX[CARD[Rope.Length[ratingNms[rating]]],    league.ratingMax]ENDLOOP;
FOR team:    CARDINAL    IN [0..teamNms.size)
DO league.teamMax        _ MAX[CARD[Rope.Length[teamNms[team]]],        league.teamMax] ENDLOOP;    
FOR paid:        CARDINAL    IN [0..paidNms.size)
DO league.paidMax        _ MAX[CARD[Rope.Length[paidNms[paid]]],        league.paidMax] ENDLOOP;
FOR group:    CARDINAL    IN [0..groupNms.size)
DO league.groupMax    _ MAX[CARD[Rope.Length[groupNms[group]]],    league.groupMax] ENDLOOP;
FOR shirt:    CARDINAL    IN [0..shirtNms.size)
DO league.shirtMax        _ MAX[CARD[Rope.Length[shirtNms[shirt]]],        league.shirtMax] ENDLOOP;
FOR pair:        CARDINAL    IN [0..pairNms.size)
DO league.pairMax        _ MAX[CARD[Rope.Length[pairNms[pair]]],        league.pairMax] ENDLOOP;
FOR sex:        CARDINAL    IN [0..sexNms.size)
DO league.sexMax        _ MAX[CARD[Rope.Length[sexNms[sex]]],        league.sexMax] ENDLOOP;
};

AutomaticMember: PROC[m: Member] RETURNS[BOOL] = {RETURN
[m.type=coach OR (m.sse#NIL AND m.sse.type=coach)]};
Protected: PROC[m: Member] RETURNS[BOOL] = {RETURN[
(m.type=player OR m.type=coach) AND m.sse#NIL AND m.sse.rating > m.rating]};
<<>>
<<Protected: PROC[m: Member] RETURNS[BOOL] = {RETURN[>>
<<m.type=player AND m.sse#NIL AND m.sse.type=coach OR>>
<<m.type=player AND m.sse#NIL AND m.sse.rating > m.rating]};>>
<<>>
<<Protected: PROC[m: Member] RETURNS[BOOL] =>>
<<{RETURN[m.type=player AND m.sse#NIL AND m.sse.type=coach]};>>

RopeSeqIndex: PUBLIC PROC[name: IO.ROPE, ropeSeq: RopeSeq] RETURNS[index: CARDINAL] = {
FOR index DECREASING IN [0..ropeSeq.size) DO
IF Rope.Compare[name, ropeSeq[index]]=equal THEN EXIT ENDLOOP };

OutJustify: PROC
[out: IO.STREAM, side: {left, right}, rope: IO.ROPE, size: CARDINAL] = {
IF rope.Length[]=0 THEN rope _ "-";
IF rope.Find[" "]#-1 THEN Signal[];
IF side=right    THEN THROUGH [0..size-rope.Length[]] DO out.PutChar[IO.SP] ENDLOOP;
out.PutRope[rope];
IF side=left    THEN THROUGH [0..size-rope.Length[]] DO out.PutChar[IO.SP] ENDLOOP };

Signal: SIGNAL = CODE;

GenRopeSeq: PROC[inStm: IO.STREAM] RETURNS[ropeSeq: RopeSeq] = {
index:     CARDINAL _ 0;
list:        LIST OF IO.ROPE _ NIL;
inStm        _ IO.RIS[ IO.GetLineRope[inStm] ];
WHILE NOT IO.EndOf[inStm]
DO list _ CONS[IO.GetTokenRope[inStm].token, list]; index _ index+1 ENDLOOP;
IF index=0 THEN RETURN[NIL];
ropeSeq _ NEW[RopeSeqRec[index]];
FOR index _ index-1, index-1 DO
ropeSeq[index] _ list.first; list _ list.rest;
IF index=0 THEN EXIT ENDLOOP };

SBTest: Commander.CommandProc = {
league: League _ ReadLeagueFile["SB87.sum", cmd.out];
WriteLeagueFiles[league, cmd.out] };

typeNms:        RopeSeq _ NEW[RopeSeqRec[4]];
ratingNms:    RopeSeq _ NEW[RopeSeqRec[6]];
teamNms:        RopeSeq _ NIL;
paidNms:        RopeSeq _ NEW[RopeSeqRec[3]];
groupNms:    RopeSeq _ NIL;
shirtNms:        RopeSeq _ NEW[RopeSeqRec[5]];
pairNms:        RopeSeq _ NEW[RopeSeqRec[3]];
sexNms:        RopeSeq _ NEW[RopeSeqRec[3]];

typeNms[0]    _ "-";
typeNms[1]    _ "coach";
typeNms[2]    _ "skeep";
typeNms[3]    _ "player";

ratingNms[0]    _ "-";
ratingNms[1]    _ "1";
ratingNms[2]    _ "2";
ratingNms[3]    _ "3";
ratingNms[4]    _ "4";
ratingNms[5]    _ "5";

paidNms[0]    _ "-";
paidNms[1]    _ "unpaid";
paidNms[2]    _ "paid";

shirtNms[0]    _ "-";
shirtNms[1]    _ "Sml";
shirtNms[2]    _ "Med";
shirtNms[3]    _ "Lrg";
shirtNms[4]    _ "XL";

sexNms[0]    _ "-";
sexNms[1]    _ "male";
sexNms[2]    _ "female";

pairNms[0]    _ "-";
pairNms[1]    _ "sgl";
pairNms[2]    _ "paired";


Commander.Register[key:"SBTest", proc: SBTest];

END.