DIRECTORY
Basics USING [BYTE, bytesPerWord],
CountedVM USING [Allocate, Handle],
FS USING [OpenFile, StreamFromOpenFile],
Imager USING [ConcatT, Context, DoSave, MaskBits, RotateT],
ImagerFont USING [CorrectionType, Extents, nullXChar, XChar],
ImagerTransformation USING [ApplyPreRotate, Rectangle, Scale2, Transformation, TransformRectangle, TransformVec],
ImagerTypeface USING [Register, Typeface, TypefaceClass, TypefaceClassRep, TypefaceRep],
IO USING [Close, SetIndex, STREAM, UnsafeGetBlock],
PrePressFontFormat USING [CardFromBcpl, CharacterData, CharacterIndexEntry, CharDataArray, DirectoryArray, IntFromBcpl, IXHeader, missingCharacter, missingFilePos, NameIndexEntry, RasterDefn, RelFilePos],
Real USING [FScale],
Vector2 USING [VEC];

ImagerACTypefaceImpl: CEDAR PROGRAM
IMPORTS CountedVM, FS, Imager, ImagerTransformation, ImagerTypeface, IO, PrePressFontFormat, Real
~ BEGIN OPEN ImagerTypeface, ImagerFont;

BYTE: TYPE ~ [0..377B];

VEC: TYPE ~ Vector2.VEC;
Transformation: TYPE ~ ImagerTransformation.Transformation;

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

MalformedACFont: ERROR ~ CODE;

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

SetWordIndex: PROC [stream: IO.STREAM, wordIndex: INT] ~ {
index: CARDINAL ~ wordIndex*Basics.bytesPerWord;
IO.SetIndex[stream, index];
};

ACCreate: PROC [file: FS.OpenFile] RETURNS [Typeface] ~ {
data: Data ~ NEW[DataRep _ []];
stream: IO.STREAM ~ FS.StreamFromOpenFile[file];
ix: PrePressFontFormat.IXHeader;
ixSize: NAT ~ SIZE[PrePressFontFormat.IXHeader];
name: PrePressFontFormat.NameIndexEntry;
index: PrePressFontFormat.CharacterIndexEntry;
nameFound, indexFound: BOOL _ FALSE;
segmentIndex, segmentWords: INT _ 0;
charUnitsPerResolutionUnit: REAL _ 0;
pixelToChar: Transformation _ NIL;
DO -- read the index part
TRUSTED { ReadWords[stream, @ix, SIZE[PrePressFontFormat.IXHeader]] };
SELECT ix.type FROM
end => EXIT;
name => {
IF nameFound THEN ERROR MalformedACFont; -- more than one name entry
IF (ix.length-ixSize)=SIZE[PrePressFontFormat.NameIndexEntry] THEN TRUSTED {
ReadWords[stream, @name, SIZE[PrePressFontFormat.NameIndexEntry]] }
ELSE ERROR MalformedACFont; -- wrong ix.length
nameFound _ TRUE;
};
character => {
IF indexFound THEN ERROR MalformedACFont; -- more than one char index entry
IF (ix.length-ixSize)=SIZE[PrePressFontFormat.CharacterIndexEntry] THEN TRUSTED {
ReadWords[stream, @index, SIZE[PrePressFontFormat.CharacterIndexEntry]] }
ELSE ERROR MalformedACFont; -- wrong ix.length
indexFound _ TRUE;
};
ENDCASE => ERROR MalformedACFont; -- unexpected ix type
ENDLOOP;
IF nameFound AND indexFound AND name.code=index.family THEN NULL
ELSE ERROR MalformedACFont; -- index part has wrong form
IF index.bc>index.ec THEN ERROR MalformedACFont; -- bc exceeds ec
data.bc _ index.bc; data.ec _ index.ec;
segmentIndex _ PrePressFontFormat.CardFromBcpl[index.segmentSA]; -- in words!
segmentWords _ PrePressFontFormat.CardFromBcpl[index.segmentLength];
data.vm _ CountedVM.Allocate[words: segmentWords];
SetWordIndex[stream, segmentIndex];
TRUSTED { -- read segment
base: LONG POINTER ~ data.vm.pointer;
ReadWords[stream, base, segmentWords];
data.charData _ base;
data.directory _ base+SIZE[PrePressFontFormat.CharDataArray[index.ec-index.bc+1]];
};
IO.Close[stream];
charUnitsPerResolutionUnit _ 25400.0/index.size; -- units of resolution are dots per 10 inches
data.pixelToChar _ ImagerTransformation.Scale2[[
charUnitsPerResolutionUnit/index.resolutionX,
charUnitsPerResolutionUnit/index.resolutionY
]];
IF index.rotation#0 THEN data.pixelToChar.ApplyPreRotate[-index.rotation/60.0];
RETURN[NEW[TypefaceRep _ [class: acClass, data: data]]];
};

ACContains: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
RETURN[cd.bbdy#PrePressFontFormat.missingCharacter];
};
RETURN[FALSE];
};

ACNextChar: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
IF cd.bbdy#PrePressFontFormat.missingCharacter THEN RETURN[[set: 0, code: code]];
ENDLOOP;
RETURN[nullXChar];
};

ACWidth: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
IF cd.bbdy#PrePressFontFormat.missingCharacter THEN {
wx: REAL ~ Real.FScale[PrePressFontFormat.IntFromBcpl[cd.wx], -16];
wy: REAL ~ Real.FScale[PrePressFontFormat.IntFromBcpl[cd.wy], -16];
RETURN[data.pixelToChar.TransformVec[[wx, wy]]];
};
};
RETURN[[0, 0]];
};

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

ACCorrection: 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];
};

ACBoundingBox: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
IF cd.bbdy#PrePressFontFormat.missingCharacter THEN {
r: ImagerTransformation.Rectangle ~ data.pixelToChar.TransformRectangle[
[x: cd.bbox, y: cd.bboy, w: cd.bbdx, h: cd.bbdy]];
RETURN[[leftExtent: -r.x, rightExtent: r.x+r.w, descent: -r.y, ascent: r.y+r.h]];
};
};
RETURN[[0, 0, 0, 0]];
};

ACFontBoundingBox: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
IF cd.bbdy#PrePressFontFormat.missingCharacter THEN {
r: ImagerTransformation.Rectangle ~ data.pixelToChar.TransformRectangle[
[x: cd.bbox, y: cd.bboy, w: cd.bbdx, h: cd.bbdy]];
xmin: REAL ~ r.x; xmax: REAL ~ r.x+r.w;
ymin: REAL ~ r.y; ymax: REAL ~ r.y+r.w;
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]];
};

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

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

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

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

ACMask: 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;
cd: PrePressFontFormat.CharacterData;
TRUSTED { cd _ data.charData[index] };
IF cd.bbdy#PrePressFontFormat.missingCharacter THEN {
raster, lines: NAT;
base: LONG POINTER _ NIL;
TRUSTED {
defn: LONG POINTER TO PrePressFontFormat.RasterDefn _ NIL;
filePos: PrePressFontFormat.RelFilePos ~ data.directory[index];
offset: INT ~ PrePressFontFormat.IntFromBcpl[filePos];
IF filePos=PrePressFontFormat.missingFilePos THEN ERROR MalformedACFont;
defn _ LOOPHOLE[data.directory+offset];
[raster: raster, lines: lines] _ defn^;
base _ defn+SIZE[PrePressFontFormat.RasterDefn];
};
IF lines=cd.bbdx AND raster=(cd.bbdy+15)/16 THEN NULL
ELSE ERROR MalformedACFont; -- raster and bounding box inconsistent
IF cd.bbdx>0 AND cd.bbdy>0 THEN {
action: PROC ~ {
Imager.RotateT[context, 90];
Imager.ConcatT[context, data.pixelToChar];
Imager.MaskBits[context: context, base: base, wordsPerLine: raster, 
sMin: 0, fMin: 0, sSize: cd.bbdx, fSize: cd.bbdy, tx: cd.bboy, ty: -cd.bbox];
};
Imager.DoSave[context, action];
};
};
};
};

acClass: TypefaceClass ~ NEW[TypefaceClassRep _ [
type: $AC,
Contains: ACContains,
NextChar: ACNextChar,
Width: ACWidth,
Amplified: ACAmplified,
Correction: ACCorrection,
BoundingBox: ACBoundingBox,
FontBoundingBox: ACFontBoundingBox,
Ligature: ACLigature,
NextLigature: ACNextLigature,
Kern: ACKern,
NextKern: ACNextKern,
Mask: ACMask
]];

ImagerTypeface.Register["AC", ACCreate];

END.
ˆImagerACTypefaceImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Doug Wyatt, May 29, 1985 10:58:54 am PDT

Κ
Έ˜
codeš
œ™Kšœ
Οm
œ1™<K™(—K™š
Οk	˜	Kšœžœžœ˜"Kšœ
žœ˜#Kšžœ
žœ ˜(Kšœžœ/˜;Kšœžœ-˜=KšœžœW˜qKšœžœD˜XKšžœ
žœžœ˜3Kšœžœ΄
˜Μ
Kšœžœ
˜Kšœžœžœ˜—K˜KšΠblœžœ
ž˜#Kšžœžœ0žœ˜aKšœžœ
žœ˜(K˜Kšžœžœ
˜K˜Kšžœžœžœ
˜Kšœžœ'˜;K˜Kšœžœžœ	˜šœ	žœžœ
˜Kšœžœ˜Kš	œ
žœ
žœ
žœ$žœ
˜AKš	œžœ
žœ
žœ%žœ
˜CKšœžœ
˜"Kšœž˜K˜K˜—Kšœžœžœ
˜K˜šΟn	œžœ
žœ
žœ
žœžœ
žœ	žœž	œ˜XKšœžœ˜'Kšžœ
žœ:žœ
ž˜HKšžœ
žœΟc˜-K˜K˜—š
 œžœ
žœ
žœ
žœ˜:Kšœžœ!˜0Kšžœ˜K˜K˜—š œžœžœžœ˜9Kšœ
žœ˜Kšœžœ
žœžœ˜0K˜ Kšœžœžœ˜0Kš
œ(˜(Kš
œ.˜.Kšœžœžœ
˜$Kšœžœ˜$Kšœžœ˜%Kšœžœ
˜"šžœ
‘˜Kšžœžœ!˜Fšžœ	ž˜Kšœžœ
˜š
œ	˜	Kšžœžœ
žœ‘˜Dšžœžœ$žœ
žœ˜LKšœžœ&˜C—Kšžœ
žœ‘˜.Kšœžœ
˜K˜—š
œ˜Kšžœžœ
žœ‘!˜Kšžœžœ)žœ
žœ˜QKšœžœ+˜I—Kšžœ
žœ‘˜.Kšœ
žœ
˜K˜—Kšžœžœ‘˜7—Kšžœ
˜—Kš	žœžœžœžœ
ž˜@Kšžœ
žœ‘˜8Kšžœžœ
žœ‘˜AKš
œ'˜'KšœA‘˜MKš
œD˜DKš
œ2˜2Kš
œ#˜#šžœ‘˜Kšœžœ
žœ˜%Kš
œ&˜&K˜Kšœžœ8˜RK˜—Kšžœ˜Kšœ1‘-˜^š
œ0˜0Kš
œ-˜-Kš
œ,˜,Kš
œ˜—Kšžœžœ7˜OKšžœ
žœ.˜8K˜K˜—š 
œžœžœžœ˜AKšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ%˜%Kšžœ˜&Kšžœ.˜4K˜—Kšžœ
žœ˜K˜K˜—š 
œžœžœ˜HKšœ
žœ˜Kšœžœ˜Kšžœžœ
ž˜Kšžœ
žœžœžœ˜AKšžœ
žœ˜š	žœžœ
žœ
žœž˜2Kšœžœ˜Kš
œ%˜%Kšžœ˜&Kšžœ-žœ
žœ˜QKšžœ
˜—Kšžœ˜K˜K˜—š œžœžœžœ˜=Kšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ%˜%Kšžœ˜&šžœ-žœ˜5Kšœžœ;˜CKšœžœ;˜CKšžœ*˜0K˜—K˜—Kšžœ	˜K˜K˜—š œžœžœžœ˜BKšžœžœ˜%K˜K˜—š œžœžœ˜MKšœ
žœ˜šžœžœžœžœ˜7Kš
žœžœ
žœžœ
žœ˜6K˜—Kšžœ˜
K˜K˜—š 
œžœžœ˜GKšœ
žœ˜šžœžœžœžœ˜7Kšœžœ˜Kš
œ%˜%Kšžœ˜&šžœ-žœ˜5Kš
œ{˜{KšžœK˜QK˜—K˜—Kšžœ˜K˜K˜—š œžœžœ˜>Kšœ
žœ˜Kšœžœ˜Kšœžœ˜%šžœžœ
žœž˜&Kšœžœ˜Kš
œ%˜%Kšžœ˜&šžœ-žœ˜5Kš
œ{˜{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šžœ˜&šžœ-žœ˜5Kšœžœ
˜Kšœžœ
žœžœ
˜šžœ˜	Kš	œžœ
žœ
žœ!žœ
˜:Kš
œ?˜?Kšœžœ+˜6Kšžœ+žœ
žœ˜HKšœžœ˜'Kš
œ'˜'Kšœžœ ˜0K˜—Kšžœžœžœ
ž˜5Kšžœ
žœ‘'˜Cšžœžœžœ˜!šœžœ˜Kš
œ˜Kš
œ*˜*Kš
œ’
˜’
K˜—Kš
œ˜K˜—K˜—K˜—K˜K˜—šœžœ˜1K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜K˜K˜—Kš
œ(˜(K˜Kšžœ
˜—…—#ό/<