summaryrefslogtreecommitdiff
path: root/dviware/ln03/rose/toppnft.pli
diff options
context:
space:
mode:
Diffstat (limited to 'dviware/ln03/rose/toppnft.pli')
-rw-r--r--dviware/ln03/rose/toppnft.pli654
1 files changed, 654 insertions, 0 deletions
diff --git a/dviware/ln03/rose/toppnft.pli b/dviware/ln03/rose/toppnft.pli
new file mode 100644
index 0000000000..0ea9b4dd53
--- /dev/null
+++ b/dviware/ln03/rose/toppnft.pli
@@ -0,0 +1,654 @@
+%REPLACE true BY '1'B;
+%REPLACE false BY '0'B;
+%REPLACE maxnfonts BY 21;
+%REPLACE maxtexfonts BY 100;
+%REPLACE nblanks BY 0;
+%REPLACE leftfirst BY 33;
+%REPLACE leftlast BY 126;
+%REPLACE rightfirst BY 161;
+%REPLACE rightlast BY 254;
+
+/* This file contains those portions of LN03Topp that deal directly with
+the font file format (.NFT files). It is under development...
+
+Development chronology:
+
+11/28/84: Initial version. Wrote COPY_CHAR.
+
+11/29/84: GOOD_OPENING. Second thoughts about whole interface.
+ Merge the three functions into one.
+
+Copyright (c) 1983, 1984 by Digital Equipment Corporation. */
+
+/* The purpose of ADD_TXF_TO_LNF is to read an NFT file corresponding to
+TeX font TXFNO and place its rasters into the output font buffer. It
+returns the number of bytes by which the NFT file incremented the size of
+the output file, or a negative value to indicate lossage. */
+
+add_txf_to_lnf: PROCEDURE(lnfno,txfno,nftfname,outf) RETURNS(FIXED);
+
+ DCL nftfname CHAR(*);
+ DCL (txfno,lnfno) FIXED;
+ DCL outf FILE;
+
+ DCL (strip,frontstrip) EXTERNAL ENTRY (CHAR (*))
+ RETURNS (CHAR (*)),
+ cvis EXTERNAL ENTRY (FIXED) RETURNS (CHAR (*));
+
+ DCL lastch(0:maxnfonts) FIXED GLOBALREF;
+ DCL chw(0:maxnfonts,0:255) FIXED GLOBALREF;
+
+ DCL 1 txf BASED,
+ 2 nchs FIXED,
+ 2 chu(0:255) CHAR(1);
+ DCL txfa(0:maxtexfonts) PTR GLOBALREF;
+
+/* The buffer for the output fonts is currently of fixed size. Eventually
+it should be possible to chain a lot of these together so output fonts of
+unlimited size can be handled, subject only to virtual memory availability.
+*/
+
+ %REPLACE obuflen BY 131120;
+ DCL lnf(0:obuflen) CHAR(1) STATIC;
+ DCL (ras_len,psize,lsize,msize) FIXED STATIC;
+ DCL using_r BIT STATIC;
+
+/* Out of laziness, we read the entire input NFT file into a big array and
+then copy it. Obviously this is foolish; we should read it block by block
+only, and even use "random reading" if the RMS file type is suitable. */
+
+ DCL nfta(0:obuflen) CHAR(1);
+ DCL (i,j,k,nftlen) FIXED;
+
+ IF txfno < 0 | txfno > maxtexfonts | txfa(txfno) = Null() THEN
+ GOTO error_return;
+ IF lnfno < 0 | lnfno > maxnfonts THEN GOTO error_return;
+
+ PUT SKIP EDIT ('Loading font ' || nftfname) (A);
+
+ nftlen = 0;
+ CALL read_into_nfta;
+
+/* The NFT file comes to us in bytes. We need ways to understand it as
+words or longwords. When we need to parse some bytes as something, we copy
+them into the following overlaid variables. Note that unsigned quantities
+still require fixing. */
+
+ DCL longword FIXED;
+ DCL chars CHAR(4) BASED (Addr(longword));
+
+/* We make exactly one gratuitous test of NFT validity: the second longword
+must be 'FONT'. */
+
+ IF nfta(4) ^= 'F' | nfta(5) ^= 'O' | nfta(6) ^= 'N' | nfta(7) ^= 'T'
+ THEN GOTO bad_format;
+
+/* We also have to check that there are a full 16 bytes of character
+parameters. If there are fewer, we give up: it's too hard to figure out how
+to give the missing ones reasonable values. Maybe in the next version... */
+
+ %REPLACE fnt$l_parameters_size BY 200;
+ CALL nft_copy(fnt$l_parameters_size);
+ IF longword ^= 16 THEN GOTO bad_format;
+
+/* Figure out where the character directory in the NFT file begins */
+
+ %REPLACE fnt$a_char_directory BY 120;
+ DCL chardir_offset FIXED;
+
+/* CHARDIR_OFFSET should always equal 480. But we read it off the file
+anyway. */
+
+ CALL nft_copy(fnt$a_char_directory);
+ chardir_offset = longword;
+ IF chardir_offset <= 0 | chardir_offset > nftlen
+ THEN GOTO bad_format;
+
+/* Figure out what the lowest character in the NFT file is */
+
+ %REPLACE fnt$l_first_character BY 164;
+ DCL nft_first_ch FIXED;
+
+ nft_first_ch = rank(nfta(fnt$l_first_character));
+
+/* Now, determine if this is the first or last TXF which is being copied
+into this file. */
+
+ DCL (first_txfc,last_txfc) FIXED;
+ DCL (first_txf,last_txf) BIT;
+
+ first_txfc = -1; last_txfc = -1;
+ DO i = 0 TO 255;
+ IF txfa(txfno) -> chu(i) ^= byte(0) THEN DO;
+ IF first_txfc = -1 THEN first_txfc = rank(txfa(txfno) -> chu(i));
+ last_txfc = rank(txfa(txfno) -> chu(i));
+ END;
+ END;
+
+ IF first_txfc = -1 | last_txfc = -1 THEN DO;
+ PUT SKIP EDIT ('LN03Topp internal error - empty TXF passed to ' ||
+ 'ADD_TXF_TO_LNF') (A);
+ GOTO error_return;
+ END;
+
+ first_txf = (first_txfc = leftfirst+nblanks);
+ last_txf = (last_txfc = lastch(lnfno));
+
+/* If this is the first TXF, then we have to initialize the font buffer */
+
+ IF first_txf THEN DO;
+ using_r = false;
+ CALL initialize_lnf;
+ END;
+
+/* The initialization routine computes where the rasters begin in the
+output buffer, puts in the blanks, etc. */
+
+ DCL (lnf_chardir,ras_beg) FIXED STATIC;
+ DCL ras_len_added FIXED;
+
+ ras_len_added = 0;
+
+/* Now go through all the characters in the TeX font and copy them into the
+right position */
+
+ DO i = 0 TO 255;
+ IF txfa(txfno) -> chu(i) ^= byte(0)
+ THEN DO;
+ j = rank(txfa(txfno) -> chu(i));
+ IF ^using_r & j >= rightfirst THEN DO;
+ CALL write_lnf;
+ PUT SKIP EDIT (',') (A) FILE(outf);
+ using_r = true;
+ CALL initialize_lnf;
+ END;
+ CALL copy_char(i,j);
+ END;
+ END;
+
+/* If this is the last TXF for this LNF, write out the LNF. */
+
+ IF last_txf THEN CALL write_lnf;
+
+
+/* What we have to return is the incremental amount of space that the TXF
+takes up in the output font */
+
+ PUT EDIT (' with ' || cvis(ras_len_added+4*(txfa(txfno) -> nchs+nblanks))
+ || ' bytes of rasters ') (A);
+
+ RETURN(ras_len_added+4*(txfa(txfno) -> nchs+nblanks));
+
+error_return:
+ RETURN(-1);
+
+rasters_too_big:
+ RETURN(-2);
+
+bad_format:
+ RETURN(-3);
+
+ read_into_nfta: PROCEDURE;
+
+ DCL nftf FILE;
+ DCL nftline CHAR(512) VARYING;
+
+ ON ENDFILE (nftf) GOTO end_of_nftfile;
+ ON UNDEFINEDFILE (nftf) BEGIN;
+ PUT SKIP LIST('No such file:' || nftfname);
+ GOTO error_return;
+ END;
+
+ nftlen = 0;
+ OPEN FILE (nftf) TITLE (nftfname)
+ ENVIRONMENT(Default_file_name('TEX$LN03DIR:AMR10.NFT'))
+ RECORD;
+
+ DO WHILE (true);
+
+ READ FILE(nftf) INTO (nftline);
+ IF nftlen+length(nftline) > obuflen THEN DO;
+ PUT SKIP EDIT ('NFT file ' || nftfname || ' too large')
+ (A);
+ GOTO error_return;
+ END;
+ DO i = 1 TO length(nftline);
+ nfta(nftlen+i-1) = substr(nftline,i,1);
+ END;
+ nftlen = nftlen+length(nftline);
+
+ END;
+
+ end_of_nftfile:
+ CLOSE FILE (nftf);
+
+ END read_into_nfta;
+
+/* Copy the character corresponding to FROM out of NFTA and into the LNFR;
+update the CHW array. */
+
+ copy_char: PROCEDURE (from,to);
+ DCL (from,to,i,j) FIXED;
+ DCL (def_start,rows,columns,quo,len) FIXED;
+
+/* First we need to determine where the character definition for FROM
+begins in the NFTA array */
+
+ CALL nft_copy(chardir_offset+(from-nft_first_ch)*4);
+ def_start = longword;
+
+/* For the moment, if there is "no such character", we just stop.
+Eventually we should substitute some blank character or something. */
+
+ IF def_start < chardir_offset | def_start > nftlen THEN
+ GOTO bad_format;
+
+/* Now we need to check that the rasters are uncompressed. */
+
+ IF nfta(def_start+17) ^= byte(129) THEN DO;
+ PUT SKIP EDIT ('Can''t handle compressed rasters') (A);
+ GOTO bad_format;
+ END;
+
+/* Fill in the CHW array. Gutenberg to pixel conversion is necessary (there
+are 24 gutenbergs in a pixel), with rounding (hence the 12). */
+
+ CALL nft_copy(def_start+4);
+ chw(lnfno,to) = DIVIDE(longword+12,24,31);
+
+/* Because of the LN03's rounding algorithm, it is necessary also to
+change the value being copied to the rounded value */
+
+ longword = 24*chw(lnfno,to);
+ nfta(def_start+4) = substr(chars,1,1);
+ nfta(def_start+5) = substr(chars,2,1);
+ nfta(def_start+6) = substr(chars,3,1);
+ nfta(def_start+7) = substr(chars,4,1);
+
+/* Now we need to compute the size of the rasters, and copy that number of
+bytes into LNF as the case may be. */
+
+ rows = rank(nfta(def_start+20))+256*rank(nfta(def_start+21));
+ columns = rank(nfta(def_start+22))+256*rank(nfta(def_start+23));
+
+/* We have to update PSIZE, LSIZE and MSIZE to fill slots in the format. */
+
+ quo = DIVIDE(rows,8,31);
+ IF rows ^= quo*8 THEN quo = quo+1;
+ i = quo*columns;
+ lsize = lsize+quo*columns;
+ quo = DIVIDE(columns,8,31);
+ IF columns ^= quo*8 THEN quo = quo+1;
+ psize = psize+quo*rows;
+ IF i > quo*rows THEN msize = msize+i; ELSE msize = msize+quo*rows;
+
+/* Now do the actual copy */
+
+ IF MOD(rank(nfta(def_start+16)),2) = 0 THEN len = quo*rows;
+ ELSE len = i;
+ len = len+24;
+ DO i = 0 TO len-1;
+ lnf(ras_beg+ras_len+i) = nfta(def_start+i);
+ END;
+ longword = ras_len+ras_beg;
+ IF to <= leftlast THEN i = to-leftfirst; ELSE i = to-rightfirst;
+ lnf(lnf_chardir+4*i) = substr(chars,1,1);
+ lnf(lnf_chardir+4*i+1) = substr(chars,2,1);
+ lnf(lnf_chardir+4*i+2) = substr(chars,3,1);
+ lnf(lnf_chardir+4*i+3) = substr(chars,4,1);
+ ras_len = ras_len+len;
+ ras_len_added = ras_len_added+len;
+ IF MOD(ras_len,2) ^= 0 THEN DO;
+ ras_len = ras_len+1;
+ ras_len_added = ras_len_added+1;
+ END;
+
+ END copy_char;
+
+/* It would be much more efficient if the following were a macro. Later on
+maybe we'll do the macro expansion "by hand" in the code. */
+
+ nft_copy: PROCEDURE (index);
+ DCL index FIXED;
+
+ substr(chars,1,1) = nfta(index);
+ substr(chars,2,1) = nfta(index+1);
+ substr(chars,3,1) = nfta(index+2);
+ substr(chars,4,1) = nfta(index+3);
+
+ END nft_copy;
+
+/* write_lnf performs the last fixups to the lnf buffer and dumps it,
+sixelized, into the OUTF. */
+
+ write_lnf: PROCEDURE;
+
+ DCL preline CHAR(96);
+ DCL (i,j,k,rem,quo,ma) FIXED;
+
+/* We now have to fix a number of slots: size of file, length of rasters,
+final 'FONT', psize, lsize, msize. */
+
+ longword = ras_beg+ras_len+8;
+ lnf(0) = substr(chars,1,1);
+ lnf(1) = substr(chars,2,1);
+ lnf(2) = substr(chars,3,1);
+ lnf(3) = substr(chars,4,1);
+ lnf(longword-8) = substr(chars,1,1);
+ lnf(longword-7) = substr(chars,2,1);
+ lnf(longword-6) = substr(chars,3,1);
+ lnf(longword-5) = substr(chars,4,1);
+ lnf(longword-4) = 'F';
+ lnf(longword-3) = 'O';
+ lnf(longword-2) = 'N';
+ lnf(longword-1) = 'T';
+
+/* Length of rasters */
+
+ %REPLACE fnt$l_char_definitions_length BY 156;
+ longword = ras_len;
+ lnf(fnt$l_char_definitions_length) = substr(chars,1,1);
+ lnf(fnt$l_char_definitions_length+1) = substr(chars,2,1);
+ lnf(fnt$l_char_definitions_length+2) = substr(chars,3,1);
+ lnf(fnt$l_char_definitions_length+3) = substr(chars,4,1);
+
+ %REPLACE fnt$l_portrait_byte_count BY 228;
+ %REPLACE fnt$l_landscape_byte_count BY 232;
+ %REPLACE fnt$l_mixed_byte_count BY 236;
+
+ longword = psize;
+ lnf(fnt$l_portrait_byte_count) = substr(chars,1,1);
+ lnf(fnt$l_portrait_byte_count+1) = substr(chars,2,1);
+ lnf(fnt$l_portrait_byte_count+2) = substr(chars,3,1);
+ lnf(fnt$l_portrait_byte_count+3) = substr(chars,4,1);
+
+ longword = lsize;
+ lnf(fnt$l_landscape_byte_count) = substr(chars,1,1);
+ lnf(fnt$l_landscape_byte_count+1) = substr(chars,2,1);
+ lnf(fnt$l_landscape_byte_count+2) = substr(chars,3,1);
+ lnf(fnt$l_landscape_byte_count+3) = substr(chars,4,1);
+
+ longword = msize;
+ lnf(fnt$l_mixed_byte_count) = substr(chars,1,1);
+ lnf(fnt$l_mixed_byte_count+1) = substr(chars,2,1);
+ lnf(fnt$l_mixed_byte_count+2) = substr(chars,3,1);
+ lnf(fnt$l_mixed_byte_count+3) = substr(chars,4,1);
+
+/* Now sixelize and write the contents of LNF. */
+
+ CALL sixelize_and_write(ras_beg+ras_len+8);
+
+ sixelize_and_write: PROCEDURE (howmuch);
+ DCL (howmuch,quo,i,j) FIXED;
+
+ quo = DIVIDE(howmuch,96,31);
+ IF howmuch > quo*96 THEN quo = quo+1;
+
+ DO i = 1 TO quo;
+ DO j = 1 TO 96;
+ substr(preline,j,1) = lnf(96*(i-1)+j-1);
+ END;
+ CALL write_preline;
+ END;
+
+ END sixelize_and_write;
+
+ write_preline: PROCEDURE;
+ DCL sixel_line CHAR(128) VARYING;
+ DCL (ix,pllen) FIXED;
+
+ pllen = 96;
+
+ ix = 1;
+ sixel_line = copy('?',128);
+ DO i = 1 TO pllen BY 3;
+ DCL cha CHAR(1);
+ DCL chb BIT(8) BASED (addr(cha));
+ DCL chc FIXED(7) BASED (addr(cha));
+ DCL ocha CHAR(1);
+ DCL ochb BIT(8) BASED(addr(ocha));
+
+ chc = 0;
+ ocha = substr(preline,i,1);
+ substr(chb,1,6) = substr(ochb,3,6);
+ chc = chc + 63;
+ substr(sixel_line,ix,1) = cha;
+ ix = ix+1;
+ chc = 0;
+ substr(chb,5,2) = substr(ochb,1,2);
+ ocha = substr(preline,i+1,1);
+ substr(chb,1,4) = substr(ochb,5,4);
+ chc = chc + 63;
+ substr(sixel_line,ix,1) = cha;
+ ix = ix+1;
+ chc = 0;
+ substr(chb,3,4) = substr(ochb,1,4);
+ ocha = substr(preline,i+2,1);
+ substr(chb,1,2) = substr(ochb,7,2);
+ chc = chc + 63;
+ substr(sixel_line,ix,1) = cha;
+ ix = ix+1;
+ chc = 0;
+ substr(chb,1,6) = substr(ochb,1,6);
+ chc = chc + 63;
+ substr(sixel_line,ix,1) = cha;
+ ix = ix+1;
+ END;
+ PUT SKIP EDIT (sixel_line) (A) FILE(outf);
+
+ END write_preline;
+
+ END write_lnf;
+
+/* Initializes the LNF buffer. */
+
+ initialize_lnf: PROCEDURE;
+
+ DCL (i,j) FIXED;
+
+/* The following array holds good values for bytes 0-479 of an LN03 format
+font. */
+
+ DCL good_opening(0:511) FIXED STATIC INIT(
+ 104,38,0,0,70,79,78,84,
+ 1,0,0,0,31,0,0,0,
+ 20,0,0,0,85,48,48,48,
+ 48,48,48,48,48,50,83,75,
+ 48,48,71,71,48,48,48,49,
+ 85,90,90,90,90,48,50,70,
+ 48,48,48,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 181,7,9,0,11,0,14,0,
+ 0,0,0,0,104,0,0,0,
+ 252,0,0,0,124,0,0,0,
+ 100,1,0,0,120,1,0,0,
+ 224,1,0,0,4,0,0,0,
+ 88,3,0,0,0,0,0,0,
+ 92,3,0,0,48,0,0,0,
+ 92,3,0,0,0,0,0,0,
+ 140,3,0,0,212,34,0,0,
+ 140,3,0,0,33,0,0,0,
+ 126,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 32,0,0,0,168,0,0,0,
+ 16,0,0,0,94,0,0,0,
+ 0,0,0,0,94,0,0,0,
+ 0,0,0,0,94,0,0,0,
+ 0,0,0,0,236,25,0,0,
+ 54,25,0,0,14,27,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,2,0,0,0,
+ 7,0,0,0,92,3,0,0,
+ 7,0,0,0,99,3,0,0,
+ 16,0,0,0,106,3,0,0,
+ 16,0,0,0,122,3,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 10,0,0,0,244,1,0,0,
+ 0,0,24,0,16,0,0,0,
+ 16,0,0,0,1,0,1,0,
+ 1,0,1,0,0,0,1,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 30,0,0,0,20,0,0,0,
+ 196,255,255,255,20,0,0,0,
+ 106,255,255,255,20,0,0,0,
+ 0,0,1,0,0,0,30,0,
+ 166,255,255,255,0,0,0,0,
+ 40,0,0,0,0,0,0,0,
+ 60,0,0,0,240,0,0,0,
+ 60,0,0,0,100,0,0,0,
+ 240,0,0,0,120,0,0,0,
+ 40,0,0,0,120,0,0,0,
+ 96,255,255,255,136,255,255,255,
+ 186,255,255,255,240,0,0,0,
+ 76,255,255,255,60,0,0,0,
+ 160,0,0,0,120,0,0,0,
+ 20,0,0,0,20,0,0,0,
+ 140,3,0,0,194,3,0,0,
+ 244,3,0,0,160,4,0,0,
+ 254,4,0,0,162,5,0,0,
+ 46,6,0,0,84,6,0,0);
+
+ lnf_chardir = 480; /* Fixed */
+
+ /* Clear out LNF */
+
+ lnf = byte(0);
+ ras_len = 0;
+ psize = 0;
+ lsize = 0;
+ msize = 0;
+
+ /* Copy the good values into LNF */
+
+ DO i = 0 TO 479;
+ lnf(i) = byte(good_opening(i));
+ END;
+
+ /* Set the last character if necessary */
+
+ IF lastch(lnfno) < leftlast & ^using_r
+ THEN lnf(fnt$l_first_character+4) = byte(lastch(lnfno));
+ IF using_r
+ THEN lnf(fnt$l_first_character+4) = byte(lastch(lnfno)-rightfirst+
+ leftfirst);
+
+ /* Set the character counts */
+
+ %REPLACE fnt$l_infile_locators BY 204;
+ %REPLACE fnt$l_character_definitions BY 212;
+ %REPLACE fnt$l_raster_count BY 220;
+
+ i = rank(lnf(fnt$l_first_character+4))-
+ rank(lnf(fnt$l_first_character))+1;
+ ras_beg = lnf_chardir + 4*i + 4 + 48;
+ lnf(fnt$l_infile_locators) = byte(i);
+ lnf(fnt$l_character_definitions) = byte(i);
+ lnf(fnt$l_raster_count) = byte(i);
+
+/* Set the font file id. The font family is dependent on the value of
+LNFNO, U0000nn where nn is LNFNO possibly with a leading zero. The
+character set is 1O if USING_R, otherwise the default from GOOD_OPENING. */
+
+ %REPLACE fnt$t_font_file_id BY 20;
+
+ lnf(fnt$t_font_file_id+5) = byte(DIVIDE(lnfno,10,31)+rank('0'));
+ lnf(fnt$t_font_file_id+6) = byte(MOD(lnfno,10)+rank('0'));
+ IF using_r
+ THEN lnf(fnt$t_font_file_id+20) = 'O';
+
+/* Set various offsets which are dependent on the number of characters in
+the font file. */
+
+ %REPLACE fnt$a_subset_tables BY 128;
+ longword = lnf_chardir+4*i;
+ lnf(fnt$a_subset_tables) = substr(chars,1,1);
+ lnf(fnt$a_subset_tables+1) = substr(chars,2,1);
+ lnf(fnt$a_subset_tables+2) = substr(chars,3,1);
+ lnf(fnt$a_subset_tables+3) = substr(chars,4,1);
+
+ longword = longword+4;
+ lnf(fnt$a_subset_tables+8) = substr(chars,1,1);
+ lnf(fnt$a_subset_tables+9) = substr(chars,2,1);
+ lnf(fnt$a_subset_tables+10) = substr(chars,3,1);
+ lnf(fnt$a_subset_tables+11) = substr(chars,4,1);
+ lnf(fnt$a_subset_tables+16) = substr(chars,1,1);
+ lnf(fnt$a_subset_tables+17) = substr(chars,2,1);
+ lnf(fnt$a_subset_tables+18) = substr(chars,3,1);
+ lnf(fnt$a_subset_tables+19) = substr(chars,4,1);
+
+ longword = longword+48;
+ lnf(fnt$a_subset_tables+24) = substr(chars,1,1);
+ lnf(fnt$a_subset_tables+25) = substr(chars,2,1);
+ lnf(fnt$a_subset_tables+26) = substr(chars,3,1);
+ lnf(fnt$a_subset_tables+27) = substr(chars,4,1);
+
+ %REPLACE fnt$a_char_definitions BY 160;
+ lnf(fnt$a_char_definitions) = substr(chars,1,1);
+ lnf(fnt$a_char_definitions+1) = substr(chars,2,1);
+ lnf(fnt$a_char_definitions+2) = substr(chars,3,1);
+ lnf(fnt$a_char_definitions+3) = substr(chars,4,1);
+
+/* Set up the string pool (48 bytes). */
+
+ DCL pool_beg FIXED;
+
+ pool_beg = ras_beg-48;
+
+ lnf(pool_beg) = '0';
+ IF using_r THEN lnf(pool_beg+1) = '<'; ELSE lnf(pool_beg+1) = 'B';
+ lnf(pool_beg+2) = byte(9);
+ lnf(pool_beg+3) = 'Z';
+ lnf(pool_beg+4) = 'Z';
+ lnf(pool_beg+5) = 'Z';
+ lnf(pool_beg+6) = 'Z';
+
+ DO i = 1 TO 7;
+ lnf(pool_beg+7+i-1) = lnf(fnt$t_font_file_id+i-1);
+ END;
+ DO i = 1 TO 16;
+ lnf(pool_beg+7+7+i-1) = ' ';
+ END;
+ DO i = 1 TO 16;
+ lnf(pool_beg+7+7+16+i-1) = lnf(fnt$t_font_file_id+i-1);
+ END;
+
+/* Now make string descriptors point into the string pool. */
+ %REPLACE fnt$a_char_set BY 260;
+ %REPLACE fnt$a_family_id BY 268;
+ %REPLACE fnt$a_family_name BY 276;
+ %REPLACE fnt$a_font_id BY 284;
+
+ longword = pool_beg;
+ lnf(fnt$a_char_set) = substr(chars,1,1);
+ lnf(fnt$a_char_set+1) = substr(chars,2,1);
+ lnf(fnt$a_char_set+2) = substr(chars,3,1);
+ lnf(fnt$a_char_set+3) = substr(chars,4,1);
+ longword = pool_beg+7;
+ lnf(fnt$a_family_id) = substr(chars,1,1);
+ lnf(fnt$a_family_id+1) = substr(chars,2,1);
+ lnf(fnt$a_family_id+2) = substr(chars,3,1);
+ lnf(fnt$a_family_id+3) = substr(chars,4,1);
+ longword = pool_beg+7+7;
+ lnf(fnt$a_family_name) = substr(chars,1,1);
+ lnf(fnt$a_family_name+1) = substr(chars,2,1);
+ lnf(fnt$a_family_name+2) = substr(chars,3,1);
+ lnf(fnt$a_family_name+3) = substr(chars,4,1);
+ longword = pool_beg+7+7+16;
+ lnf(fnt$a_font_id) = substr(chars,1,1);
+ lnf(fnt$a_font_id+1) = substr(chars,2,1);
+ lnf(fnt$a_font_id+2) = substr(chars,3,1);
+ lnf(fnt$a_font_id+3) = substr(chars,4,1);
+
+/* Mercifully, all remaining font file slots that we can fill now are
+already good as received from GOOD_OPENING. */
+
+ END initialize_lnf;
+
+END add_txf_to_lnf;