
<<PLAOps.mesa>>
<<Copyright © 1984 by Xerox Corporation.  All rights reserved.>>
<<Last edited by Curry, April 4, 1986 2:33:25 pm PST
>>
DIRECTORY IO, Basics, BasicTime, REFBit;

PLAOps: CEDAR DEFINITIONS IMPORTS IO =
BEGIN

PLA:            TYPE = REF PLARec;
PLARec:        TYPE = RECORD [
mask,    data,    out:        REF,
time:                        BasicTime.GMT,
termList:                    TermList,
term:                        Term,
validTerm:                BOOL _ FALSE ]; -- for caching reads

BoolExpr:            TYPE = TermList;    --  only inputs inportant - all outs are true

Format:            TYPE = REFBit.Format;
FormatSeq:        TYPE = REFBit.FormatSeq;
FormatRec:        TYPE = REFBit.FormatRec;

TermListSeq:        TYPE = REF TermListSeqRec;
TermListSeqRec:    TYPE = RECORD[SEQUENCE size: CARDINAL OF TermList];
TermList:        TYPE = REF TermListRec;
TermListRec:    TYPE = RECORD[
begin:        Term _ NIL,
end:        Term _ NIL,
length:    NAT _ 0,
inBits:    NAT _ 0,
outBits:    NAT _ 0];
Term:        TYPE = REF TermRec _ NIL;
TermRec:    TYPE = RECORD [
use:    Use        _ avail,
old:    Use        _ avail,
best:    Use        _ avail,
kin:    TList        _ NIL,
kkin:    Term        _ NIL,
last:    Term        _ NIL,
next:    Term        _ NIL,
in:        QWSeq    _ NIL,
out:    QWSeq    _ NIL ];
TList:                TYPE = LIST OF Term;
TermSeqRec:        TYPE = RECORD[SEQUENCE size: CARDINAL OF Term];
UseSeqRec:        TYPE = RECORD[SEQUENCE size: CARDINAL OF Use];
Use:                TYPE = {avail, skip, used, ess, del} _ avail;
QWSeq:            TYPE = REF QWSeqRec;
QWSeqRec:        TYPE = RECORD[SEQUENCE wdSize: CARDINAL OF QrtWord];
Qrt:                TYPE = {zero, one, dontcare, undefined};
QrtWord:            TYPE = RECORD[m, d: CARDINAL];
initInQrtWdc:    QrtWord = [m:       0B, d:        0];    -- init to dontcare
initOutQrtWz:    QrtWord = [m: 177777B, d:        0];    -- init to zero
initOutQrtWo:    QrtWord = [m: 177777B, d: 177777B];    -- init to one

Trace:            BOOL;
FinishMin:    BOOL;
FinishCS:        BOOL;
Abort:            BOOL;
Aborted:                SIGNAL;
InvalidTermRope:    SIGNAL[rope: IO.ROPE];

NewPLA:        PROC [inRef, outRef: REF]                                            RETURNS[pla: PLA];
ReadPLAFile:    PROC [fileName: IO.ROPE, log: IO.STREAM_IO.noWhereStream]    RETURNS[pla: PLA];
WritePLAFile:    PROC [fileName: IO.ROPE, log: IO.STREAM_IO.noWhereStream,                pla: PLA];
PLAHeader:            PROC[pla: PLA, fileName: IO.ROPE _ NIL] RETURNS[header: IO.ROPE];
DefaultCMDLine:        PROC[cmdLine, default: IO.ROPE] RETURNS[IO.ROPE];
GetBEForDataMask:    PROC[pla: PLA]    RETURNS[be: BoolExpr];
SetOutForBE:            PROC[pla: PLA, be: BoolExpr];
GetOutForData:        PROC[pla: PLA];

CopyPLASubFields:    PROC [refPla: PLA, outRef: REF]    RETURNS[newPla: PLA];

NewTerm:        PROC[inBitSize, outBitSize: CARDINAL] RETURNS[new: Term];
CopyTerm:        PROC[ref: Term] RETURNS[new: Term];
AppendTerm:    PROC[ref: Term, list: TermList];
ACopy:            PROC[ref: Term, list: TermList];    -- only if significant
DeleteTerm:    PROC[old: Term, list: TermList];
SaveTerm:        PROC[old: Term] = INLINE {old.next _ SavedTerms; SavedTerms _ old };
SaveListTerms: PROC[list: TermList] = INLINE {
IF list.end = NIL OR list.begin = NIL THEN RETURN;
list.end.next_SavedTerms; SavedTerms_list.begin; list.begin_list.end_NIL; list.length_0};
SavedTerms: Term;

AndTrue:    TermList;            -- Only used as default arg for And
OrFalse:    TermList = NIL;    -- Only used as default arg for Or

Intersection: PROC[ref, test, intersection: Term] RETURNS[valid: BOOL];
Add:    PROC[tl1, tl2, tl3, tl4, tl5:    TermList _ NIL            ] RETURNS[new: TermList];
And:    PROC[tl1, tl2, tl3, tl4, tl5:    TermList _ AndTrue    ] RETURNS[new: TermList];
Or:    PROC[tl1, tl2, tl3, tl4, tl5:    TermList _ OrFalse        ] RETURNS[new: TermList];
Not:    PROC[tl:                        TermList                    ] RETURNS[new: TermList];

SetInQrt:    PROC[q: Qrt, t: Term, index: CARDINAL];
SetOutQrt:    PROC[q: Qrt, t: Term, index: CARDINAL];
GetInQrt:    PROC[term:Term, index:CARDINAL] RETURNS[q: Qrt];
GetOutQrt:    PROC[term:Term, index:CARDINAL] RETURNS[q: Qrt];

InsUsed: PROC[list: TermList] RETURNS[count:    CARDINAL];

GetTermVal:    PROC[term: Term, list: TermList];

RopeToFormat: PROC[
rope:    IO.ROPE]
RETURNS[iFormat, oFormat: Format];

RopeToTerm: PROC[
rope:            IO.ROPE,
list:            TermList,
iFormat:        Format _ NIL,
oFormat:        Format _ NIL]
RETURNS[term: Term];

TermToRope: PROC[
term:            Term,
list:            TermList,
showUse:        BOOL _ FALSE,
iFormat:        Format _ NIL,
oFormat:        Format _ NIL]
RETURNS[rope: IO.ROPE];

CopyTermList: PROC[
list:        TermList,
firstOut:    CARDINAL _ 0,
lastOut:    CARDINAL _ 177777B]
RETURNS[newList: TermList];

CopyTermListForField: PROC[
list:        TermList,
firstBit:    CARDINAL, 
bitSize:    CARDINAL ]
RETURNS[newList: TermList];

ListTermList: PROC[
list:            TermList,
showUse:        BOOL _ FALSE,
omitDeletes:    BOOL _ FALSE,
log:            IO.STREAM _ IO.noWhereStream,
iFormat:        Format _ NIL,
oFormat:        Format _ NIL];

SortTermList: PROC[
list:        TermList,
bigFirst:    BOOL _ TRUE];

ConvertTermListToCompleteSum: PROC[
list:                TermList,
addMerges:        BOOL,
addConsensus:    BOOL,
log:                IO.STREAM _ IO.noWhereStream]
RETURNS[unfinished: BOOL];

UpdateCompleteSumWithTerm: PROC [
sum:                TermList,
term:                Term,
addMerges:        BOOL,
addConsensus:    BOOL,
log:                IO.STREAM _ IO.noWhereStream]
RETURNS[unfinished: BOOL];

FindAMinimalCover: PROC[
list:    TermList,
time:    CARDINAL,
log:    IO.STREAM _ IO.noWhereStream]
RETURNS[initEss, initDel, bestCov: CARDINAL, unfinished: BOOL];
TimeOut:        PROC[minutes: CARDINAL];
TimeOutReset:    PROC;
TimeOutQuit:    PROC;


END.