clewis@ecicrl.UUCP (Chris Lewis) (11/17/90)
Submitted-by: Chris Lewis <clewis@ecicrl.uucp>
Archive-name: psroff2.0/Part03
#! /bin/sh
# This is a shell archive. Remove anything before this line, then feed it
# into a shell via "sh file" or similar. To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to comp-sources-unix@uunet.uu.net if you want that tool.
# Contents: fonts.lj/S.20.pk.UU pk.c utils/maps/alnum.ROMAN8
# utils/psdtwd.S
# Wrapped by clewis@ecicrl on Fri Nov 16 23:35:19 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo If this archive is complete, you will see the following message:
echo ' "shar: End of archive 3 (of 16)."'
if test -f 'fonts.lj/S.20.pk.UU' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'fonts.lj/S.20.pk.UU'\"
else
echo shar: Extracting \"'fonts.lj/S.20.pk.UU'\" \(11597 characters\)
sed "s/^X//" >'fonts.lj/S.20.pk.UU' <<'END_OF_FILE'
Xtable
X !"#$%&'()*+,-./0123456789:;<=>?
X@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
Xbegin 644 fonts.lj/S.20.pk
XM]UD``4``````````!":N``0FKJ",(0```$`[4_H]WB_=/]P]SSW//<XCW//<
XM\]SB/<\]SSW//<XCW//<\]SB/<\]SSW/.^+!.^/!.]3!.\:_.\$5OSNB-;T[
XMH56].Y%EO#PO6[/#];D\1;@\9;<\9;8\A;4\CUM#RELSRELCS%L3S/6P/.]9
XM/06#T/5STO53U/4SU5(]?U$]CWV6VUVTW?/(L+$D````6$TF^R3!C7C+PM'"
XMQL;-QL/)RGA<%UP,9L%+6ZQ%Q3E,*L)<<W3%G`7)-CQYI,PE/)F$S30\J67.
XM(SS)1<\R/-DET2(LZA32(3S\'371P-1-*M5-.=5-.M1-2M--6=--6M)-3`T5
XMT\'/,2TD&LXB+14IS3(\]4G,,RSE:<HT/-2)R34LQ*G'-CR5P)Q4<\=<*L))
XM/%7$JUM,%L;`5\%8?*R</&S<;&PM'"RXUXP0H"HE````1#DR^RV_78?6G4Y+
XM#4G6?84`*<W!!''<`"G%V'UIU.2PU)UGV%OPP(\F````1#DF^R2X`2>=#=E]
XM39MM;6;%B=-=!,C07131BUTCTXE=(]6(33/6ADTSV'5-0]ES35+:@DU2V\U3
XMW+U2W:UBWIUBWWURWXUB`0C5(!%]4@$)U"`0K3/>O4+>S3+=0HTBW4-](]M%
XM?2+:1HT3V$B-$]99C0/56XT#TUT(T#T%TYQ);6T'T]G)S=JX`2>P;"H```!$
XM*2KS*1+7(4U9TU%=%37/55S5=<M97)6UQUP5Q5PUPUQ5P5QUM<E97+5US55<
XM]37145TYU7U_77?5G345T5-<]57-5URUE<E;7'7!7%7#7#7%7!7'6UR5E<M7
XM7-55SU-=%173G502UR%@#2T```!$-03Y%AG!TQG!H$P\````/"\M^BK2'13.
XM;,;,;,;,;+?+?+?+;,;,;,;+?+?+?+;,;,;,;+?-7/?0;0;0;0;0?/?/?0;0
XM;0;0;0?/?/?0;0;0;0;0;032$:A*/0```#PO+/HI30;0;0;0;0;0?/?/?0;0
XM;0;0;0?/?/?0;0;0;0;0?/7-?+;,;,;,;+?+?+?+;,;,;,;+?+?+?+;,;,;,
XM;,;.31'2N"Q#````-RXX_#?B`0FL6JC)>HRGF,MIC,6?C-2>.,XYC.3CB,\^
XMU(C9O0XL[("@CD0```!)0#K\.</T`0;>^-SZVOL=A!G7,IUD.=4TG419TS:=
XM)'G1.)T/.ISCL9S$L:RSLYRDM)R3M9R$MIQSMYQDN)Q3N9Q$NIPSNYPDO)P3
XMO9P$OIOSOYOO/!F\/#FZ3#JY/%FX3&FW/'FV3(FU/)FT3*FS/+FR3,FQ/-FP
XM3.FCSYE-"8/1E_WU\!$P$Q!5L()(````1#DZ^SC+O?Q=EY?4;#;0?%?-;);+
XM;+;(?-?%?/?#?1?";3;!;5:WU7GWUW?WV76-F$]]MS^-N"]V/+-G&&/+-L3F
XM;1;$XF/+-H%]UR^-N#]]MTC9A??9=_?7>7U7MM5L!]-\%]%\-\]\5L]L=\M\
XMILELUL=M!L-M1Y?8Q]Z\L*!^2P```#TV.OTYON)-;B;4^-+BK0^QSS&,Y!G-
XM\SC,0YR_-8RC:<GS>,@XG'\YC&.IQ?.PC$.QG#.RC"2RG!.SG!.TC`2TF_.U
XMF_.VB^2VF].WF].XB\2XF[\[J+H[N;GSO(N#O9M_.^BV._FU/`BT3`BT6_FQ
XM>_FK"\L5XK:TNY`K3@```#LR-_PV'EQB/`,?3`?CPC#ZXSLCIN6XIN,[(P`5
XM[D/"?\!!/`,N7&&H&%````!".3C\-P@'F^FT[4B^BTJ\I^*]F]"H@5(````_
XM-#C[-^+7.K^R.PPI2L2$K$=:Q&6PQ%:L5'K$2*PTBL0YK#.JPDFPPCJL(["L
XM$[&L`[&PSZT*T*S[#/K0K0^M"=&-%]-=-=-=1-1-1,$[5,([1,,[-,0[),1+
XM%,4[%,8[!<5*7&25QTA<=77'9TQW9,>%3&I$P[)-4]8OUR#`35,````@("[]
XM)-6M;3T&AJ71*DW4WDWDWDWDWSWTWN)-Y=[TW^)=YMU]R-R-NMJ]G-C0U]'7
XMT=?0V,V;VJVXW'W6WO7>3>7>37)4V*VVT*!/5````$0Y.?LXA\![.QNK&K6W
XMM'M[2W:XLKA;JQN3O*NR:)F88DL8A[%!2T=GLWMF9K5K9T:V:W9%MSNU-M!B
XM72]272L-3CK5[#C4L<KBP;/`<U4````_-#C[-\XMX!2P'N9P'L`6V=Z1<IV7
XM5V?5=WA])X>7T'EZ>HI[AXM\AGQ]!UC'T(.<?0DOC0?1@>6=!]&?&-!]&"G'
XMT).,?0A7Q]!VBWR'BGN*>7I]!X>7TG=X?5=79]F1<IWMD!;`'>9P'K`4XM[0
XML&)7````1#DX^S?#XL_:L!3F?-C%?%QL-\.CC"?"AXP7P8GWP7P7J,!\"+Z7
XMP'P'P>-[>WP_>GI\5J>FQGEY?':7ELAX>'R7=W?+=G9\YE=6T7-S?4<7%]C'
XMWK`4YG`4O:XL_#"P?U@````_-CG\.,G`VLC3F)SHPHRWQGR'RGQ7S'PHSHN<
XMZ:C0B8TH>=*6C4A?G4D^B=:3C6A.*=25C4AITI?XTHF-"+]]!\%\Y\-LYL1\
XMQ\5LQL=<Q<GURERTRDP/.DR$HQ.CR#HR.DQDHR\[/&.S)++&*T-*/$.D3CQ<
XM3%7\3$Q#F)=9````24`Z_#<$8=0_TET&C%-XPSB,))C!.@C`2AB_.BB^2CB]
XM.DB\2EB[.FBZ2GBY.HBX2IBW.JBV2KBU.M>T.NBS.OBQ.PBP2QBO.RBN2SBM
XM.TBL2UBK.VBJ2WBI.XBH2YBG.ZBF2[BE.\BD2]BC._>B/`BA/!B3PHA,.'/$
XMADQ84\:$3'@SR(),F!/*HLOZ#-^,]M'TM,"36@```"XL._PYV)`4T=]7;;3%
XMV4TEUDU%U$UETDUUTCV5T&UVQ]=<?7:HUVJ-A:C8:7V6L]MN,!EM>*;3T7?1
XM:$5\;#1[72,WEM0R>&UB&';7IVV99MJ5?:E/?;A/?<@XW'1]UT]]QTC<=/?<
XM=7W&9]MV;<9_;;:'V6IMAK;7;0;5;1;4;3;2;5;'UWA]O5WM(!.=L*!?7```
XM`$0U1_DVURUETWT8T)SYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSJSY
XMT7TXTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTXU&UC`"O=@0
XM/QV!H%]>````1#5'^382UUU7U(TYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTYTY
XMTYTYTYTYTYTWTHT)SYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYSYT(
XMTFU3`"[=@0/QV!!8"5\````J*@,`[-C`@6$````X,";\)-9P&=`!1F4!!:7=
XM;%PY;16SAM)I1VU%DW;5:#9M9G17UF<V;89C5]AE1'V64U?99$2-ED-7VF-%
XM?:8S9]IB18VF(V?;83=]NG?;F'VXE]MZ;<>O;<:VW'MMJ+;9G%UT%F,VU4)F
XM-%TT5515T$=D.%=J4TG2T)T8UE;`NV(````Q,$K_.0%(`8T`%%=0$$M=U-%=
XMM-)=I-1=A-5==-9=9-==5-A=4]AM0]EM--EM,]IM)-E](]IM)-IM(]IM,]I=
XM--EM,]EM0ZDEU4C4UCA';7.-76.J)=1-EM,]M=/SVVT4VVT?/=;0/<?$W'SB
XM/=>TW(OB/=>TW(OTW'Q-M\7;?%VGT&V6T6V&T8UFTC(]5M,S/3;4,TT6U$4\
XM;5-U=M<YT=D\C;0!_B,!]`'^(P'T`?XC`?0!_S`@L&EC````+2XV_R3"?9O(
XM.L/%2,;$.,C"1\G"-X>,!&;`;`-FPUI&3&2C9,=81DR$@V3*-T8\M&-SS#5&
XM3,-3US4]=#38,SV3)-DR/:,4VO,3VWV^)MSUW>)-[B/>]-X][C3=XTW>--[S
XMWRQPP()D````)R,[_#G9?<S85DUDH]1+32303071/%TBT%`10!'U`1]@$'WX
XMWJW:W:W;W+W+V\U]+64YTV9])H?0:7QK:VT&EM%H?26&TU=]-6?45GU$:-1&
XM]]5%C518U3;B?51GU$=M5';5./;42&TTIM)*;13%T3T&P]);3364U65-G-UM
XM8,`X90```",<)?PCU:TM#-.WUGUVV&V&V&V'U_?7]]>-?]M-E8U^1]GC;:7:
XM;:7;72-ET$=:669LT=2(L&EF````)R1*_#C*Y3U3&,S"R5<\=!P,9#G'33/3
XM333334/4333333]---/TT_33]-/TTUT^)--=/C33Y%T_;3]M)])]&-&L[!S,
XM/*Q<G%R<7)Q,O"S<#/G1?2;3XUTTR"I,@X3*14S:T&P0L'AG````+"@V_21U
XMPWN:P(,U=65355.E-%4TMB-F%,!B-JPE%&G#43>,11-WQ9=\2?=\67;&:FQ7
XME\5_EL9J;%>7Q7GVQFIL5Y?%>?;&:FQ7E\5Y]L9J;%>7Q7GVQFIL5Y?%>6QF
XMP#QVU??5]M7WU?;5]]7VU??5;8.PP(-H````*2,[_3G97?G;14UU9=583465
XMTEM-%K707%QL6VT%M=%:;1;X;29WTF=M-F?39FTW]7TW]'U'1]-TC3=/?4='
XMTX/B`21].#C3=/?4='TX1]-U;4=6U&7WTW7WTG9M-G;2>%TFGUT6I=!K707%
XMQM!:;16ETTE=1(761EV$1-NMY=G`/6D````?%R;\)*/6;3]]/VTWT^)M-]/B
XM;3?3]M-]/B;3?3;3?3]L,7M!;#)K0FLR:T)J1%E%6$972%1:O1;`L&QJ````
XM,RLF_"2CVVQEP7Q)M\*[;!08ML`SBGI$BGDV>VDY/!:#S7<\YU3/93T60]%R
XM32O4P]#(RG7`QWJ,9L%\5L)\/WPWPO;%:#)\1W0GQ'<S]L5H,O?%9S-L9F0V
XMQU8S?'531\A3-6RI@\U8L&UK````,RHZ^SB6V)V(UXUWUXU_?8]]>-?WV.)]
XMCWV.)]CWUXU_?8XGV/?5K3O2P-%2?/4WSF.,QE?+9GRFA\AI?':GQFP'Q'P'
XMPWP8P7PWP'Q'M\9Y?'>'R'=\IUC*=(RX*,UR?.<FT'%=)Q/48+!U;````#4O
XM-OXDPCWVQSQGQEQ7Q6Q?;&;$]\5\3VQFQ/?%?$]L9L3WQ7Q/;&;$]\5\3VQF
XMQ/?%?$]L9G-VQ7<V?%=D9\5G-WQ'<VC#AD;XPI8WFT)51KE#53?`9&4SABP8
XMF65\%:]]SVW/?<]MSWW/;<]]QM\]X,!F;0```"LI)?PDA]@TT-=O+0UG=]=I
XM;7:'UGA]9I;7:6UFE]9I?5:FUFIM5J?5:GU&MM1[;4:WTVQ])M!M-=%M)M!]
XM%M%]!M)M!M-L74>UU7I=9I;7:%V'==EU7;9%W6)=[`$)`34!<+!U;@```"<D
XM2OXXR>4]7!RL3%B#PW'!PG2<*,^,^-!]!]"-#WT(T.1])M)])M)RO&R,5X3$
XMQ\1#O%323333733333]-/TTUT^)--=/VTVTGT8T9S\#-PLO$RL3)QLG%R<7*
XMP\S!SJT(TFT_733'*EQSE,E53,O0:\!<;P```"HD)OPDUGW=#79FU%I=%L7&
XMT&IM)9;39VU&9M9D?69&UV-]=O)]=QC7?Q?8<7U]/7TOV'%]>!]]=R;7<VUV
XM1M9T;69FU&=M-I72:FT&Q<;16EU&9M?0W7U@L%UP````,B\E_2.]>MI]QMQM
XMQF@X3%6CA,1:2#Q4M(/$3`.3PTP3A,,\%(332$TSD]-)/32$TEA-+TE-%931
XM]*306DT%EL[UILUJ;-:US.)L!LKVP7R'PFR/;#;)/&/#L'=Q````+2@V_B3-
XM?2P,YE3,6%R%IL9<!<5<%L-L)<)L-L%<1L!L1OML5J;&:FQ7E\5_EL9Y;%B'
XMQ8^&QGA\6(?%>6QGEL5Y?%>7Q'IL5K?#>HPVN,)L"<!L&;;!<3E<-R15Q62\
XM=F?(]]7VU??5]M7WU?;5]]5M@]?`97(````R+27\(]7=TP$=`!.P%+`4J7C7
XMBGUGT'U'TFU&TVTVU6T7U6T6UFT/;7;'UVQMAL;7>WUVSVV&QM=\;7;078;0
XM]==M%=9M)=9=-=5M1=-M5=)M==!MA<;:6EWE90$=`!9P$+`]<P```"<J)?TC
XMO2K5?7;7;79J/*7`/)7`3)3!3(3"3'3"3(/#3:39]=GTV>)=CB78]MCUV.)M
XM?B;7]]=ME,[`<W0````P*R;]))7:.IUG9#75=45=.4-ETY,W74@D=M1R.&U6
XM%';6;Q.&UY=]=!.&V$$W?9.VV4MMD[?9.VVCMME*?9.VVCMME+;9.WV$MMD\
XM;83&V#T&UTT&UST6UCTFU3U&TTU&TDUFT$V&L]MW3>T0$YU0L)]U````-"Y*
XM_#C3\][TWO/>]-[SWO3>\][TWO/>]-JM3&SG)#;*945L9G.%PVDY7!:4I;6T
XMM97`/`6&P#P&9L!,%5;!3!;S;"/";R;"3";Q;#/#86PDPL+"3"P?PSPV'VPD
XMPF+VPCPF-L%,%E7!3`9FP#P&A<`\!96TM;6DEL%9.6PU@W;&945LIC0GSL;4
XMK:]-[SWO3>\][TWO/>]-[ST@L)-V````-S`V_21VW+TB-#?0,S5\Y"-WS$,W
XMC*3#?)3$C'3&?&3'?%3)?#3*?"7+?`7,?`3->TSWE-!X31=TTW5-1T35<TUW
XM%-B]FMN-SWWO?<C;K9O807UT-]5$?417TT=]%(?027STM\U,!\Q<!\M<)\I,
XM-\E,5\=,9\9,>,1,EY%4RH<S3,=S),YU,ST'-#+2O<9PP,)W````.35*_3@!
XM?C,"1`).(P)$`DXC`D0"3B,"1`).(]Y=1,.ITCMV0UT3MU15T#J4-EQ*DS=<
XM/()':ST'(X:ST6%':TT6\3AK/3EWL]-!.&M--!-WL]4[;#U$ML/4.WM-0[;#
XMU3ML/42GP]0[;$U#ML/4/&P]-+?#TSQL323&P],]!L/2/1;#T4T6M-!--J/0
XM34:CQ-9I.TUVA*/:9SE-UE-T`0@C1@%-0!JP(/,"1`).(P)$`DXC`D0"3B,"
XM1`)#`3"PA'@````W-";_)`$CP"U6H]5X34ATU99-:%38=3V71-ID/<4TW%,]
XMU#3=0SR#QT,\=<9"3&;&,_/';&,SQVQ4),9L8S/';&,SQVQ4,\=<8T/'7%1$
XMQEQ$5,9,5%3%7$1DQ&PU9<)\)7;`G`65NJ>7;#:*R!R,#&/&P<5,7#PVPL>Y
XMO+;"?"GD````5`U/W/0^PP#EZ````)AE3^CW775/7/8/8/8/8]-?MQ-?T
XMUTV#V#UTUDU%VTVDVCVCV4V?39[<39]-D]H]H]H]L]M0R#E[````)AE3^CU=
XMM-I-H]H]E-GTV>W$V?39/:/:/:/;/;75/7/8/8/8/8]-?MQ-?TUTV#V#UTUD
XMU%UPL$]\````1#DG^R>WV1G!U3?$TS;&TC7)T#3+SS.'K-0FP9RT)<2,E"7&
XMG&4DR8Q%),N<%B3,MX,\_+0]#)4]+&8]/$<]7!D=EP`X`!L05A`;$&`:?0``
XM`$0Y*/LH&@';&@`"N:`=L:``*YH!VQH!R$U^````)AU3_#TM[SWN(][B/>XC
XMWN(][B/>XSWN(][B/>XCWN(][B/>XCWN(][B/>XCWN(][B/>XCWN(][C/>XC
XMWN(][B/>XCWN(][SWB"@F'\```!$.CS[.:FYFVM+.TLK>K>PN8N9=X:'=ULF
XM1K)56U4EM51+>K=#6XBX4DN8N4+TNFND%;M+N?O$O(O2O8Y=>=5?%-5"734_
XM331%T55<]73/2%S5E<M;!,M+%<E;)<=;1<5;9<-;A<%;I;];Q;U;Y;M<!K=L
XM)K5L1K-L9K%LE:7,6%SE9=!4721$TU)=2M;XV/;:]-PL$,`RH0```"P@2?HX
XMTB`0]-[VW(VJV,UD%!340D)-)#0TQ41%AE161G1V%928M+/@*M%`$"T@@#6B
XM````6$T>^R/$'2/131/131/13131313131315=$@41T<U<Y,],],],],]-`]
XM!-`]!-`](9;`,J,````L($GZ.-(@$.`J31.TN)25%G1V1E16A41%Q#0TTD)"
XM3404%-;-BMJ-SVWO0!`M((`UI````%A-'OLCEATCT$T#T$T#T$STSTSTSTST
XMSES=$042T571313131313131/131/131/2'$L&NF````+"4L_2H2UEU'THT:
XMS\#-0GS$.,I%C(1WQTB,5*?$3`?"3!C`3#>TQ(E,:'3(=DR81,N"3-<?3.O-
XM<4RX),F$3(=DQH=,2)3#>TP8P$P'PDI\1(C%1WQT6,A#C*0GS,#-K/C1?275
XM+6"P:Z@````L)2S]*M8M5=)]&,^LW`S'),J#3(A4QW=,6(3$>DPGP$P(P4M\
XM-)C$1XQD9\A$C)0HRT%\V_SD%\U"C+1(R49\A'C&28Q$M\-,",%,)\!,1Z3%
XMB$QW=,B%3*@TS'),W`SZT8TGU%UB$%@)L````"HJ`P`^V+`QM0```#LP,OLP
XM$MXA[63<G:44VD)=A3381%UE5=17;0:7S'N<:<'`K`Q-+(SLW(U,#&"P,;8`
XM```[,#+[,,;`U,C-SLC2Q,"L#!G&FWS'EM!G7455UE1-A#784DVD%=J>UMQ!
XM+>(0L%6W````.RPV^2_*R<?.Q-#"T<*M2-=]AMEME=I=I=M-M=I=M-M=M-M=
XMOB3;7;]-S?$&<?3<7<XDW%W$W%W$W%W%W$W%W%W%W&VVVWVHVJU]'%T,;.RL
XMD:!.N@```$0U-ODONL2WR;3+LLRQL,Z-%])M-=1=1=5-5=1=5-5=5-5=7B35
XM75Z4UEUN)-9=9-9=9-9=9=9-9=9=9=9M5]2-.PT<RUR[;)NL0:!.NP```$0U
XM-ODO'$NLFVR[7,T;#3C4?5;676767636767636763676XDUEZ=9-5>+53575
XM357535747535747473;2?1C.L+',LLNTR;?$NJ!5O@```$0U1_DVNL2WR;3+
XMLLRQL,Z-%])M-=1=1=1=5-5=5-5=5-5=7B3575Z$UEUN)-9=9-9=9-9=9-9=
XM9=9=9=9M5]2-.PT<RUR[;)NL0`*_UC_8/6&@5;\```!$-4?Y-AQ+K)MLNUS-
XM&PTXU'U6UEUEUEUEUDUEUDUEUDUEUN)-9>C6357BU4U5U4U5U4U5U4U5U%U%
XMU%TVTGT8SK"QS+++M,FWQ``M'6/]@]8P<!+(````.S`7^QT:8=@:?HFD2E(0
XML##,````+"$B^R7!?+P<;%P\?!R;RYS7SU_1/BTQ#LXATS_17/?-G+O)P<?#
XMQ<;!RWP0D*_-````6$U+^SFVH]&MR;/$M\"CH:.\H*N@N8L8MHM8LWN7L6O6
XMKVOVK5PUJUQ5J5QUIUR5I5RUI$S4HUS5H5SUH$T4E=%8331UTU9-5%755/37
XM0UUU+B3905V9Z@VYV5XA390EUU/TUT1=55351ETU=--(7164T4H%SUH5S5HT
XMS4I%RUI5R5IUQUJ5Q5JUPUK6OVKVO6L7N7LXM8MHL8N:"KH+RCH:/`M\2SR:
XMW1H[8,`HS@```"<<2_LYQ-KH;:Y4W.(M%F)F&C(P/S(Z%F)FT?+<Y$VNW6VN
XMTDR`.\\````G'$O[.9-)[G:>Y$H/*5A"2!VQ=25Y7RH.1)[G:>2[2>YVGN1*
XM#RE80E<=L80DB5\J#D2>YVGDD[!4U0```"4C2_LYSET(SD,\Q%/+1%R5)\E#
XM?BR%-\A5/)Y5T6T>-='D;171Y6T'T.1M!]#E;171Y&T>-=%M'E7(-EQ_=%Q_
XM=$R'-,E53*-4S#-,Z-!<X-"7V````"PC1?P^`<("+T`@4"!`%W-`%`$P$E=P
XM$4M`$4Q=3'M-B5V835%'74)6]`$$-%75-4]=1%-=55+B74927%91]L1\M7SB
XMM(REC/I)R5G/E*R%K.*$O'6\]TQA5EQ2XE9-4F1<8F1-8U1-5%-=5%-`$%7U
XM)-5T%=2)U9C4M\35Q`$5E0$85@$@$P%$-P%T`@4"#T`B(!R@]=D```!-1$S\
XM.L*MNWU;O0FIS&MVR6NVQEOUPUPUP%Q5ODR4O$RTNDS4N$STMDT4M3TSM#U3
XMLDU4L3USL//9.?/;-SW38\![LU.^1BNC0[Q**X-#NTLAMS,[M+0;<R.Z2V&V
XM,CN5MAMC([E+5+4R.X6T6U,3N4M5MFN%M5MFN%MCMVN$S&Y[=<P_$[9<LR.W
XM3+,O.W7*,_.W2Z&S-#N$N!M#4[=+@;,V.X2V&T-SN#M1M#@[D[,;4Y.Y.P*U
XM.CNS<K<[`[R+@[%-5+(]4[0],[5-%+9,]+A,U+I,M+Q,E+Y<5<!<-<-;]<9K
XMMLEK=LR:G0N]6WVZPF@-V@```"\F)OPEWNB(G>`(#.````!$%E/C/-[E@<#8
XM#>$```!$%E/C/N!+G0R`H#;B````1!A3XSRZ.X6W:V:V:V:V:V:V:V>U>U][
XM5[6+5[6+5[7XM/BTFT^+3YM/BTXYM(M.U9M`P#WC````1!A5\C[2[;GBT9T?
XMG1G2C2C2C3?3?3?2C2?2?3?2;537;7?5?6?5C5?5?5?4C4C4C3G3^=/BG3[;
XMD*@TY````$084^,^[5FUBUXYM?BU^;7XM9M?BV^+9[:+9[:+9[?WMWMWMVN&
XMN&N&N&N&N&N%NC#8#?````!$%E/P/`R.!+V0``SQ````1!93\#X<Y8W@J#3R
XM````1!A3\CP[I;AKAKAKAKAKAKAK=[=[?WMWMHMGMHMGMOBV^+6;7XM?FU^+
XM7CFUBU[5D,@]\P```$085>,^[;G3XIT_G3G3C4C4C4?5?5?5C5?6?5?7;735
XM;2?3?2?2C2?3?3?3C2C2C2G1^='BG1[;G2"@-O0```!$&%/R/K3M6;2+3CFT
XM^+3YM/BTFT^+3XM7M8M7M8M7M?>U>U>V:V:V:V:V:V:V:W6X.Z#8"_4```!$
XM"57C/@`O\"@)]@```%A7`@`6VY!5^P```%A-,/LLLSWTWEWDWEWDWEW5W5WD
XMWEW5W5W<^IT:;3I=.E;;;;?:?:C8G7^@W)W8W7WGWFWVWM.GTZC1J<^K7?7?
XM7?3?7?7?7?3?7?3?7?0!`\/8"_P````O)B;\)0!:8)!5_0```%A-,/LLPS`0
XM3?7?3?7?3?7?7?7?3?7?7?6KSZG1J-.GT]YM]MY]Y]V-V=SZ#7G8C:?:?;;;
XM:ETZ73IM&IS]U=U=U=Y-Y=U=U=Y-Y=Y-Y=Y-\[-@&OX```!$.3K[.(4I_H)(
X/2@';&@A>?TA*`=L:`?7V
X`
Xend
END_OF_FILE
if test 11597 -ne `wc -c <'fonts.lj/S.20.pk.UU'`; then
echo shar: \"'fonts.lj/S.20.pk.UU'\" unpacked with wrong size!
fi
# end of 'fonts.lj/S.20.pk.UU'
fi
if test -f 'pk.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'pk.c'\"
else
echo shar: Extracting \"'pk.c'\" \(21373 characters\)
sed "s/^X//" >'pk.c' <<'END_OF_FILE'
X/* Copyright 1990 Chris Lewis
X */
X
X
X#include "defs.h"
X
X#ifdef PK
X
X#ifndef lint
Xstatic char SCCSid[] = "@(#)pk.c 2.1 Copyright 90/07/18 16:51:38 Chris Lewis";
X#endif
X
X#define DRAW
X#define OUTRES 300
X
X#include "pk.h"
X
X#if defined(PARTIAL)
X#include "pkc.h"
Xstruct needmaps *needmaps = (struct needmaps *) NULL;
X#endif
X
Xextern char *progname;
X
Xstatic FILE *fin;
Xstatic char *filename; /* name of *current* font being read */
Xextern char *malloc();
X
Xstatic long flag_byte;
Xstatic repeatcount;
Xstatic dyn_f;
X
Xstatic readraster();
X
Xstatic long
Xget1int() { return(getc(fin)); }
X
Xstatic long
Xget2int() {
X register long c;
X c = get1int();
X c = (c<<8) | (0xff & get1int());
X return(c);
X}
X
Xstatic long
Xget4int() {
X register long c;
X c = get2int();
X c = (c << 16) | (0xffff & get2int());
X return(c);
X}
X
Xstatic long
Xget3int() {
X register long c;
X c = get2int();
X c = (c << 8) | (0xff & get1int());
X return(c);
X}
X
X#ifdef VFPRINTF
X#include <varargs.h>
X/* VARARGS */
Xpkmsg(va_alist)
Xva_dcl
X{
X va_list args;
X char *fmt;
X
X va_start(args);
X fmt = (char *) va_arg(args, char *);
X VFPRINTF(stderr, fmt, args);
X va_end(args);
X}
X#else
X/* VARARGS1 ARGSUSED */
Xpkmsg(fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
Xchar *fmt;
Xint a1, a2, a3, a4, a5, a6, a7, a8, a9, a10; {
X char buf[BUFSIZ];
X sprintf(buf, fmt, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
X fprintf(stderr, buf);
X}
X#endif
X
Xstatic
Xskipspecials() {
X register int i,c;
X do {
X flag_byte = getc(fin);
X if (flag_byte >= 240) {
X i = 0;
X switch(flag_byte) {
X case PK_xxx4:
X i = (i << 8) + getc(fin);
X case PK_xxx3:
X i = (i << 8) + getc(fin);
X case PK_xxx2:
X i = (i << 8) + getc(fin);
X case PK_xxx1:
X i = (i << 8) + getc(fin);
X DBP((D_PK, "PK_xxx%d: ", flag_byte - PK_xxx1 + 1));
X while(i--) {
X c = getc(fin);
X DBP((D_PK, "%c", c));
X }
X DBP((D_PK, "\n"));
X break;
X case PK_yyy:
X i = get4int();
X DBP((D_PK, "Num special: %d\n", i));
X break;
X case PK_post:
X DBP((D_PK, "Postamble\n"));
X break;
X case PK_no_op:
X DBP((D_PK, "No-op\n"));
X break;
X default:
X pkmsg("PK file %s: Unexpected %ld\n", filename,
X flag_byte);
X exit(1);
X }
X }
X } while (flag_byte >= 240 && flag_byte != PK_post);
X}
X
Xstatic
Xreadschar(p)
Xstruct pkc *p; {
X p->pkc_pl = get1int() + ((p->pkc_flag&0x3) << 8);
X p->pkc_char = get1int();
X p->pkc_tfm = get3int();
X p->pkc_dx = get1int() * pow2(16);
X p->pkc_dy = 0;
X p->pkc_width = get1int();
X p->pkc_height = get1int();
X p->pkc_x_off = get1int();
X p->pkc_y_off = get1int();
X if (p->pkc_x_off > 127)
X p->pkc_x_off -= 256;
X if (p->pkc_y_off > 127)
X p->pkc_y_off -= 256;
X p->pkc_rlen = p->pkc_pl - 8;
X readraster(p);
X}
X
Xstatic
Xreadeschar(p)
Xstruct pkc *p; {
X p->pkc_pl = get2int() + ((p->pkc_flag&0x3) << 16);
X p->pkc_char = get1int();
X p->pkc_tfm = get3int();
X p->pkc_dx = get2int() * pow2(16);
X p->pkc_dy = 0;
X p->pkc_width = get2int();
X p->pkc_height = get2int();
X p->pkc_x_off = get2int();
X p->pkc_y_off = get2int();
X if (p->pkc_x_off > 32767)
X p->pkc_x_off -= 65536;
X if (p->pkc_y_off > 32767)
X p->pkc_y_off -= 65536;
X p->pkc_rlen = p->pkc_pl - 13;
X readraster(p);
X}
X
Xstatic
Xreadlchar(p)
Xstruct pkc *p; {
X p->pkc_pl = get4int();
X p->pkc_char = get4int();
X p->pkc_tfm = get4int();
X p->pkc_dx = get4int();
X p->pkc_dy = get4int();
X p->pkc_width = get4int();
X p->pkc_height = get4int();
X p->pkc_x_off = get4int();
X p->pkc_y_off = get4int();
X p->pkc_rlen = p->pkc_pl - 28;
X readraster(p);
X}
X
Xstatic
Xreadraster(p)
Xstruct pkc *p; {
X p->pkc_pkr = (int8 *) mustmalloc((int) p->pkc_rlen, filename);
X fread((char *) p->pkc_pkr, 1, (int) p->pkc_rlen, fin);
X}
X
X/* Read a character sequence from a PK file */
Xstatic struct pkc *
Xrpkc() {
X register struct pkc *p = (struct pkc *) mustmalloc(sizeof(struct pkc),
X filename);
X
X p->pkc_pkr = NULL;
X p->pkc_sfpr = NULL;
X p->pkc_flag = flag_byte;
X p->pkc_dyn_f = p->pkc_flag >> 4;
X flag_byte &= 0x7;
X
X if (flag_byte == 7)
X readlchar(p);
X else if (flag_byte > 3)
X readeschar(p);
X else
X readschar(p);
X return(p);
X}
X
X#ifdef SFP
X/* Read a character sequence from an SFP */
Xstatic struct pkc *
Xrsfpc() {
X register struct pkc *p;
X int len;
X
X if ((len = getc(fin)) == EOF || len != '\033') {
X /* HP fonts when loaded often have trailing nulls due to DOS
X file padding. Screech on non-null */
X if (len && len != EOF)
X fprintf(stderr,
X "%s: WARNING: trailing garbage in %s, offset %ld, char 0x%02x\n",
X progname, filename, ftell(fin), len);
X flag_byte = PK_post;
X return((struct pkc *) NULL);
X }
X
X p = (struct pkc *) mustmalloc(sizeof(struct pkc), filename);
X p->pkc_pkr = NULL;
X p->pkc_sfpr = NULL;
X p->pkc_flag = 0;
X p->pkc_dyn_f = 0;
X
X if (fscanf(fin, "*c%ldE", &(p->pkc_char)) != 1) {
X pkmsg("SFP file: %s, bad/missing SET CHAR CODE, offset: %ld\n",
X filename, ftell(fin));
X exit(1);
X }
X
X if (fscanf(fin, "\033(s%dW", &len) != 1 || len < 16) {
X pkmsg("SFP file: %s, bad/missing/tooshort CHAR DOWNLOAD sequence\n",
X filename);
X exit(1);
X }
X
X get4int(); /* skip some garbage */
X get2int(); /* skip more garbage (actually, orientation & dummy */
X
X p->pkc_x_off = get2int();
X if (p->pkc_x_off > 32767)
X p->pkc_x_off -= 65536;
X p->pkc_x_off = -p->pkc_x_off;
X p->pkc_y_off = get2int();
X if (p->pkc_y_off > 32767)
X p->pkc_y_off -= 65536;
X p->pkc_width = get2int();
X p->pkc_height = get2int();
X p->pkc_dx = get2int() * pow2(16) / 4;
X
X p->pkc_sfpr = (struct ras *) mustmalloc(sizeof(struct ras), filename);
X
X p->pkc_sfpr->ras_height = p->pkc_height;
X p->pkc_sfpr->ras_width = p->pkc_width;
X p->pkc_sfpr->ras_bline = (p->pkc_width + 7) / 8;
X p->pkc_sfpr->ras_bytes = p->pkc_sfpr->ras_height * p->pkc_sfpr->ras_bline;
X if (p->pkc_sfpr->ras_bytes) {
X p->pkc_sfpr->ras_raster = (int8 *) mustmalloc((int)
X p->pkc_sfpr->ras_bytes, filename);
X
X fread((char *) p->pkc_sfpr->ras_raster, (int) p->pkc_sfpr->ras_bytes,
X 1, fin);
X } else {
X free((char *) p->pkc_sfpr);
X p->pkc_sfpr = NULL;
X }
X
X return(p);
X}
X#endif
X
Xstatic struct pkc *
Xreadchar(p)
Xstruct pkp *p; {
X if (p->pkp_flags&PK_PK)
X return(rpkc());
X#ifdef SFP
X else if (p->pkp_flags&PK_SFP)
X return(rsfpc());
X#endif
X else
X return((struct pkc *) NULL);
X}
X
Xstatic int
Xpkccomp(a, b)
Xstruct pkc **a, **b; {
X if ((*a)->pkc_char < (*b)->pkc_char)
X return(-1);
X else
X return(1);
X /* can't be equal! */
X}
X
Xstatic
Xrastbit(x,y,r)
Xregister int x, y;
Xregister struct ras *r; {
X register int bi = y * r->ras_bline + (x >> 3);
X
X /* You don't really want to uncomment this.... ;-) */
X /* printf("x,y,bi: %d,%d,%d\n", x, y, bi);*/
X return(r->ras_raster[bi] & (0x80 >> (x&7)));
X}
X
Xstatic int8 *rptr;
Xstatic long bitweight;
X
Xgetnyb() {
X register int8 b;
X if (!bitweight) {
X bitweight = 8;
X rptr++;
X }
X b = *rptr;
X bitweight -= 4;
X#ifdef VDEBUG
X DBP((D_PK, "getnyb byte: %x\n", b));
X DBP((D_PK, "getnyb: %x\n", (b >> bitweight) & 0xf));
X#endif
X return((b >> bitweight)&0xf);
X}
X
X#ifdef NEVER
Xgetbit() {
X register int8 b;
X if (!bitweight) {
X bitweight = 8;
X rptr++;
X }
X b = *rptr;
X bitweight--;
X return((b>>bitweight)&1);
X}
X#endif
X
X/* Dumps an ASCII version of the SFP raster r, to line n.
X Normally only for debugging, but is also used from pktype
X */
X
Xdumpr(r, n)
Xstruct ras *r;
Xint n; {
X int x, y;
X if (!diagFile)
X return;
X fprintf(diagFile, "\n");
X for (y = 0; y < n; y++) {
X fprintf(diagFile, "%3d ", y);
X for (x = 0; x < r->ras_width; x++) {
X if (rastbit(x, y, r))
X putc('*', diagFile);
X else
X putc(' ', diagFile);
X }
X putc('\n', diagFile);
X }
X}
X
Xstatic long
Xpkpack(pc,r)
Xregister struct pkc *pc;
Xregister struct ras *r; {
X long i, j;
X long pkpackret;
X i = getnyb();
X if (i == 0) {
X do {
X j = getnyb();
X i++;
X } while(!j);
X while(i--)
X j = (j << 4) + getnyb();
X pkpackret = (j - 15 + (13 - dyn_f) * 16 + dyn_f);
X } else if (i <= dyn_f)
X pkpackret = (i);
X else if (i < 14)
X pkpackret = ((i - dyn_f - 1)*16 + getnyb() + dyn_f + 1);
X else {
X if (repeatcount) {
X pkmsg("Second repeat count for this row!\n");
X exit(1);
X }
X if (i == 14)
X repeatcount = pkpack(pc,r);
X else
X repeatcount = 1;
X /*sendout(1, repeatcount, pc, r);*/
X pkpackret = (pkpack(pc,r));
X }
X if (pkpackret < 1) {
X pkmsg("pkpack returned < 1! (%s)", filename);
X exit(1);
X }
X return(pkpackret);
X}
X
Xstatic
Xgetpbits(pc, r)
Xregister struct pkc *pc;
Xregister struct ras *r; {
X register int h_bit = pc->pkc_width,
X count,
X turnon;
X turnon = pc->pkc_flag&0x8;
X dyn_f = pc->pkc_dyn_f;
X repeatcount = 0;
X r->ras_xcur = r->ras_ycur = 0;
X while(r->ras_ycur < pc->pkc_height) {
X count = pkpack(pc,r);
X while(count > 0) {
X if (count >= h_bit) {
X count -= h_bit;
X while(h_bit--) {
X if (turnon)
X r->ras_raster[r->ras_ycur*r->ras_bline + (r->ras_xcur>>3)]
X |= (0x80 >> (r->ras_xcur&7));
X r->ras_xcur++;
X }
X r->ras_ycur++;
X r->ras_xcur = 0;
X while(repeatcount --) {
X#ifdef VDEBUG
X DBP((D_PK, "Copy line %d to %d\n", r->ras_ycur,
X r->ras_ycur-1));
X#endif
X memcpy((char*)&(r->ras_raster[r->ras_ycur * r->ras_bline]),
X (char*)&(r->ras_raster[(r->ras_ycur - 1) *
X r->ras_bline]),
X (int) r->ras_bline);
X r->ras_ycur++;
X }
X repeatcount = 0;
X h_bit = pc->pkc_width;
X } else {
X h_bit -= count;
X while(count--) {
X if (turnon)
X r->ras_raster[r->ras_ycur*r->ras_bline +
X (r->ras_xcur>>3)] |= (0x80 >> (r->ras_xcur&7));
X r->ras_xcur++;
X }
X count = 0;
X }
X }
X turnon = !turnon;
X }
X if (r->ras_ycur != pc->pkc_height ||
X h_bit != pc->pkc_width)
X pkmsg("Bad bit somehow (%s)\n", filename);
X}
X
Xstatic
Xgetrbits(pc, r)
Xregister struct pkc *pc;
Xregister struct ras *r; {
X register int x, y;
X register int bit = 0;
X for (y = 0; y < pc->pkc_height; y++) {
X for (x = 0; x < pc->pkc_width; x++) {
X if (pc->pkc_pkr[bit >> 3] & (0x80 >> (bit&7)))
X r->ras_raster[y*r->ras_bline + (x>>3)] |= (0x80 >> (x&7));
X bit++;
X }
X }
X}
X
X/* Convert a PK raster to an unpacked SFP version.
X (If there's already an SFP version, it's returned instead)
X */
Xstruct ras *
Xpkrast(pc)
Xstruct pkc *pc; {
X register struct ras *r;
X if (pc->pkc_sfpr)
X return(pc->pkc_sfpr);
X if (!pc->pkc_rlen)
X return(NULL);
X
X pc->pkc_sfpr = r = (struct ras *) mustmalloc(sizeof(struct ras),
X filename);
X
X r->ras_height = pc->pkc_height;
X r->ras_width = pc->pkc_width;
X r->ras_bline = (pc->pkc_width + 7) / 8;
X r->ras_bytes = r->ras_height * r->ras_bline;
X r->ras_raster = (int8 *) mustmalloc((int) r->ras_bytes, filename);
X
X /* initialize bit unpackers */
X rptr = pc->pkc_pkr;
X bitweight = 8;
X
X /* calculate bits here...*/
X if (pc->pkc_dyn_f == 14)
X getrbits(pc, r);
X else
X getpbits(pc, r);
X return(r);
X}
X
X/* Read a PK font file header */
Xstatic struct pkp *
Xpk_rpk(p)
Xregister struct pkp *p; {
X register int i,c;
X
X if (getc(fin) != 89) {
X pkmsg("PK file %s: Wrong version of packed file!\n", filename);
X exit(1);
X }
X i = getc(fin);
X if (i > 0) {
X DBP((D_PK, "PKVersion: "));
X while (i--) {
X c = getc(fin);
X DBP((D_PK, "%c", c));
X }
X DBP((D_PK, "\n"));
X }
X p->pkp_bmax = 0;
X p->pkp_dmax = 0;
X p->pkp_wmax = 0;
X p->pkp_xomax = 0;
X p->pkp_ds = get4int();
X p->pkp_cs = get4int();
X p->pkp_hppp = get4int();
X p->pkp_vppp = get4int();
X
X if (p->pkp_hppp != p->pkp_vppp)
X pkmsg("PK file %s: Warning aspect ratio not 1:1\n", filename);
X p->pkp_res = (double) p->pkp_hppp * POINT / pow2(16) + .5;
X p->pkp_npts = ((double) p->pkp_ds / pow2(20)) *
X ((double) p->pkp_res / OUTRES) + .5;
X p->pkp_chars = (struct pkc *) NULL;
X p->pkp_last = (struct pkc *) NULL;
X p->pkp_num = 0;
X p->pkp_list = (struct pkc **) NULL;
X
X /* Try to guess symset, style, stroke weight and typeface
X These aren't particularly important, but it assists the LJ
X if it's trying to select one of these via characteristic.
X This will only work if the file name reflects the Troff name,
X according to the following conventions:
X
X filename: {<path>/}troffname.pointsize.[pk|sfp]
X
X All ROMAN8 encodings unless MATH8.
X All 0 strokeweight, unless Bold.
X All upright, unless Italic
X All Roman typeface, unless otherwise specified
X
X R : Normal Roman
X I : Italic
X B : Bold
X S : MATH8 Symbol
X X : Bold italic
X .X : <typeface> Bold italic
X .I : <typeface> Italic
X .B : <typeface> Bold
X .R : <typeface> Normal
X H or H. : Helvetica typeface
X C or C. : Courier typeface
X typefaces should be extended.
X */
X
X {
X register char *fp;
X register int char1, char2, italic, bold, bolditalic, onechar;
X
X fp = strrchr(filename, '/');
X if (!fp)
X fp = filename;
X else
X fp++;
X
X /* Default settings */
X p->pkp_symset = (8 << 5) - 64 + 'U'; /* ROMAN 8 */
X p->pkp_style = 0; /* upright */
X p->pkp_sw = 0; /* stroke 0 */
X p->pkp_typeface = 5; /* typeface Roman */
X
X char1 = *fp++;
X onechar = (*fp == '.');
X
X if (char1 == 'S' && onechar)
X p->pkp_symset = (8 << 5) - 64 + 'M'; /* MATH 8 */
X else {
X
X char2 = *fp;
X
X italic = ((onechar && char1 == 'I') || char2 == 'I');
X bold = ((onechar && char1 == 'B') || char2 == 'B');
X bolditalic = ((onechar && char1 == 'X') || char2 == 'X');
X
X if (bold || bolditalic)
X p->pkp_sw = 3;
X
X if (italic || bolditalic)
X p->pkp_style = 1;
X
X /* This should be extended, but I don't have a good feeling
X for troff typeface -> HPLJ nomenclature */
X switch(char1) {
X case 'H':
X p->pkp_typeface = 4; /* Helvetica */
X break;
X case 'C':
X p->pkp_typeface = 3; /* Courier */
X break;
X /* more? */
X }
X }
X }
X
X return(p);
X}
X
X#ifdef SFP
X
X/* Read an SFP header and convert it into the PK internal structure.
X */
Xstatic struct pkp *
Xpk_rsfp(p)
Xregister struct pkp *p; {
X register int c;
X int len;
X
X if (fscanf(fin, ")s%dW", &len) != 1) {
X pkmsg("SFP file %s: Bad CREATE FONT sequence\n", filename);
X exit(1);
X }
X
X if (len < 26) {
X pkmsg("SFP file %s: CREATE FONT sequence too short (%d)\n",
X filename, len);
X exit(1);
X }
X
X get2int(); /* 26 */
X get1int(); /* 0 */
X get1int(); /* 0 or 1 - forced 1 anyways */
X get2int(); /* dummy */
X
X p->pkp_bmax = get2int(); /* baseline */
X p->pkp_wmax = get2int(); /* cell width */
X p->pkp_dmax = get2int() - p->pkp_bmax; /* cell height */
X
X get1int(); /* 0 port, 1 land - forced 0 */
X get1int(); /* fixed/proportional - forced proportional */
X
X p->pkp_symset = get2int();
X
X get2int(); /* pitch - we calculate this from height */
X c = get2int(); /* retrieved *height* */
X p->pkp_npts = c * POINT / (OUTRES*4) + .5;
X
X get2int(); /* dummy */
X get1int(); /* dummy */
X
X p->pkp_style = get1int();
X p->pkp_sw = get1int();
X p->pkp_typeface = get1int();
X
X p->pkp_xomax = 0;
X
X /* These are simulated so that the PK handlers can figure the font out */
X p->pkp_ds = p->pkp_npts * pow2(20);
X p->pkp_cs = 0;
X p->pkp_hppp = OUTRES * pow2(16) / POINT;
X p->pkp_vppp = OUTRES * pow2(16) / POINT;
X p->pkp_res = (double) p->pkp_hppp * POINT / pow2(16) + .5;
X
X p->pkp_chars = (struct pkc *) NULL;
X p->pkp_last = (struct pkc *) NULL;
X p->pkp_num = 0;
X p->pkp_list = (struct pkc **) NULL;
X
X
X len -= 26;
X while(len--)
X getc(fin);
X return(p);
X}
X#endif
X
Xstatic struct pkp *
Xreadhead() {
X register struct pkp *p = (struct pkp *) mustmalloc(sizeof(struct pkp),
X filename);
X switch(getc(fin)) {
X case PK_pre:
X p->pkp_flags |= PK_PK;
X return(pk_rpk(p));
X#ifdef SFP
X case 0x1b:
X p->pkp_flags |= PK_SFP;
X flag_byte = 0;
X return(pk_rsfp(p));
X#endif
X default:
X fprintf(stderr, "PK file: %s don't know what it is!\n",
X filename);
X exit(1);
X }
X /*NOTREACHED*/
X}
X
Xpk_destroy(p)
Xregister struct pkp *p; {
X register struct pkc *pc, *opc;
X for (pc = p->pkp_chars; pc;) {
X if (pc->pkc_pkr)
X free((char *) pc->pkc_pkr);
X
X if (pc->pkc_sfpr) {
X free((char *) pc->pkc_sfpr->ras_raster);
X free((char *) pc->pkc_sfpr);
X }
X
X opc = pc;
X pc = opc->pkc_next;
X free((char *) opc);
X }
X if (p->pkp_list)
X free((char *) p->pkp_list);
X free((char *) p);
X}
X
Xstruct pkp *
Xpk_read(file, fontcode)
Xchar *file; int fontcode; {
X register struct pkp *p;
X register struct pkc *pc, **pcp;
X#ifdef COMPRESS
X int compressed = 0;
X#endif
X fin = (FILE *) NULL;
X if (access(filename = file, 4) == 0)
X fin = fopen(filename, "r");
X#ifdef COMPRESS
X else {
X char buf[1024];
X strcpy(buf, file);
X strcat(buf, ".Z");
X if (access(buf, 4) == 0) {
X sprintf(buf, "%s %s.Z", COMPRESS, file);
X fin = popen(buf, "r");
X compressed = 1;
X }
X }
X#endif
X if (!fin) {
X pkmsg("Cannot open PK/SFP file %s\n", file);
X exit(1);
X }
X p = readhead();
X if (p->pkp_flags&PK_PK)
X skipspecials();
X
X while ((flag_byte != PK_post) && (pc = readchar(p))) {
X DBP((D_VERB, "type: %s: %d\n", p->pkp_flags&PK_PK? "PK": "SFP",
X pc->pkc_char));
X#ifdef PARTIAL
X if (!needchar(fontcode, pc->pkc_char)) {
X DBP((D_FONT|D_PK, "Dropping char %02x from load\n", pc->pkc_char));
X
X if (pc->pkc_pkr) {
X free((char *) pc->pkc_pkr);
X pc->pkc_pkr = (int8 *) NULL;
X }
X
X if (pc->pkc_sfpr) {
X free((char *) pc->pkc_sfpr->ras_raster);
X free((char *) pc->pkc_sfpr);
X pc->pkc_sfpr = (struct ras *) NULL;
X }
X
X free((char *) pc);
X if (p->pkp_flags&PK_PK)
X skipspecials();
X continue;
X }
X#endif
X DBP((D_FONT|D_PK, "Loading char %02x\n", pc->pkc_char));
X p->pkp_num++;
X pc->pkc_next = (struct pkc *) NULL;
X if (!p->pkp_chars)
X p->pkp_chars = pc;
X if (p->pkp_last)
X p->pkp_last->pkc_next = pc;
X p->pkp_last = pc;
X if (p->pkp_flags&PK_PK) {
X p->pkp_bmax = max(p->pkp_bmax, pc->pkc_y_off);
X p->pkp_dmax = max(p->pkp_dmax, pc->pkc_height - pc->pkc_y_off);
X p->pkp_wmax = max(p->pkp_wmax, pc->pkc_width - pc->pkc_x_off);
X }
X p->pkp_xomax = min(p->pkp_xomax, pc->pkc_x_off);
X if (pc->pkc_char == 'a') {
X p->pkp_kh = pc->pkc_y_off;
X p->pkp_kl = pc->pkc_y_off - pc->pkc_height;
X }
X if (p->pkp_flags&PK_PK)
X skipspecials();
X }
X DBP((D_FONT|D_PK, "End of font\n"));
X#ifdef COMPRESS
X if (compressed) {
X if (pclose(fin)) {
X pkmsg("Decompression of %s failed\n", file);
X exit(1);
X }
X } else
X#endif
X fclose(fin);
X pcp = p->pkp_list = (struct pkc **)
X mustmalloc((int) (p->pkp_num * sizeof(struct pkc *)), filename);
X for (pc = p->pkp_chars; pc; pc = pc->pkc_next)
X *pcp++ = pc;
X qsort(p->pkp_list, (unsigned) p->pkp_num, sizeof(struct pkc *), pkccomp);
X return(p);
X}
X
X/* Emit routines */
X
X/* Emit a font descriptor in SFP format */
Xepk_desc(p, sfp)
Xregister struct pkp *p;
XFILE *sfp; {
X
X fprintf(sfp, "\033)s26W");
X fputshort(26, sfp);
X fputc(0, sfp);
X fputc(1, sfp); /* font type 1 (33-127 && 160-255 printable) */
X fputshort(0, sfp);
X fputshort(p->pkp_bmax, sfp); /* baseline position */
X fputshort(p->pkp_wmax, sfp); /* cell width */
X fputshort(p->pkp_bmax + p->pkp_dmax, sfp); /* cell height */
X fputc(0, sfp); /* portrait */
X fputc(1, sfp); /* proportional */
X
X fputshort((long) p->pkp_symset, sfp);
X
X fputshort((long) (OUTRES * p->pkp_npts * 4) / 120, sfp);
X fputshort((long) (p->pkp_npts * (OUTRES / POINT) * 4), sfp);
X fputshort(0, sfp);
X fputc(0, sfp);
X fputc(p->pkp_style, sfp);
X fputc(p->pkp_sw, sfp);
X fputc(p->pkp_typeface, sfp);
X
X}
X
Xfputshort(val, f)
XFILE *f;
Xlong val; {
X fputc(((int) val >> 8) & 0xff, f);
X fputc((int) val & 0xff, f);
X}
X
X
X/* Emit a character descriptor in SFP format.
X Notes: if this is a PK font, the PK raster is converted
X to SFP format and dumpped. If the font was originally
X SFP format, it's dumpped directly. In either event, epkc_desc
X deletes the SFP raster *and* the PK raster (if the character
X has one), meaning that once this routine has emitted a character,
X you can't emit it again! Which is why pkc's pkflush completely
X destroys the font. Why? Well, SFP's can get rather large, and
X it seems reasonable to get rid of them as quickly as possible.
X
X Returns number of bytes emitted.
X */
Xepkc_desc(pc, sfp)
Xregister struct pkc *pc;
Xregister FILE *sfp; {
X register struct ras *r;
X
X if (!pc->pkc_pkr && !pc->pkc_sfpr) {
X fprintf(stderr, "%s: already downloaded %02x\n", pc->pkc_char);
X return(0);
X }
X
X /* Emit SET CHARACTER sequence */
X fprintf(sfp, "\033*c%dE", pc->pkc_char);
X
X /* Emit DOWNLOAD CHARACTER sequence */
X fprintf(sfp, "\033(s%dW", 16 + ((pc->pkc_width + 7) / 8) *
X pc->pkc_height);
X fputc(4, sfp);
X fputc(0, sfp);
X fputc(14, sfp);
X fputc(1, sfp);
X fputc(0, sfp); /* portrait */
X fputc(0, sfp);
X fputshort(-pc->pkc_x_off, sfp);
X fputshort(pc->pkc_y_off, sfp);
X fputshort(pc->pkc_width, sfp);
X fputshort(pc->pkc_height, sfp);
X fputshort(pc->pkc_dx * 4 / pow2(16), sfp);
X r = pkrast(pc);
X
X if (pc->pkc_pkr)
X free((char *) pc->pkc_pkr);
X pc->pkc_pkr = (int8 *) NULL;
X
X if (r) {
X#ifdef VDEBUG
X dumpr(r, r->ras_ycur);
X#endif
X fwrite((char *) r->ras_raster, 1, (int) ((pc->pkc_width + 7) / 8) *
X (int) pc->pkc_height, sfp);
X free((char *) r->ras_raster);
X free((char *) r);
X }
X pc->pkc_sfpr = (struct ras *) NULL;
X return(((pc->pkc_width + 7) / 8) * pc->pkc_height);
X}
X#endif
END_OF_FILE
if test 21373 -ne `wc -c <'pk.c'`; then
echo shar: \"'pk.c'\" unpacked with wrong size!
fi
# end of 'pk.c'
fi
if test -f 'utils/maps/alnum.ROMAN8' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'utils/maps/alnum.ROMAN8'\"
else
echo shar: Extracting \"'utils/maps/alnum.ROMAN8'\" \(206 characters\)
sed "s/^X//" >'utils/maps/alnum.ROMAN8' <<'END_OF_FILE'
X# 2.1 90/07/18 for simple merging of other fonts.
X0x30
X0x31
X0x32
X0x33
X0x34
X0x35
X0x36
X0x37
X0x38
X0x39
X@
XA
XB
XC
XD
XE
XF
XG
XH
XI
XJ
XK
XL
XM
XN
XO
XP
XQ
XR
XS
XT
XU
XV
XW
XX
XY
XZ
Xa
Xb
Xc
Xd
Xe
Xf
Xg
Xh
Xi
Xj
Xk
Xl
Xm
Xn
Xo
Xp
Xq
Xr
Xs
Xt
Xu
Xv
Xw
Xx
Xy
Xz
END_OF_FILE
if test 206 -ne `wc -c <'utils/maps/alnum.ROMAN8'`; then
echo shar: \"'utils/maps/alnum.ROMAN8'\" unpacked with wrong size!
fi
# end of 'utils/maps/alnum.ROMAN8'
fi
if test -f 'utils/psdtwd.S' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'utils/psdtwd.S'\"
else
echo shar: Extracting \"'utils/psdtwd.S'\" \(18900 characters\)
sed "s/^X//" >'utils/psdtwd.S' <<'END_OF_FILE'
X%%STARTSHELL%%
X# Most of this program was written by Michael Rourke (see below)
X# to generate ditroff width tables from Postscript. The original
X# name (as distributed in tpscript) was genftable. It has been
X# extended to support more fonts than the original, plus attempt
X# to handle non-builtin fonts. This shell script's output should
X# be sent to your postscript printer, and the printer will send
X# back up the serial link a series of shars containing the
X# width tables.
X#
X# The program goes through all existing characters in the font
X# to print width information in ditroff format. The name of each
X# character's drawing routine is used to look up how to print the
X# width information. There are three tables: the standard-encoding,
X# symbol-encoding and ascii-map. The first two are dictionaries,
X# the third is an array. If the font you've asked for is "Symbol",
X# the symbol-encoding dictionary is used, otherwise standard-encoding.
X# If the drawing routine isn't in the selected dictionary, the
X# character code is used to look up in ascii-map for a new name.
X# The new name is then searched for in standard-encoding to print the
X# width information.
X#
X# This latter kludge is necessary for fonts that don't use the
X# standard naming conventions, and will work sanely only for characters
X# 32 (space) thru 126 (tilde).
X#
X# usage: psdtwd <arguments>
X#
X# if there are no arguments, pstdwd will generate widths for
X# all of the fonts that are listed at the end of this shell
X# script. Arguments are usually repeated quoted
X# strings of the form:
X# /psname /intname /catname fontinfo
X# Where psname is the Postscript name of the font. intname is
X# a shortened name (which psroff doesn't care about, but ditroff
X# does apparently), catname is the one or two character name that
X# cat will know it by (and will be the name of the resultant shar),
X# and fontinfo is itself.
X# If the argument is a readable filename instead, it is inserted.
X# For example:
X# ./psdtwd hwfont "/HaeberliWriting /HaeberliW /HW fontinfo" \
X# "/Times-Roman /Roman /R fontinfo"
X# will insert file hwfont (usually containing the definition of the
X# subsequent argument), and generate the widths in a file HW of
X# the HaeberliWriting font, plus the widths for the "Times-Roman"
X# font in R.
Xif [ $# = 0 ]
Xthen
X all=1
Xelse
X while [ $# != 0 ]
X do
X if [ -r $1 ]
X then
X files="$files $1"
X else
X lines="$lines $1"
X fi
X shift
X done
Xfi
Xcat <<'END'
X%!
X% psdtwd - Postcript program to produce font tables for ditroff.
X% Tables are output on the standard output file - which
X% needs to be captured by the host computer.
X%
X% Note the routine "commondefs" which outputs local
X% defined (hand built) characters.
X%
X% Michael Rourke, University of N.S.W., Australia
X% (included in troff2: 2.1 90/07/18)
X/SAVEOBJ save def
X
X/t 30 string def
X
X(Starting psdtwd.ps `date`\n) print
Xflush
X
X/ps
X% string ->
X{
X print
X} def
X
X/pr
X% any -->
X{
X t cvs ps
X} def
X
X/prsp
X{
X (\t) ps
X} def
X
X/prnl
X{
X (\n) ps
X} def
X
X/pro
X% int -->
X{
X dup 0 eq
X { pr }
X { dup 8 idiv pro 8 mod pr }
X ifelse
X} def
X
X/charsize
X% string --> bot top
X{
X gsave
X newpath 0 0 moveto false charpath flattenpath pathbbox
X exch pop 3 -1 roll pop
X grestore
X} def
X
X/strwidth
X% string --> width
X{
X stringwidth pop round cvi
X} def
X
X/prsize
X% string -->
X{
X dup strwidth pr prsp
X dup charsize
X top gt { 2 } { 0 } ifelse
X exch bot lt { 1 or } if
X pr prsp
X 0 get pro
X} def
X
X/fontinfo
X% fontname troffinternal troffname
X{
X (\ncat <<"!" > ) ps dup pr prnl
X (# ) ps 2 index pr prnl
X (name ) ps pr prnl
X (internalname ) ps pr prnl
X dup findfont 100 scalefont setfont
X /fixedwidth false def
X /Symbol eq
X {
X /actions symbol-encoding def
X (special\n) ps
X }
X {
X /actions standard-encoding def
X currentfont /FontInfo get /isFixedPitch get
X {
X (# fixed width\n) ps
X /fixedwidth true def
X }
X {
X (ligatures fi fl ff ffi ffl 0\n) ps
X }
X ifelse
X }
X ifelse
X % use "o" to get top and bottom on a normal char
X (o) charsize /top exch def /bot exch def
X % some non ascending chars slightly higher than "o"
X % and some lower so adjust slightly
X /top top 2 add def
X /bot bot 4 sub def
X /encoding currentfont /Encoding get def
X /s 1 string def
X 0 1 255
X {
X dup /id exch def
X s 0 2 index put
X encoding exch get dup /.notdef ne
X {
X s 1 index actions exch
X % actions charfuncname
X 2 copy known
X {
X get
X % charname charstr /type
X exec
X flush
X }
X {
X % actions charfuncname
X pop
X ascii-map id get
X 2 copy known
X {
X get
X % charname charstr /type
X exec
X flush
X }
X {
X % charname charstr
X pop
X pop
X }
X ifelse
X }
X ifelse
X }
X {
X pop
X }
X ifelse
X } for
X actions standard-encoding eq { commondefs } if
X (!\n) ps flush
X} def
X
X/commondefs
X{
X /fracsize (0) strwidth (\244) strwidth add def % \244 = '/'
X /Fisize (f) strwidth (\256) strwidth add 5 sub def % \256 = 'fi'
X /ffsize (f) strwidth 2 mul 5 sub def
X /fl { flush } def
X fixedwidth not
X {
X (ff) ps prsp ffsize pr (\t2\t0100\tff ligature - faked\n) ps fl
X (Fi) ps prsp Fisize pr (\t2\t0100\tffi ligature - faked\n) ps fl
X (Fl) ps prsp Fisize pr (\t2\t0100\tffl ligature - faked\n) ps fl
X } if
X (12) ps prsp fracsize pr (\t2\t0100\t1/2 - faked\n) ps fl
X (13) ps prsp fracsize pr (\t2\t0100\t1/3 - faked\n) ps fl
X (14) ps prsp fracsize pr (\t2\t0100\t1/4 - faked\n) ps fl
X (18) ps prsp fracsize pr (\t2\t0100\t1/8 - faked\n) ps fl
X (23) ps prsp fracsize pr (\t2\t0100\t2/3 - faked\n) ps fl
X (34) ps prsp fracsize pr (\t2\t0100\t3/4 - faked\n) ps fl
X (38) ps prsp fracsize pr (\t2\t0100\t3/8 - faked\n) ps fl
X (58) ps prsp fracsize pr (\t2\t0100\t5/8 - faked\n) ps fl
X (78) ps prsp fracsize pr (\t2\t0100\t7/8 - faked\n) ps fl
X (sq\t100\t3\t0100\tsquare box - faked\n) ps fl
X} def
X
X/space
X% charname charstr -->
X{
X (spacewidth ) ps
X strwidth pr pop prnl
X (charset\n) ps
X} def
X
X/norm
X% charname charstr -->
X{
X dup pr prsp prsize pop prnl
X} def
X
X/normdup
X% charname charstr dupname -->
X{
X 3 1 roll norm
X pr prsp (") ps prnl
X} def
X
X/gnorm
X% charname charstr -->
X{
X (*) ps norm
X} def
X
X/map
X% charname charstr mapname -->
X{
X pr prsp prsize prsp pr prnl
X} def
X
X/mapdup
X% charname charstr mapname dupname -->
X{
X 4 1 roll map
X pr prsp (") ps prnl
X} def
X
X/mapdupdup
X% charname charstr mapname dupname dupname -->
X{
X 5 1 roll mapdup
X pr prsp (") ps prnl
X} def
X
X/cmap
X% charname charstr mapname -->
X{
X fixedwidth { 3 { pop } repeat } { map } ifelse
X} def
X
X/ascii-map 256 array def
X0 1 255 {ascii-map exch /exclam put} for
X
Xascii-map 32 /space put
Xascii-map 33 /exclam put
Xascii-map 34 /quotedbl put
Xascii-map 35 /numbersign put
Xascii-map 36 /dollar put
Xascii-map 37 /percent put
Xascii-map 38 /ampersand put
Xascii-map 39 /quoteright put
Xascii-map 40 /parenleft put
Xascii-map 41 /parenright put
Xascii-map 42 /asterisk put
Xascii-map 43 /plus put
Xascii-map 44 /comma put
Xascii-map 45 /hyphen put
Xascii-map 46 /period put
Xascii-map 47 /slash put
Xascii-map 48 /zero put
Xascii-map 49 /one put
Xascii-map 50 /two put
Xascii-map 51 /three put
Xascii-map 52 /four put
Xascii-map 53 /five put
Xascii-map 54 /six put
Xascii-map 55 /seven put
Xascii-map 56 /eight put
Xascii-map 57 /nine put
Xascii-map 58 /colon put
Xascii-map 59 /semicolon put
Xascii-map 60 /less put
Xascii-map 61 /equal put
Xascii-map 62 /greater put
Xascii-map 63 /question put
Xascii-map 64 /at put
Xascii-map 65 /A put
Xascii-map 66 /B put
Xascii-map 67 /C put
Xascii-map 68 /D put
Xascii-map 69 /E put
Xascii-map 70 /F put
Xascii-map 71 /G put
Xascii-map 72 /H put
Xascii-map 73 /I put
Xascii-map 74 /J put
Xascii-map 75 /K put
Xascii-map 76 /L put
Xascii-map 77 /M put
Xascii-map 78 /N put
Xascii-map 79 /O put
Xascii-map 80 /P put
Xascii-map 81 /Q put
Xascii-map 82 /R put
Xascii-map 83 /S put
Xascii-map 84 /T put
Xascii-map 85 /U put
Xascii-map 86 /V put
Xascii-map 87 /W put
Xascii-map 88 /X put
Xascii-map 89 /Y put
Xascii-map 90 /Z put
Xascii-map 91 /bracketleft put
Xascii-map 92 /backslash put
Xascii-map 93 /bracketright put
Xascii-map 94 /asciicircum put
Xascii-map 95 /underscore put
Xascii-map 96 /quoteleft put
Xascii-map 97 /a put
Xascii-map 98 /b put
Xascii-map 99 /c put
Xascii-map 100 /d put
Xascii-map 101 /e put
Xascii-map 102 /f put
Xascii-map 103 /g put
Xascii-map 104 /h put
Xascii-map 105 /i put
Xascii-map 106 /j put
Xascii-map 107 /k put
Xascii-map 108 /l put
Xascii-map 109 /m put
Xascii-map 110 /n put
Xascii-map 111 /o put
Xascii-map 112 /p put
Xascii-map 113 /q put
Xascii-map 114 /r put
Xascii-map 115 /s put
Xascii-map 116 /t put
Xascii-map 117 /u put
Xascii-map 118 /v put
Xascii-map 119 /w put
Xascii-map 120 /x put
Xascii-map 121 /y put
Xascii-map 122 /z put
Xascii-map 123 /braceleft put
Xascii-map 124 /bar put
Xascii-map 125 /braceright put
Xascii-map 126 /asciitilde put
X
X/standard-encoding 149 dict def
Xstandard-encoding begin
X /space { space } def
X /exclam { norm } def
X /quotedbl { norm } def
X /numbersign { norm } def
X /dollar { norm } def
X /percent { norm } def
X /ampersand { norm } def
X /quoteright { norm } def
X /parenleft { norm } def
X /parenright { norm } def
X /asterisk { norm } def
X /plus { norm } def
X /comma { norm } def
X /hyphen { (hy) normdup } def
X /period { norm } def
X /slash { (sl) dup } def
X /zero { norm } def
X /one { norm } def
X /two { norm } def
X /three { norm } def
X /four { norm } def
X /five { norm } def
X /six { norm } def
X /seven { norm } def
X /eight { norm } def
X /nine { norm } def
X /colon { norm } def
X /semicolon { norm } def
X /less { norm } def
X /equal { norm } def
X /greater { norm } def
X /question { norm } def
X /at { norm } def
X /A { norm } def
X /B { norm } def
X /C { norm } def
X /D { norm } def
X /E { norm } def
X /F { norm } def
X /G { norm } def
X /H { norm } def
X /I { norm } def
X /J { norm } def
X /K { norm } def
X /L { norm } def
X /M { norm } def
X /N { norm } def
X /O { norm } def
X /P { norm } def
X /Q { norm } def
X /R { norm } def
X /S { norm } def
X /T { norm } def
X /U { norm } def
X /V { norm } def
X /W { norm } def
X /X { norm } def
X /Y { norm } def
X /Z { norm } def
X /bracketleft { norm } def
X /backslash { norm } def
X /bracketright { norm } def
X /asciicircum { (a^) map } def
X /underscore { (ru) normdup } def
X /quoteleft { norm } def
X /a { norm } def
X /b { norm } def
X /c { norm } def
X /d { norm } def
X /e { norm } def
X /f { norm } def
X /g { norm } def
X /h { norm } def
X /i { norm } def
X /j { norm } def
X /k { norm } def
X /l { norm } def
X /m { norm } def
X /n { norm } def
X /o { norm } def
X /p { norm } def
X /q { norm } def
X /r { norm } def
X /s { norm } def
X /t { norm } def
X /u { norm } def
X /v { norm } def
X /w { norm } def
X /x { norm } def
X /y { norm } def
X /z { norm } def
X /braceleft { norm } def
X /bar { norm } def
X /braceright { norm } def
X /asciitilde { (a~) map } def
X /exclamdown { (I!) map } def
X /cent { (ct) map } def
X /sterling { (po) map } def
X /fraction { } def
X /yen { ($J) map } def
X /florin { } def
X /section { (sc) map } def
X /currency { } def
X /quotesingle { (fm) (n') mapdup } def
X /quotedblleft { (lq) map } def
X /guillemotleft { (d<) map } def
X /guilsinglleft { (l<) map } def
X /guilsinglright { (r>) map } def
X /fi { (fi) cmap } def
X /fl { (fl) cmap } def
X /endash { (\\-) map } def
X /dagger { (dg) map } def
X /daggerdbl { (dd) map } def
X /periodcentered { } def
X /paragraph { (pp) map } def
X /bullet { (bu) map } def
X /quotesinglbase { } def
X /quotedblbase { } def
X /quotedblright { (rq) map } def
X /guillemotright { (d>) map } def
X /ellipsis { } def
X /perthousand { (pm) cmap } def
X /questiondown { (I?) map } def
X /grave { (ga) (\\`) mapdup } def
X /acute { (aa) (\\') mapdup } def
X /circumflex { (^) map } def
X /tilde { (~) map } def
X /macron { (ma) map } def
X /breve { (be) map } def
X /dotaccent { (dt) map } def
X /dieresis { (..) (um) mapdup } def
X /ring { (ri) map } def
X /cedilla { (cd) map } def
X /hungarumlaut { ('') map } def
X /ogonek { (og) map } def
X /caron { (hc) map } def
X /emdash { (em) map } def
X /AE { (AE) cmap } def
X /ordfeminine { } def
X /Lslash { (PL) map } def
X /Oslash { (O/) map } def
X /OE { (OE) cmap } def
X /ordmasculine { } def
X /ae { (ae) cmap } def
X /dotlessi { (ui) map } def
X /lslash { (Pl) map } def
X /oslash { (o/) map } def
X /oe { (oe) cmap } def
X /germandbls { (ss) map } def
Xend
X
X/symbol-encoding 189 dict def
Xsymbol-encoding begin
X /space { space } def
X /exclam { norm } def
X /universal { (fa) map } def
X /numbersign { norm } def
X /existential { (te) map } def
X /percent { norm } def
X /ampersand { norm } def
X /suchthat { (cm) map } def
X /parenleft { norm } def
X /parenright { norm } def
X /asteriskmath { (**) map } def
X /plus { (pl) map } def
X /comma { norm } def
X /minus { (mi) normdup } def
X /period { norm } def
X /slash { (sl) map } def
X /zero { norm } def
X /one { norm } def
X /two { norm } def
X /three { norm } def
X /four { norm } def
X /five { norm } def
X /six { norm } def
X /seven { norm } def
X /eight { norm } def
X /nine { norm } def
X /colon { norm } def
X /semicolon { norm } def
X /less { norm } def
X /equal { (eq) normdup } def
X /greater { norm } def
X /question { norm } def
X /congruent { (=~) map } def
X /Alpha { gnorm } def
X /Beta { gnorm } def
X /Chi { (*X) map } def
X /Delta { gnorm } def
X /Epsilon { gnorm } def
X /Phi { gnorm } def
X /Gamma { gnorm } def
X /Eta { (*Y) map } def
X /Iota { gnorm } def
X /theta1 { } def
X /Kappa { gnorm } def
X /Lambda { gnorm } def
X /Mu { gnorm } def
X /Nu { gnorm } def
X /Omicron { gnorm } def
X /Pi { gnorm } def
X /Theta { (*H) map } def
X /Rho { gnorm } def
X /Sigma { gnorm } def
X /Tau { gnorm } def
X /Upsilon { gnorm } def
X /sigma1 { (ts) map } def
X /Omega { (*W) map } def
X /Xi { (*C) map } def
X /Psi { (*Q) map } def
X /Zeta { gnorm } def
X /bracketleft { norm } def
X /therefore { (tf) map } def
X /bracketright { norm } def
X /perpendicular { (bt) map } def
X /underscore { (ul) map } def
X /radicalex { } def
X /alpha { gnorm } def
X /beta { gnorm } def
X /chi { (*x) map } def
X /delta { gnorm } def
X /epsilon { gnorm } def
X /phi { gnorm } def
X /gamma { gnorm } def
X /eta { (*y) map } def
X /iota { gnorm } def
X /phi1 { } def
X /kappa { gnorm } def
X /lambda { gnorm } def
X /mu { gnorm } def
X /nu { gnorm } def
X /omicron { gnorm } def
X /pi { gnorm } def
X /theta { (*h) map } def
X /rho { gnorm } def
X /sigma { gnorm } def
X /tau { gnorm } def
X /upsilon { gnorm } def
X /omega1 { } def
X /omega { (*w) map } def
X /xi { (*c) map } def
X /psi { (*q) map } def
X /zeta { gnorm } def
X /braceleft { norm } def
X /bar { (or) normdup } def
X /braceright { norm } def
X /similar { (ap) map } def
X /Upsilon1 { } def
X /minute { (mt) map } def
X /lessequal { (<=) map } def
X /fraction { (/) map } def
X /infinity { (if) map } def
X /florin { } def
X /club { (Cc) map } def
X /diamond { (Cd) map } def
X /heart { (Ch) map } def
X /spade { (Cs) map } def
X /arrowboth { (<>) map } def
X /arrowleft { (<-) map } def
X /arrowup { (ua) map } def
X /arrowright { (->) map } def
X /arrowdown { (da) map } def
X /degree { (de) map } def
X /plusminus { (+-) map } def
X /second { (sd) map } def
X /greaterequal { (>=) map } def
X /multiply { (mu) map } def
X /proportional { (pt) map } def
X /partialdiff { (pd) map } def
X /bullet { } def
X /divide { (di) map } def
X /notequal { (!=) map } def
X /equivalence { (==) map } def
X /approxequal { (~=) map } def
X /ellipsis { } def
X /arrowvertex { } def
X /arrowhorizex { } def
X /carriagereturn { (cr) map } def
X /aleph { (al) map } def
X /Ifraktur { } def
X /Rfraktur { } def
X /weierstrass { } def
X /circlemultiply { (ax) map } def
X /circleplus { (a+) map } def
X /emptyset { (es) map } def
X /intersection { (ca) map } def
X /union { (cu) map } def
X /propersuperset { (sp) map } def
X /reflexsuperset { (ip) map } def
X /notsubset { (!s) map } def
X /propersubset { (sb) map } def
X /reflexsubset { (ib) map } def
X /element { (mo) map } def
X /notelement { (!m) (nm) mapdup } def
X /angle { (ag) map } def
X /gradient { (gr) map } def
X /registerserif { } def
X /copyrightserif { } def
X /trademarkserif { } def
X /product { } def
X /radical { (sr) map } def
X /dotmath { (m.) map } def
X /logicalnot { (no) map } def
X /logicaland { (an) (la) mapdup } def
X /logicalor { (lo) map } def
X /arrowdblboth { (io) map } def
X /arrowdblleft { (<:) (lh) mapdup } def
X /arrowdblup { (u=) map } def
X /arrowdblright { (:>) (rh) (im) mapdupdup } def
X /arrowdbldown { (d=) map } def
X /lozenge { (dm) map } def
X /angleleft { (L<) map } def
X /registersans { (rg) map } def
X /copyrightsans { (co) map } def
X /trademarksans { (tm) map } def
X /summation { } def
X /parenlefttp { } def
X /parenleftex { } def
X /parenleftbt { } def
X /bracketlefttp { } def
X /bracketleftex { } def
X /bracketleftbt { } def
X /bracelefttp { } def
X /braceleftmid { } def
X /braceleftbt { } def
X /braceex { } def
X /apple { (AL) map } def
X /angleright { (R>) map } def
X /integral { (is) map } def
X /integraltp { } def
X /integralex { } def
X /integralbt { } def
X /parenrighttp { } def
X /parenrightex { } def
X /parenrightbt { } def
X /bracketrighttp { } def
X /bracketrightex { } def
X /bracketrightbt { } def
X /bracerighttp { } def
X /bracerightmid { } def
X /bracerightbt { } def
Xend
XEND
Xif [ -n "$all" ]
Xthen
Xcat <<'END'
X /Times-Roman /Roman /R fontinfo
X /Helvetica /Helvetica /H fontinfo
X /Courier /Courier /C fontinfo
X /Symbol /Symbol /S fontinfo
X /Times-Italic /Italic /I fontinfo
X /Times-Bold /Bold /B fontinfo
X /Times-BoldItalic /BoldI /BI fontinfo
X /Helvetica-Bold /HelveticaB /HB fontinfo
X /Helvetica-Oblique /HelveticaO /HO fontinfo
X /Helvetica-BoldOblique /HelveticaBO /HX fontinfo
X /Courier-Bold /CourierB /CB fontinfo
X /Courier-Oblique /CourierO /CO fontinfo
X /Courier-BoldOblique /CourierBO /CX fontinfo
X /Helvetica-Narrow /HelvNarHn /Hn fontinfo
X /Helvetica-Narrow-Oblique /HelvNarHo /Ho fontinfo
X /Helvetica-Narrow-BoldOblique /HelvNarHx /Hx fontinfo
X /Helvetica-Narrow-Bold /HelvNarHb /Hb fontinfo
X /ZapfChancery-MediumItalic /ZapfC /ZC fontinfo
X /ZapfDingbats /ZapfD /ZD fontinfo
X /AvantGarde-Book /AvantAR /AR fontinfo
X /AvantGarde-BookOblique /AvantAX /AX fontinfo
X /AvantGarde-Demi /AvantAB /AB fontinfo
X /AvantGarde-DemiOblique /AvantAI /AI fontinfo
X /Palatino-Roman /PalatPR /PR fontinfo
X /Palatino-Bold /PalatPB /PB fontinfo
X /Palatino-BoldItalic /PalatPX /PX fontinfo
X /Palatino-Italic /PalatPI /PI fontinfo
X /NewCenturySchlbk-Bold /NewCB /NB fontinfo
X /NewCenturySchlbk-BoldItalic /NewCX /NX fontinfo
X /NewCenturySchlbk-Italic /NewCI /NI fontinfo
X /NewCenturySchlbk-Roman /NewCR /NR fontinfo
XEND
Xelse
X if [ -n "$files" ]
X then
X cat $files
X fi
X if [ -n "$lines" ]
X then
X echo $lines
X fi
Xfi
Xecho "SAVEOBJ restore"
Xecho "\004\c"
END_OF_FILE
if test 18900 -ne `wc -c <'utils/psdtwd.S'`; then
echo shar: \"'utils/psdtwd.S'\" unpacked with wrong size!
fi
# end of 'utils/psdtwd.S'
fi
echo shar: End of archive 3 \(of 16\).
cp /dev/null ark3isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 16 archives.
echo "Read the README to get started with psroff installation"
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still must unpack the following archives:
echo " " ${MISSING}
fi
exit 0
--
Chris Lewis, Phone: TBA
UUCP: uunet!utai!lsuc!ecicrl!clewis
Moderator of the Ferret Mailing List (ferret-request@eci386)
Psroff mailing list (psroff-request@eci386)