DIRECTORY
AMBridge, AMTypes, Atom, Convert, IO, Rope, UserExec, VFonts, ViewRec;


ViewRecAux: CEDAR PROGRAM
IMPORTS AMBridge, AMTypes, Atom, Convert, IO, Rope, UserExec, VF:VFonts, ViewRec
EXPORTS ViewRec =

BEGIN OPEN ViewRec;

EnumData: TYPE = REF EnumDataRep;
EnumDataRep: TYPE = RECORD [
wideType: Type];

enumerationHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseEnumeration,
UnParse: UnParseEnumeration,
Max: MaxEnumeration,
Butt: ButtEnumeration,
blueDoc: "Shift Blue => previous member of enumeration,
Not-Shift Blue => next member of enumeration,\n"]];

ParseEnumeration: ParseProc =
BEGIN
ed: EnumData _ NARROW[handlerData];
new: TypedVariable;
index: CARDINAL;
ok _ TRUE;
index _ AMTypes.NameToIndex[type: ed.wideType, name: asRope !AMTypes.Error => {ok _ FALSE; CONTINUE}];
IF NOT ok THEN {[index, ok] _ ParseCard[asRope]; index _ index+1};
IF NOT ok THEN RETURN [FALSE];
new _ AMTypes.Value[type: ed.wideType, index: index !AMTypes.Error => {ok _ FALSE; CONTINUE}];
IF ok THEN AMTypes.Assign[lhs: tv, rhs: new];
END;

ParseCard: PROC [asRope: ROPE] RETURNS [card: LONG CARDINAL, ok: BOOLEAN] =
BEGIN
v: Convert.Value;
stopPlace: INT;
TRUSTED {[v, stopPlace] _ Convert.Parse[text: [rope[asRope]], template: Convert.DefaultUnsigned]};
IF stopPlace < asRope.Length[] THEN RETURN [0, FALSE];
WITH v SELECT FROM
unsigned => RETURN [unsigned, TRUE];
ENDCASE => RETURN [0, FALSE];
END;

UnParseEnumeration: UnParseProc =
BEGIN
asRope _ MyTVToName[tv];
END;

MyTVToName: PROC [et: AMTypes.TypedVariable --of an enumerated type--]
RETURNS [r: ROPE] =
BEGIN
r _ AMTypes.TVToName[et !AMTypes.Error =>
TRUSTED {r _ IO.PutFR["%g", IO.card[AMBridge.TVToCardinal[et]]];
CONTINUE}];
END;

MaxEnumeration: MaxProc =
BEGIN
maxWidthNeeded _ 20;
FOR tv _ AMTypes.First[targType], AMTypes.Next[tv] WHILE tv # NIL DO
maxWidthNeeded _ MAX[maxWidthNeeded, VF.StringWidth[AMTypes.TVToName[tv !AMTypes.Error => EXIT]]];
ENDLOOP;
END;

ButtEnumeration: ButtProc =
BEGIN
IF shift THEN new _ EnumPrev[tv, targType] ELSE IF (new _ AMTypes.Next[tv]) = NIL THEN new _ AMTypes.First[targType];
END;

EnumPrev: PROC [of: TypedVariable, type: Type] RETURNS [is: TypedVariable] =
BEGIN
is _ AMTypes.First[type];
WHILE is # NIL DO
next: TypedVariable _ AMTypes.Next[is];
IF AMTypes.TVEqual[next, of] THEN RETURN;
is _ next;
ENDLOOP;
is _ AMTypes.Last[type];
END;

RecognizeEnumerations: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN
BEGIN
ed: EnumData _ NEW [EnumDataRep _ [
wideType: AMTypes.GroundStar[t] ]];
handler _ enumerationHandler;
handlerData _ ed;
END;
IKnowYou _ TRUE;
END;

NumData: TYPE = REF NumDataRep;
NumDataRep: TYPE = RECORD [
typeClass: AMTypes.Class,
cvt: ConvertProc,
parseTemplate: Convert.Value,
tempAsTV: TypedVariable _ NIL,
tempAsRef: REF ANY];

ConvertProc: TYPE = PROC [nd: NumData, v: Convert.Value]
RETURNS [ok: BOOLEAN];

numHandlerDatas: ARRAY AMTypes.Class OF NumData _ ALL[NIL];

numberHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseNumber,
UnParse: UnParseNumber,
Max: MaxNumber,
Butt: NIL]];

ParseNumber: ParseProc =
BEGIN
nd: NumData _ NARROW[handlerData];
v: Convert.Value;
stopPlace: INT;
TRUSTED {[v, stopPlace] _ Convert.Parse[text: [rope[asRope]], template: nd.parseTemplate]};
IF stopPlace < asRope.Length[] THEN RETURN [FALSE];
IF (ok _ nd.cvt[nd, v]) THEN
BEGIN
AMTypes.Assign[tv, nd.tempAsTV !AMTypes.Error =>
{ok _ FALSE; CONTINUE}];
END;
END;

ToC: ConvertProc =
BEGIN
c: REF CARDINAL _ NARROW[nd.tempAsRef];
WITH v SELECT FROM
unsigned => IF (ok _ unsigned IN [0..65536)) THEN c^ _ unsigned;
signed => IF (ok _ signed IN [0..65536)) THEN c^ _ signed;
ENDCASE => ok _ FALSE;
END;

ToI: ConvertProc =
BEGIN
i: REF INTEGER _ NARROW[nd.tempAsRef];
WITH v SELECT FROM
unsigned => IF (ok _ unsigned IN [0..32768)) THEN i^ _ unsigned;
signed => IF (ok _ (((ABS[signed] = 32768) AND (signed < 0)) OR (ABS[signed] <= 32767))) THEN i^ _ signed;
ENDCASE => ok _ FALSE;
END;

ToLC: ConvertProc =
BEGIN
c: REF LONG CARDINAL _ NARROW[nd.tempAsRef];
WITH v SELECT FROM
unsigned => {ok _ TRUE; c^ _ unsigned};
signed => IF (ok _ signed >= 0) THEN c^ _ signed;
ENDCASE => ok _ FALSE;
END;

ToLI: ConvertProc =
BEGIN
i: REF LONG INTEGER _ NARROW[nd.tempAsRef];
limit: LONG CARDINAL = LAST[LONG INTEGER];
WITH v SELECT FROM
unsigned => IF (ok _ unsigned <= limit) THEN
i^ _ unsigned;
signed => {ok _ TRUE; i^ _ signed};
ENDCASE => ok _ FALSE;
END;

ToR: ConvertProc =
BEGIN
r: REF REAL _ NARROW[nd.tempAsRef];
WITH v SELECT FROM
real => {r^ _ real; ok _ TRUE};
ENDCASE => ok _ FALSE;
END;

UnParseNumber: UnParseProc =
BEGIN
nd: NumData _ NARROW[handlerData];
AMTypes.Assign[nd.tempAsTV, tv];
BEGIN
v: Convert.Value _ SELECT nd.typeClass FROM
cardinal => [unsigned[NARROW[nd.tempAsRef, REF CARDINAL]^]],
integer => [signed[NARROW[nd.tempAsRef, REF INTEGER]^]],
longCardinal => [unsigned[NARROW[nd.tempAsRef, REF LONG CARDINAL]^]],
longInteger => [signed[NARROW[nd.tempAsRef, REF INT]^]],
real => [real[NARROW[nd.tempAsRef, REF REAL]^]],
ENDCASE => ERROR;
RETURN [Convert.ValueToRope[v]];
END;
END;

MaxNumber: MaxProc =
BEGIN
nd: NumData _ NARROW[handlerData];
maxWidthNeeded _ VF.StringWidth[SELECT nd.typeClass FROM
cardinal => "65,536",
integer => "-29,860",
longCardinal => "0,123,456,789",
longInteger => "-0,123,456,789",
real => "-3.456789E-29",
ENDCASE => ERROR];
END;

RecognizeNumber: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN
BEGIN
wt: Type _ AMTypes.GroundStar[t];
tc: AMTypes.Class _ AMTypes.TypeClass[wt];
handler _ numberHandler;
handlerData _ numHandlerDatas[tc];
END;
IKnowYou _ TRUE;
END;

ropeHandler: SimpleHandler _ NEW [SimpleHandlerRep _ [
Parse: ParseRope,
UnParse: UnParseRope,
Max: MaxRope,
Butt: NIL]];

ParseRope: ParseProc = TRUSTED
BEGIN
asTV: TypedVariable _ AMBridge.TVForROPE[asRope];
ok _ TRUE;
AMTypes.Assign[tv, asTV !AMTypes.Error => {ok _ FALSE; CONTINUE}];
END;

UnParseRope: UnParseProc =
BEGIN
asRope _ AMTypes.TVToName[tv];
END;

MaxRope: MaxProc = {RETURN [1024, 2]};

RecognizeRope: PUBLIC Recognizer =
BEGIN
IF NOT onlyRecognize THEN {handler _ ropeHandler; handlerData _ NIL};
IKnowYou _ TRUE;
END;

Setup: PROC =
BEGIN
countAsAny: REF ANY;

numHandlerDatas[cardinal] _ NEW [NumDataRep _ [typeClass: cardinal, cvt: ToC, parseTemplate: Convert.DefaultUnsigned, tempAsRef: NEW [CARDINAL] ]];
numHandlerDatas[integer] _ NEW [NumDataRep _ [typeClass: integer, cvt: ToI, parseTemplate: Convert.DefaultSigned, tempAsRef: NEW [INTEGER] ]];
numHandlerDatas[longCardinal] _ NEW [NumDataRep _ [typeClass: longCardinal, cvt: ToLC, parseTemplate: Convert.DefaultUnsigned, tempAsRef: NEW [LONG CARDINAL] ]];
numHandlerDatas[longInteger] _ NEW [NumDataRep _ [typeClass: longInteger, cvt: ToLI, parseTemplate: Convert.DefaultSigned, tempAsRef: NEW [LONG INTEGER] ]];
numHandlerDatas[real] _ NEW [NumDataRep _ [typeClass: real, cvt: ToR, parseTemplate: Convert.DefaultReal, tempAsRef: NEW [REAL] ]];

FOR c: AMTypes.Class IN AMTypes.Class DO
TRUSTED {
IF numHandlerDatas[c] # NIL THEN numHandlerDatas[c].tempAsTV _ AMBridge.TVForReferent[numHandlerDatas[c].tempAsRef]};
ENDLOOP;

RegisterRecognizerByType[r: RecognizeEnumerations, end: Back, type: CODE[ViewRec.AddPlace], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[INTEGER], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[CARDINAL], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[LONG INTEGER], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[LONG CARDINAL], reductions: TypeClass];
RegisterRecognizerByType[r: RecognizeNumber, end: Back, type: CODE[REAL], reductions: TypeClass];

RegisterRecognizerByType[r: RecognizeRope, end: Back, type: CODE[ROPE], reductions: TypeClass];

countAsAny _ Atom.GetProp[atom: $ViewRecCount, prop: $ViewRecCount];
IF countAsAny = NIL THEN
Atom.PutProp[atom: $ViewRecCount, prop: $ViewRecCount, val: NEW [INT _ 1]]
ELSE BEGIN
ri: REF INT _ NARROW[countAsAny];
eh: UserExec.ExecHandle _ UserExec.GetExecHandle[];
ri^ _ ri^ + 1;
eh.GetStreams[].out.PutF[
"ViewRec has been loaded %g times!
Confusion is likely to result.
I recommend you rollback and do things right.", IO.int[ri^]];
END;
END;

Setup[];

END.
zViewRecAux.Mesa
Last Edited by: Spreitzer, March 10, 1983 4:55 pm
Last Edited by: Maxwell, March 11, 1983 10:56 am
Κ
φ˜J™J™1J™0
codeš
Οk	˜	Kšœ"œ"˜F—K˜K˜šΠbx
œ
˜Kšœ#œœ˜PKšœ
˜—K˜Kšœ
œ	˜K˜Kšœ
œœ
˜!šœ
œœ˜Kš
œ˜—K˜šœ$œ˜=K˜K˜K˜K˜˜7K˜3——K˜šΟnœ
˜Kš
˜Kšœœ˜#K˜Kšœœ
˜Kšœœ
˜
KšœTœœ˜fKšœ
œœ4˜BKš
œ
œœ
œœ˜KšœLœœ˜^Kšœœ#˜-Kšœ
˜—K˜šŸ	œœ
œœœ
œœ˜KKš
˜K˜Kšœœ
˜Kšœ[˜bKšœœ
œœ˜6šœœ
˜Kšœœœ˜$Kšœœœ˜—Kšœ
˜—K˜šŸœ˜!Kš
˜Kš
œ˜Kšœ
˜—K˜šŸ
œœΟcœ
˜FKšœœ˜Kš
˜˜)Kšœœ
œ"˜@Kšœ˜—Kšœ
˜—K˜šŸœ˜Kš
˜K˜šœ0œœ
˜DKšœœœ3œ˜bKšœ
˜—Kšœ
˜—K˜šŸœ˜Kš
˜Kšœœœ
œœ
œ˜uKšœ
˜—K˜šŸœœ!œ˜LKš
˜K˜šœœ
˜K˜'Kšœœ
œ
˜)K˜
Kšœ
˜—K˜Kšœ
˜K˜—šŸœœ
˜*Kš
˜šœ
œ˜Kš
˜šœœ˜#Kš
œ#˜#—K˜K˜Kšœ
˜—Kšœœ
˜Kšœ
˜—K˜Kšœ	œœ˜šœœœ˜K˜K˜K˜Kšœœ
˜Kšœœ
œ˜—K˜šŸœœœ ˜8Kšœœ˜—K˜Kš	œœœœ
œ˜;K˜šœœ˜8K˜K˜K˜Kšœœ˜—K˜šŸœ
˜Kš
˜K˜"K˜K˜KšœT˜[K˜3šœ˜Kš
˜š
œ0˜0Kšœœœ˜—Kšœ
˜—Kšœ
˜—K˜šŸœ˜Kš
˜Kšœœ
œœ˜'šœœ
˜Kšœœœ
œ˜@Kšœ
œœ
œ
˜:Kšœ	œ
˜—Kšœ
˜K˜—šŸœ˜Kš
˜Kšœœ
œœ˜&šœœ
˜Kšœœœ
œ˜@Kš
œ
œ
œœœœœ
˜jKšœ	œ
˜—Kšœ
˜K˜—šŸœ˜Kš
˜Kš	œœ
œ
œœ˜,šœœ
˜Kšœœ˜'Kšœ
œœ
˜1Kšœ	œ
˜—Kšœ
˜K˜—šŸœ˜Kš
˜Kš	œœ
œ
œœ˜+Kšœœ
œœ
œ
œ˜*šœœ
˜šœœ˜,K˜—Kšœœ˜#Kšœ	œ
˜—Kšœ
˜K˜—šŸœ˜Kš
˜Kšœœ
œœ˜#šœœ
˜Kšœœ˜Kšœ	œ
˜—Kšœ
˜—K˜šŸ
œ˜Kš
˜Kšœœ˜"˜ Kš
˜šœœ˜+Kšœœœ
œ˜<Kšœœœ
œ˜8Kš	œœœ
œ
œ˜EKšœœœ
œ˜8Kšœœœ
œ˜0Kšœœ
˜—Kšœ˜ Kšœ
˜—Kšœ
˜—K˜šŸ	œ˜Kš
˜Kšœœ˜"šœœ
œ˜8K˜K˜K˜ K˜ K˜Kšœœ˜—Kšœ
˜—K˜šŸœœ
˜$Kš
˜šœ
œ˜Kš
˜K˜!K˜*K˜K˜"Kšœ
˜—Kšœœ
˜Kšœ
˜—K˜šœœ˜6K˜K˜K˜
Kšœœ˜—K˜šŸ	œ˜Kš
˜K˜1Kšœœ
˜
Kšœ0œœ˜BKšœ
˜—K˜šŸœ˜Kš
˜K˜Kšœ
˜—K˜KšŸœ
œ˜&K˜šŸ
œœ
˜"Kš
˜Kšœ
œœ'œ˜EKšœœ
˜Kšœ
˜—K˜šŸœœ˜
Kš
˜Kšœœ
œ
˜K˜Kšœœbœœ˜“
Kšœœ_œœ˜Ž
Kš	œ œgœœ
œ˜‘
Kš	œœdœœ
œ˜œ
KšœœZœœ˜ƒ
K˜šœœ˜(š
	˜	Kšœœ
œU˜u—Kšœ
˜—K˜KšœDœ+˜sK˜Kšœ>œ
œ˜dKšœ>œ
œ˜eKšœ>œ
œ
œ˜iKšœ>œ
œ
œ˜jKšœ>œ
œ˜aK˜Kšœ<œ
œ˜_K˜K˜Dšœœ
˜Kšœ<œœ˜J—šœ
˜
Kšœœ
œœ
˜!K˜3K˜˜K˜"K˜Kšœ0œ˜=—Kšœ
˜—Kšœ
˜—K˜K˜K˜Kšœ
˜—…— D+΄