PLAOps.mesa
Copyright © 1984 by Xerox Corporation. All rights reserved.
Last edited by Curry, April 4, 1986 2:33:25 pm PST
Don Curry March 5, 1987 10:45:55 am PST
Last Edited by: Don Curry August 8, 1987 12:03:21 pm PDT
DIRECTORY IO, Basics, BasicTime, REFBit;
PLAOps: CEDAR DEFINITIONS IMPORTS IO =
BEGIN
PLA: TYPE = REF PLARec;
PLARec:
TYPE =
RECORD [
name: IO.ROPE,
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
Exp: TYPE = REF;
Trace: BOOL;
FinishMin: BOOL;
FinishCS: BOOL;
Abort: BOOL;
Aborted: SIGNAL;
InvalidTermRope: SIGNAL[rope: IO.ROPE];
NewPLA: PROC[inRef, outRef: REF, name: IO.ROPE]RETURNS[pla: PLA];
CopyPLA: PROC[old: PLA] RETURNS[new: PLA];
FlushPLACache: PROC;
WritePLA: PROC [pla: PLA, out: IO.STREAM];
WritePLAFile: PROC [pla: PLA, fileName: IO.ROPE←NIL, log: IO.STREAM ← NIL];
ReadPLAFile: PROC [name: IO.ROPE, log: IO.STREAM ← NIL, useCache: BOOL ← FALSE] RETURNS[pla: PLA];
EqualExpr: PROC[e0, e1: Exp] RETURNS[equal: BOOL];
EqualPLA: PROC[pla0, pla1: PLA] RETURNS[equal: BOOL];
EqualTerm: PROC[term0, term1: Term] RETURNS[equal: BOOL];
PLAToExpression: PROC[pla: PLA] RETURNS[exp: Exp];
ExpressionToPLA: PROC[exp: Exp] RETURNS[pla: PLA];
Factor: PROC[pla: PLA] RETURNS[mach: Exp];
FactorExpression: PROC[mach: Exp] RETURNS[newMach: Exp];
CompressExpression: PROC[mach: Exp, complete: BOOL ← FALSE] RETURNS[newMach: Exp];
PLAHeader: PROC[pla: PLA] 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];
GetOutputBE: PROC[pla: PLA, out: CARDINAL] RETURNS[be: BoolExpr];
SplitPLA: PROC[pla: PLA] RETURNS[andPla, orPla: PLA];
InvOutBits: PROC[pla: PLA, first, size: CARDINAL ← 0];
ReconfigurePLA:
PROC [refPla:
PLA, newIn, newOut:
REF]
RETURNS[newPla:
PLA];
Used to reorder input and/or ouput bits or select ouput subfields.
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𡤀};
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 ← NIL,
iFormat: Format ← NIL,
oFormat: Format ← NIL];
SortTermList:
PROC[
list: TermList,
bigFirst: BOOL ← TRUE];
FastSortTermList:
PROC[
list: TermList]
RETURNS[new: TermList];
CTCompressPLA:
PROC[pla:
PLA, complete:
BOOL ←
FALSE]
RETURNS[new: PLA]; -- Via CommandTool
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.