fontSize, lead, lineHeight: INT];

zip: INT ← 0,

dataLength: CARDINAL,

text: ROPE];

handle: Handle, viewer: ViewerClasses.Viewer ← NIL];

switch: REF BOOL ← NARROW [clientData];

switch^ ← ~switch^;

Buttons.SetDisplayStyle[
button: NARROW[parent],
style: IF switch^ THEN $WhiteOnBlack ELSE $BlackOnWhite];

};

IF h.busy THEN {

h.busy ← TRUE;

RETURN[TRUE];

};

st ← FS.StreamOpen[name, $read

flagged: BOOLEAN ← FALSE;

Flag: PROC [msg: ROPE ← NIL] = {

e: REF Entry;

ch: CHAR;

zip: INT ← 0;

i, len: INT;

st: STREAM = handle.in;

IF handle.eof THEN RETURN;

IF st = NIL THEN {

[] ← st.SkipWhitespace[];

e ← ReadEntry[handle, st];

extract zip

len ← Rope.Length[e.text];

FOR i IN [0..len) DO

i ← len - 1;

WHILE i >= 0 AND Rope.Fetch[e.text, i] <= Ascii.SP DO i ← i - 1 ENDLOOP;

e.dataLength ← i+1;

WHILE i >= 0 AND Rope.Fetch[e.text, i] IN ['0..'9] DO i ← i - 1 ENDLOOP;

i ← i+1;

WHILE i < len AND (ch ← Rope.Fetch[e.text, i]) IN ['0..'9] DO

IF handle.flagZip^ AND (zip = 0 OR zip > 99999) THEN Flag["**** zip ****"];

e.zip ← zip;

IF handle.item.count = handle.item.max THEN GrowItemRec[handle];

handle.item[handle.item.count] ← e; handle.item.count ← handle.item.count + 1;

};

n: INT;

new: EntrySeq;

IF h.item = NIL THEN n ← 1000 ELSE n ← MAX[(5*h.item.max)/4, h.item.max + 100];

new ← NEW[EntrySeqBody[n]];

IF h.item # NIL THEN {

h.item ← new};

one should SkipWhitespace before calling (and check for eof)

prevCr: BOOL ← FALSE;

DoubleCrBreak: IO.BreakProc -- [char: CHAR] RETURNS [IO.CharClass] -- = {

e ← NEW [Entry];

e.text ← GetTokenRope[handle.in, DoubleCrBreak].token;

};

flagged: BOOLEAN ← FALSE;

Flag: PROC [msg: ROPE ← NIL] = {

IF handle.textOutput THEN {

IF handle.pressOutput THEN {

};

loc: INT;

IF handle.in = NIL THEN loc ← 0

ELSE {

handle.tsOut.Put[[rope[reason]], [integer[loc]], [character['\n]]];

ERROR Problem};

BEGIN

bottom: Points;

line ← of-1-line; -- count from top

bottom ← (box.h- of*h.dim.lineHeight)/2;

IF bottom < 0 THEN SIGNAL TooHigh;

RETURN [box.y + bottom + line*(h.dim.lineHeight)];

END;

BEGIN

PT: PROC [t: ROPE, x, y: INT] = {

y: Points = LineY[h: h, box: box, line: line, of: of];

IF PWidth[h, s] > box.w THEN SIGNAL TooWide;

PT[t: s, x: box.x, y: y];

END;

w: TSTypes.Dimn ← [0];

ref: TSFont.Ref ← h.fontInfo;

IF ref = NIL THEN RETURN [0];

FOR i: INT IN [0..Rope.Length[s]) DO

RETURN [TSTypes.DimnInt[w, TSTypes.pt]];

};

doubleWide: BOOL ← FALSE;

NextLabel[h];

PressEntryRope[h, e.text ! TooWide => {

h.col ← h.col + (IF doubleWide THEN 2 ELSE 1);

};

IF h.col = 3 THEN NextRow[h];

};

h.row ← h.row + 1; h.col ← 0;

IF h.row = 11 THEN {

};

box: PBox;

eLines: CARDINAL ← 1;

tl: INT ← Rope.Length[text];

this: ROPE;

i1, i2: INT ← 0;

ch: CHAR ← '\n;

first: BOOL ← TRUE;

k: CARDINAL ← 0;

lw: INT ← 0;

box.x ← 18 + h.col * LWidth;

box.y ← 10*72 - h.row*LHeight;

box.w ← LWidth - 27;

box.h ← IF h.row = 0 THEN 72 - 18 ELSE 72; -- don't write on top 1/4 inch of paper

compute number of lines

FOR i: INT IN [0..tl) DO

IF ch # '\n THEN eLines ← eLines + 1;

WHILE i1 < tl DO

};

len: INT ← Rope.Length[n];

ln2, t1, t2, f1, f2: INT ← 0;

slashSeen: BOOL ← FALSE;

last, title, first: ROPE;

find last name

ln2 ← 0;

IF flipName THEN {

ELSE last ← NIL;

find title

t1 ← ln2+1;

WHILE t1 < len AND Rope.Fetch[n, t1] = ' DO t1 ← t1 + 1 ENDLOOP;

t2 ← t1;

WHILE t2 < len DO

title ← IF t1 = t2 THEN NIL ELSE Rope.Substr[n, t1, t2-t1];

one could be a lot more clever, but this works quick enough

IF slashSeen THEN SELECT TRUE FROM

f1 ← t2+1;

WHILE f1 < len AND Rope.Fetch[n, f1] = ' DO f1 ← f1 + 1 ENDLOOP;

f2 ← f1;

WHILE f2 < len DO

WHILE f2 > f1 AND Rope.Fetch[n, f2-1] = ' DO f2 ← f2 - 1 ENDLOOP;

first ← IF f1 = f2 THEN NIL ELSE Rope.Substr[n, f1, f2-f1];

RETURN [Rope.Cat[title, " ", first, " ", last]];

};

IF r1 = NIL THEN -- make NIL be greater than anything

ELSE IF r2 = NIL THEN RETURN[less];

IF h.doZip THEN SELECT r1.zip FROM

SELECT Rope.Compare[r1.text, r2.text, FALSE] FROM

RETURN[equal]};

Greater: PROC [r1, r2: REF Entry] RETURNS [BOOL] = {

Sort[h.item, h.item.count, Greater];

};

a: EntrySeq,

n: CARDINAL,

greater: PROC [r1, r2: REF Entry] RETURNS [BOOL]] = {

i: CARDINAL;

temp: REF Entry;

SiftUp: PROC [l, u: CARDINAL] = {

FOR i DECREASING IN [2..n/2] DO SiftUp[i, n]; ENDLOOP;

FOR i DECREASING IN [2..n] DO

doc: "Sort labels, producing new source file or press file with 33 up labels (or both) Source file has entries (separated by blank lines) of the form

Last, Title First Other
Address
TownAndState Zipcode

At least 5 lines will fit in Gacha 8, lead 0. For proof printing, the first line is printed as-is. For non-proof, the Last name is put last and if the title has one of several special forms (see below), it is expanded. Entries that don't fit within a label are displayed in the log window and printed across two label spaces. One can optionally display entries that have no comma in the first line (for corporate labels, this can be legitimate, but it's helpful for finding typos).

Entries with difficult to encode names can have the non-proof label first line given explicitly after an =. e.g.,

Smith, The Family=The Smith Family

Optional info can appear in parentheses, but is surpressed for non-proof labels

Smith, Mrs. Joseph (Susie)

Finally, the entry can be followed extra non-label information if it begins on a line with a left bracket '[ (but before the blank line separating entries).

The text output has the option of a plain text file, or a Tioga node per entry. Either is acceptable input to the program.

The expandable titles (ad hoc to handle the Children's Health Council) are

M/M => Mr & Mrs
Dr/M => Dr & Mrs
Dr/Dr => Dr & Dr
R/Adm/M => R/Adm & Mrs
R/Adm => R/Adm
LtC/M => Lt/Col & Mrs
Judge/M => Judge & Mrs
Col/M => Col & Mrs
Rev/M => Rev & Mrs
Prof/M => Prof & Mrs
Capt/M => Capt & Mrs
Admiral/M => Admiral & Mrs
Gen/M => Gen & Mrs
" ];