DIRECTORY
Basics USING [BYTE, bytesPerWord],
CountedVM USING [Allocate, Handle],
FS USING [OpenFile, StreamFromOpenFile],
Imager USING [Context, MaskFill],
ImagerFont USING [CorrectionType, Extents, nullXChar, XChar],
ImagerPath USING [PathProc],
ImagerTypeface USING [Register, Typeface, TypefaceClass, TypefaceClassRep, TypefaceRep],
IO USING [Close, SetIndex, STREAM, UnsafeGetBlock],
PrePressFontFormat USING [CardFromBcpl, DirectoryArray, IntFromBcpl, IXHeader, missingFilePos, missingSpline, NameIndexEntry, RelFilePos, SplineCode, SplineCommand, SplineCoords, SplineData, SplineDataArray, StdIndexEntry],
RealConvert USING [BcplToIeee],
Vector2 USING [Add, Div, VEC];

ImagerSDTypefaceImpl: CEDAR PROGRAM
IMPORTS CountedVM, FS, Imager, ImagerTypeface, IO, PrePressFontFormat, RealConvert, Vector2
~ BEGIN OPEN ImagerTypeface, ImagerFont;

BYTE: TYPE ~ Basics.BYTE;
VEC: TYPE ~ Vector2.VEC;

Data: TYPE ~ REF DataRep;
DataRep: TYPE ~ RECORD[
bc, ec: BYTE _ 0,
splineData: LONG POINTER TO PrePressFontFormat.SplineDataArray _ NIL,
directory: LONG POINTER TO PrePressFontFormat.DirectoryArray _ NIL,
vm: CountedVM.Handle _ NIL
];


MalformedSDFont: ERROR ~ CODE;

ReadWords: UNSAFE PROC [stream: IO.STREAM, base: LONG POINTER, words: INT] ~ UNCHECKED {
count: INT ~ words*Basics.bytesPerWord;
IF IO.UnsafeGetBlock[stream, [base: LOOPHOLE[base], count: count]]=count THEN NULL
ELSE ERROR MalformedSDFont; -- data too short
};

SDCreate: PROC [file: FS.OpenFile] RETURNS [Typeface] ~ {
OPEN PrePressFontFormat;
stream: IO.STREAM ~ FS.StreamFromOpenFile[file];
data: Data ~ NEW[DataRep _ []];
ix: IXHeader;
ixSize: NAT ~ SIZE[IXHeader];
name: NameIndexEntry;
index: StdIndexEntry;
nameFound, indexFound: BOOL _ FALSE;
segmentIndex, segmentWords: INT _ 0;
DO -- read the index part
TRUSTED { ReadWords[stream, @ix, SIZE[IXHeader]] };
SELECT ix.type FROM
end => EXIT;
name => {
IF nameFound THEN ERROR MalformedSDFont; -- more than one name entry
IF (ix.length-ixSize)=SIZE[NameIndexEntry] THEN TRUSTED {
ReadWords[stream, @name, SIZE[NameIndexEntry]] }
ELSE ERROR MalformedSDFont; -- wrong ix.length
nameFound _ TRUE;
};
spline => {
IF indexFound THEN ERROR MalformedSDFont; -- more than one char index entry
IF (ix.length-ixSize)=SIZE[StdIndexEntry] THEN TRUSTED {
ReadWords[stream, @index, SIZE[StdIndexEntry]] }
ELSE ERROR MalformedSDFont; -- wrong ix.length
indexFound _ TRUE;
};
ENDCASE => ERROR MalformedSDFont; -- unexpected ix type
ENDLOOP;
IF nameFound AND indexFound AND name.code=index.family THEN NULL
ELSE ERROR MalformedSDFont; -- index part has wrong form
IF index.bc>index.ec THEN ERROR MalformedSDFont; -- bc exceeds ec
data.bc _ index.bc; data.ec _ index.ec;
segmentIndex _ CardFromBcpl[index.segmentSA]; -- in words!
segmentWords _ CardFromBcpl[index.segmentLength];
data.vm _ CountedVM.Allocate[words: segmentWords];
IO.SetIndex[stream, segmentIndex*Basics.bytesPerWord];
TRUSTED { -- read segment
base: LONG POINTER ~ data.vm.pointer;
ReadWords[stream, base, segmentWords];
data.splineData _ LOOPHOLE[base];
data.directory _ LOOPHOLE[base+SIZE[SplineDataArray[index.ec-index.bc+1]]];
};
IO.Close[stream];
RETURN[NEW[TypefaceRep _ [class: sdClass, data: data]]];
};


SDContains: PROC [self: Typeface, char: XChar] RETURNS [BOOL] ~ {
data: Data ~ NARROW[self.data];
IF char.set=0 AND char.code IN[data.bc..data.ec] THEN {
index: NAT ~ char.code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
RETURN[sd.wx#PrePressFontFormat.missingSpline];
};
RETURN[FALSE];
};

SDNextChar: PROC [self: Typeface, char: XChar] RETURNS [next: XChar] ~ {
data: Data ~ NARROW[self.data];
start: BYTE _ 0;
IF char=nullXChar THEN NULL
ELSE IF char.set=0 AND char.code<data.ec THEN start _ char.code+1
ELSE RETURN[nullXChar];
FOR code: BYTE IN[MAX[data.bc, start]..data.ec] DO
index: NAT ~ code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
IF sd.wx#PrePressFontFormat.missingSpline THEN RETURN[[set: 0, code: code]];
ENDLOOP;
RETURN[nullXChar];
};

SDWidth: PROC [self: Typeface, char: XChar] RETURNS [VEC] ~ {
data: Data ~ NARROW[self.data];
IF char.set=0 AND char.code IN[data.bc..data.ec] THEN {
index: NAT ~ char.code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
IF sd.wx#PrePressFontFormat.missingSpline THEN {
wx: REAL ~ RealConvert.BcplToIeee[sd.wx];
wy: REAL ~ RealConvert.BcplToIeee[sd.wy];
RETURN[[wx, wy]];
};
};
RETURN[[0, 0]];
};

SDAmplified: PROC [self: Typeface, char: XChar] RETURNS [BOOL] ~ {
RETURN[char.set=0 AND char.code=40B];
};

SDCorrection: PROC [self: Typeface, char: XChar] RETURNS [CorrectionType] ~ {
data: Data ~ NARROW[self.data];
IF char.set=0 AND char.code IN[data.bc..data.ec] THEN {
IF char.code=40B THEN RETURN[space] ELSE RETURN[mask];
};
RETURN[none];
};

SDBoundingBox: PROC [self: Typeface, char: XChar] RETURNS [Extents] ~ {
data: Data ~ NARROW[self.data];
IF char.set=0 AND char.code IN[data.bc..data.ec] THEN {
index: NAT ~ char.code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
IF sd.wx#PrePressFontFormat.missingSpline THEN {
xmin: REAL ~ RealConvert.BcplToIeee[sd.xmin];
ymin: REAL ~ RealConvert.BcplToIeee[sd.ymin];
xmax: REAL ~ RealConvert.BcplToIeee[sd.xmax];
ymax: REAL ~ RealConvert.BcplToIeee[sd.ymax];
RETURN[[leftExtent: -xmin, rightExtent: xmax, descent: -ymin, ascent: ymax]];
};
};
RETURN[[0, 0, 0, 0]];
};

SDFontBoundingBox: PROC [self: Typeface] RETURNS [Extents] ~ {
data: Data ~ NARROW[self.data];
count: NAT _ 0;
fxmin, fymin, fxmax, fymax: REAL _ 0;
FOR code: BYTE IN[data.bc..data.ec] DO
index: NAT ~ code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
IF sd.wx#PrePressFontFormat.missingSpline THEN {
xmin: REAL ~ RealConvert.BcplToIeee[sd.xmin];
ymin: REAL ~ RealConvert.BcplToIeee[sd.ymin];
xmax: REAL ~ RealConvert.BcplToIeee[sd.xmax];
ymax: REAL ~ RealConvert.BcplToIeee[sd.ymax];
IF count=0 THEN { fxmin _ xmin; fymin _ ymin; fxmax _ xmax; fymax _ ymax }
ELSE {
IF xmin<fxmin THEN fxmin _ xmin;
IF ymin<fymin THEN fymin _ ymin;
IF xmax>fxmax THEN fxmax _ xmax;
IF ymax>fymax THEN fymax _ ymax;
};
count _ count+1;
};
ENDLOOP;
RETURN[[leftExtent: -fxmin, rightExtent: fxmax, descent: -fymin, ascent: fymax]];
};

SDKern: PROC [self: Typeface, char, successor: XChar] RETURNS [VEC] ~ {
RETURN[[0, 0]];
};

SDNextKern: PROC [self: Typeface, char, successor: XChar] RETURNS [XChar] ~ {
RETURN[nullXChar];
};

SDLigature: PROC [self: Typeface, char, successor: XChar] RETURNS [XChar] ~ {
RETURN[nullXChar];
};

SDNextLigature: PROC [self: Typeface, char, successor: XChar] RETURNS [XChar] ~ {
RETURN[nullXChar];
};

SDMask: PROC [self: Typeface, char: XChar, context: Imager.Context] ~ {
data: Data ~ NARROW[self.data];
IF char.set=0 AND char.code IN[data.bc..data.ec] THEN {
index: NAT ~ char.code-data.bc;
sd: PrePressFontFormat.SplineData;
TRUSTED { sd _ data.splineData[index] };
IF sd.wx#PrePressFontFormat.missingSpline THEN {
base: LONG POINTER _ NIL;
path: ImagerPath.PathProc ~ {
next: LONG POINTER _ base;
lp: VEC _ [0, 0];
GetCode: PROC RETURNS [PrePressFontFormat.SplineCode] ~ TRUSTED {
p: LONG POINTER TO PrePressFontFormat.SplineCommand ~ LOOPHOLE[next];
next _ next+SIZE[PrePressFontFormat.SplineCommand];
RETURN[p.code];
};
GetCoords: PROC RETURNS [VEC] ~ TRUSTED {
p: LONG POINTER TO PrePressFontFormat.SplineCoords ~ LOOPHOLE[next];
next _ next+SIZE[PrePressFontFormat.SplineCoords];
RETURN[[RealConvert.BcplToIeee[p.x], RealConvert.BcplToIeee[p.y]]];
};
DO SELECT GetCode[] FROM
$moveTo => {
p: VEC ~ GetCoords[];
moveTo[p];
lp _ p;
};
$drawTo => {
p: VEC ~ GetCoords[];
lineTo[p];
lp _ p;
};
$drawCurve => {
c1: VEC ~ GetCoords[];
c2: VEC ~ GetCoords[];
c3: VEC ~ GetCoords[];
b1: VEC ~ lp.Add[c1.Div[3]];
b2: VEC ~ b1.Add[c1.Add[c2].Div[3]];
b3: VEC ~ lp.Add[c1].Add[c2].Add[c3];
curveTo[b1, b2, b3];
lp _ b3;
};
$endDefinition => EXIT;
$newObject => ERROR MalformedSDFont; -- not implemented
ENDCASE => ERROR MalformedSDFont; -- undefined
ENDLOOP;
};
TRUSTED {
filePos: PrePressFontFormat.RelFilePos ~ data.directory[index];
offset: INT ~ PrePressFontFormat.IntFromBcpl[filePos];
IF filePos=PrePressFontFormat.missingFilePos THEN ERROR MalformedSDFont;
base _ LOOPHOLE[data.directory+offset];
};
Imager.MaskFill[context: context, path: path, parity: TRUE];
};
};
};


sdClass: TypefaceClass ~ NEW[TypefaceClassRep _ [
type: $SD,
Contains: SDContains,
NextChar: SDNextChar,
Width: SDWidth,
Amplified: SDAmplified,
Correction: SDCorrection,
BoundingBox: SDBoundingBox,
FontBoundingBox: SDFontBoundingBox,
Ligature: SDLigature,
NextLigature: SDNextLigature,
Kern: SDKern,
NextKern: SDNextKern,
Mask: SDMask
]];

ImagerTypeface.Register["SD", SDCreate];

END.
ΐImagerSDTypefaceImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Doug Wyatt, May 29, 1985 10:39:42 am PDT

{ -- convert name to rope
i: NAT _ 0; p: PROC RETURNS [CHAR] ~ { RETURN[VAL[name.chars[i _ i+1]]] };
family _ Rope.FromProc[len: name.chars[0], p: p];
};
SDRegister: PROC ~ {
scratch: REF TEXT ~ NEW[TEXT[200]];
DoName: FS.NameProc ~ {
cp: FS.ComponentPositions; start, stop: INT;
text: REF TEXT _ scratch;
[fullFName: fullFName, cp: cp] _ FS.ExpandName[fullFName];
start _ cp.subDirs.start; stop _ cp.base.start+cp.base.length;
text.length _ 0;
text _ RefText.AppendRope[to: text, from: "Xerox/PressFonts/"];
text _ RefText.AppendRope[to: text, from: fullFName, start: start, len: stop-start];
FOR i: NAT IN[0..text.length) DO IF text[i]='> THEN text[i] _ '/ ENDLOOP;
Register[name: Rope.FromRefText[text], fileName: fullFName, create: SDCreate];
RETURN[continue: TRUE];
};
FS.EnumerateForNames[pattern: "[Indigo]<PressFonts>*.sd!H", proc: DoName];
Alias["Xerox/XC82-0-0/Classic", "Xerox/PressFonts/Classic-MRR"];
Alias["Xerox/XC82-0-0/Classic-Bold", "Xerox/PressFonts/Classic-BRR"];
Alias["Xerox/XC82-0-0/Classic-Italic", "Xerox/PressFonts/Classic-MIR"];
Alias["Xerox/XC82-0-0/Modern", "Xerox/PressFonts/Modern-MRR"];
Alias["Xerox/XC82-0-0/Modern-Bold", "Xerox/PressFonts/Modern-BRR"];
Alias["Xerox/XC82-0-0/Modern-Italic", "Xerox/PressFonts/Modern-MIR"];
Alias["Xerox/XC82-0-0/Logotypes-Xerox", "Xerox/PressFonts/LOGO-MRR"];
};

Κ\˜
codeš
œ™Kšœ
Οm
œ7™BK™(—K™š
Οk	˜	Kšœžœžœ˜"Kšœ
žœ˜#Kšžœ
žœ ˜(Kšœžœ˜!Kšœžœ-˜=Kšœžœ˜KšœžœD˜XKšžœ
žœžœ˜3KšœžœΗ
˜ί
Kšœžœ˜Kšœžœžœ˜—K˜KšΠblœžœ
ž˜#Kšžœžœžœ*˜[Kšœžœ
žœ˜(K˜Kšžœžœ
žœ
˜Kšžœžœžœ
˜K˜Kšœžœžœ	˜šœ	žœžœ
˜Kšœžœ˜Kš	œžœ
žœ
žœ&žœ
˜EKš	œžœ
žœ
žœ%žœ
˜CKšœž˜K˜K˜—K˜Kšœžœžœ
˜K˜šΟn	œžœ
žœ
žœ
žœžœ
žœ	žœž	œ˜XKšœžœ˜'Kš	žœ
žœžœžœ
ž˜RKšžœ
žœΟc˜-K˜K˜—š œžœžœžœ˜9Kšžœ˜Kšœžœ
žœžœ˜0Kšœ
žœ˜K˜
Kšœžœžœ˜Kš
œ˜Kš
œ˜Kšœžœžœ
˜$Kšœžœ˜$šžœ
‘˜Kšžœžœ˜3šžœ	ž˜Kšœžœ
˜š
œ	˜	Kšžœžœ
žœ‘˜Dšžœžœžœ
žœ˜9Kšœžœ˜0—Kšžœ
žœ‘˜.šœ‘™Kš
œžœ	žœ
žœžœžœ
žœ™JKš
œ1™1K™—Kšœžœ
˜K˜—š
œ˜Kšžœžœ
žœ‘!˜Kšžœžœžœ
žœ˜8Kšœžœ˜0—Kšžœ
žœ‘˜.Kšœ
žœ
˜K˜—Kšžœžœ‘˜7—Kšžœ
˜—Kš	žœžœžœžœ
ž˜@Kšžœ
žœ‘˜8Kšžœžœ
žœ‘˜AKš
œ'˜'Kšœ.‘˜:Kš
œ1˜1Kš
œ2˜2Kšžœ4˜6šžœ‘˜Kšœžœ
žœ˜%Kš
œ&˜&Kšœžœ˜!Kšœžœžœ(˜KK˜—Kšžœ˜Kšžœ
žœ.˜8K˜K˜—K˜š 
œžœžœžœ˜AKšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ"˜"Kšžœ!˜(Kšžœ)˜/K˜—Kšžœ
žœ˜K˜K˜—š 
œžœžœ˜HKšœ
žœ˜Kšœžœ˜Kšžœžœ
ž˜Kšžœ
žœžœžœ˜AKšžœ
žœ˜š	žœžœ
žœ
žœž˜2Kšœžœ˜Kš
œ"˜"Kšžœ!˜(Kšžœ(žœ
žœ˜LKšžœ
˜—Kšžœ˜K˜K˜—š œžœžœžœ˜=Kšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ"˜"Kšžœ!˜(šžœ(žœ˜0Kšœžœ!˜)Kšœžœ!˜)Kšžœ˜K˜—K˜—Kšžœ	˜K˜K˜—š œžœžœžœ˜BKšžœžœ˜%K˜K˜—š œžœžœ˜MKšœ
žœ˜šžœžœžœžœ˜7Kš
žœžœ
žœžœ
žœ˜6K˜—Kšžœ˜
K˜K˜—š 
œžœžœ˜GKšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ"˜"Kšžœ!˜(šžœ(žœ˜0Kšœžœ#˜-Kšœžœ#˜-Kšœžœ#˜-Kšœžœ#˜-KšžœG˜MK˜—K˜—Kšžœ˜K˜K˜—š œžœžœ˜>Kšœ
žœ˜Kšœžœ˜Kšœžœ˜%šžœžœ
žœž˜&Kšœžœ˜Kš
œ"˜"Kšžœ!˜(šžœ(žœ˜0Kšœžœ#˜-Kšœžœ#˜-Kšœžœ#˜-Kšœžœ#˜-Kšžœ	žœ;˜Jšžœ˜Kšžœžœ˜ Kšžœžœ˜ Kšžœžœ˜ Kšžœžœ˜ K˜—K˜K˜—Kšžœ
˜—KšžœK˜QK˜K˜—š œžœ*žœžœ˜GKšžœ	˜K˜K˜—š 
œžœ*žœ˜MKšžœ˜K˜K˜—š 
œžœ*žœ˜MKšžœ˜K˜K˜—š œžœ*žœ˜QKšžœ˜K˜K˜—š œžœ;˜GKšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ"˜"Kšžœ!˜(šžœ(žœ
ž
˜0Kšœžœ
žœžœ
˜š
œ˜Kšœžœ
žœ˜Kšœžœ
˜š œžœ
žœ#žœ˜AKš	œžœ
žœ
žœ$žœ˜EKšœžœ#˜3Kšžœ	˜K˜—š
 	œžœ
žœžœžœ˜)Kš	œžœ
žœ
žœ#žœ˜DKšœžœ"˜2Kšžœ=˜CK˜—šžœ
žœž˜˜Kšœžœ˜K˜
K˜K˜—˜Kšœžœ˜K˜
K˜K˜—š
œ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜$Kšœžœ˜%K˜K˜K˜—Kšœžœ
˜Kšœžœ‘˜7Kšžœžœ‘˜.Kšžœ
˜—K˜—šžœ˜	Kš
œ?˜?Kšœžœ+˜6Kšžœ+žœ
žœ˜HKšœžœ˜'K˜—Kšœ6žœ˜<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™?Kš
œT™TKšžœžœ
žœžœ
žœžœžœ
™IK™NKšžœžœ™K™—KšžœH™JK™@K™EK™GK™>K™CK™EKš
œE™EK™K™—Kš
œ(˜(K˜Kšžœ
˜—…—"$4@