home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / util / new_font.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-11  |  97.1 KB  |  3,614 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from util/new_font.c
  3. */
  4. /*
  5.  ************************************************************************
  6.  *                                    *
  7.  *    new_font.c                    04. Mar. 90    *
  8.  *                                    *
  9.  *    A replacement for the old fontstructure-handling.    (hes)    *
  10.  *                                    *
  11.  ************************************************************************
  12.  */
  13.  
  14. /*
  15.  *    Zu tun:
  16.  *
  17.  *    o common ueberpruefen. Wird common nicht zuviel/staendig neu angelegt?
  18.  *      (-)
  19.  *    o Arrays (z.B. Path) ueberpruefen, ob man es nicht per Pointer
  20.  *      (strdup, stringpool? (Liste von Strings??)) machen koennte.
  21.  *      (!)
  22.  *    o Ueberall wo mit Arrays gearbeitet wird muss strncat strncpy ...
  23.  *      verwendet werden.
  24.  *      (!)
  25.  *    o Fontstruktur umstellen. Es soll eine strikte Trennung zwischen DVI-File
  26.  *      Daten und Fontdaten eingefuehrt werden. Dazu noch eine Struktur
  27.  *      vorschalten. Alle Flags umschalten. Alles sollen Bitflags werden.
  28.  *      (!!!)
  29.  *    o pk Substitutionsmoeglichkeit: Es muesste moeglich sein, zu sagen
  30.  *      dass falls ein 143dpi Font nicht gefunden wird, moege doch der 144dpi
  31.  *      Font gesucht werden.
  32.  *      (-)
  33.  *    o TFM File lesen (optional), falls ein Font nicht gefunden wurde.
  34.  *      (!!)
  35.  *    o Die Fontsubstitutionsidee von Bernd implementieren. Falls pkdir oder
  36.  *      flib definiert, dann die der Reihe nach absuchen.
  37.  *      (!)
  38.  *    o Per Option auswaehlbar was/nach welcher Reihenfolge die einzelnen
  39.  *      Ersetzungen gemacht werden sollen:
  40.  *      - Substitution durch andere Groesse
  41.  *      - Black Box durch TFM File
  42.  *      - cmr10 Font einsetzen
  43.  *      (!)
  44.  *    o Virtuelle Fonts! (der zweite Punkt sollte das schon vorbereiten)
  45.  *      (!!!)
  46.  *    o Zukunftsidee:
  47.  *      Die Struktur so umstellen, dass mit mehreren DVI-Files *gleichzeitig*
  48.  *      gearbeitet werden kann.
  49.  *      Vielleicht mal die Fontverwaltung als eigenen Task implementieren
  50.  *      so dass ShowDVI/DVIprint gleichzeitig darauf zugreifen koennen.
  51.  *      (Oder auch andere zu portierende Treiber (Beeble, dvips, ...))
  52.  *      (-)
  53.  *
  54.  */
  55.  
  56. #include "defines.h"
  57.  
  58. #define OLDARGS        /* !!!!! */
  59.  
  60. #include <stdio.h>
  61.  
  62. #ifdef AMIGA
  63. #  include <exec/types.h>
  64. #  include <dos/dos.h>
  65. #endif
  66.  
  67. #include "globals.h"
  68. #include "textypes.h"
  69. #include "flmt.h"
  70. #include "new_font.h"
  71.  
  72. #ifdef ANSI
  73. #  include <string.h>
  74. #  include <stdlib.h>
  75. #  include <stddef.h>
  76. #endif
  77. #include <ctype.h>
  78.  
  79.  
  80. #ifdef LATTICE
  81. #  include <clib/exec_protos.h>
  82. #  include <clib/dos_protos.h>
  83. #  include <pragmas/exec_pragmas.h>
  84. #  include <pragmas/dos_pragmas.h>
  85.    extern struct DosLibrary    *DOSBase;
  86. #endif
  87.  
  88. #include "globals.i"
  89. #include "new_font.i"
  90. #include "loadfont.i"
  91. #include "dvihand.i"
  92.  
  93. #ifdef SLOW
  94. #  include "bitmap.i"
  95. #endif
  96. #ifndef OLDARGS
  97. #  include "parsef.h"
  98. #  include "parsef.i"
  99. #endif
  100.  
  101. #ifdef ATARI
  102. # include <ext.h>
  103. # include <aes.h>   /* for shel_find */
  104. # define abs(a)        labs(a)
  105. # ifdef __TURBOC__
  106.    extern int access(char *, int);
  107. #  if (__TURBOC__ < 0x200)
  108. #   define setup_lru_flib slruflib 
  109. #   define setup_lru_font slrufont 
  110. #   define what_lru_flib wlruflib 
  111. #   define what_lru_font wlrufont
  112. #   define search_font_location sfloc
  113. #   define search_font_group sfgrp
  114. #   define is_font_in_font_list isifolist
  115. #   define is_font_in_lib_list isililist
  116. #   define is_font_in_pk_dirs isipkdirs
  117. #   define search_in_defined_libs sindelibs
  118. #   define search_in_rest_pathes sinrepathes
  119. #   define define_font def_font
  120. #   define define_flib def_flib
  121. #  endif
  122. # endif
  123. #endif
  124.  
  125.  
  126.  
  127. #ifdef AMIGA
  128. #  ifdef FONTS_IN_CHIPMEM
  129. #    include <exec/memory.h>
  130. #    include <libraries/dos.h>
  131. char *AllocRemember();
  132. extern struct Remember *Rem_Key;    /* Memory-Management */
  133. extern int fontmem_in_chipmem;        /* soll oder soll nicht? */
  134. #  endif
  135. #endif
  136.  
  137.  
  138.  
  139. #ifndef ATARI
  140. # ifndef abs
  141. #  define abs(a)    (((a) < 0) ? -(a) : (a))
  142. # endif
  143. #endif
  144.  
  145. #ifdef AMIGA
  146. #  define ACC_READ        4
  147. #  define B_OPEN_READ        "r"
  148. #else
  149. #  ifdef ATARI
  150. #    define ACC_READ        S_IREAD
  151. #    define B_OPEN_READ        "rb"
  152. #  endif
  153. #endif
  154.  
  155.  
  156.  
  157.  
  158. /*
  159.  * Fuer die locale-Library:
  160.  *
  161.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  162.  * Achtung:
  163.  * Es muss/sollte 'multiple-include' erlaubt sein!
  164.  */
  165. #include "local.i"
  166.  
  167. #undef  CATCOMP_ARRAY
  168. #undef  CATCOMP_BLOCK
  169. #undef  CATCOMP_STRINGS
  170. #define CATCOMP_NUMBERS
  171. #include "localstr.h"
  172.  
  173.  
  174.  
  175. /*
  176.  ************************************************************************
  177.  *                                    *
  178.  ************************************************************************
  179.  */
  180.  
  181. /*
  182.  ************************************************************************
  183.  *    external variables                        *
  184.  ************************************************************************
  185.  */
  186.  
  187. #ifdef AMIGA
  188. extern struct ArpBase    *ArpBase;
  189. #endif
  190.  
  191. extern long        resolution;    /* actual base resolution    */
  192.        struct Font    *cfontptr;    /* pointer to the actual font    */
  193.  
  194.        struct FontMan    *FontRoot = NULL;    /* root structure    */
  195.  
  196.  
  197. /*
  198.  ************************************************************************
  199.  *    global variables for this module                *
  200.  ************************************************************************
  201.  */
  202.  
  203. static char        *lowmem, *charmap, *start_mem, *end_mem;
  204.  
  205.     /*  lowmem    pointer to the first free memory cell        */
  206.     /*  charmap    pointer to the current character        */
  207.     /*  start_mem    pointer to the start of the fontmem        */
  208.     /*  end_mem    pointer to the end of the fontmem        */
  209.  
  210.  
  211. static short mags[NRMAGS] = { 1000, 1095, 1200, 1315, 1440, 1577,
  212.             1728, 2074, 2488, 2986, 3583, 4300, 5160 };
  213.  
  214.     /* mag(0) mag(0.5) mag(1) mag(1.5) mag(2) mag(2.5)
  215.        mag(3) mag(4)   mag(5) mag(6)   mag(7) mag(8)   mag(9) */
  216.  
  217.  
  218.  
  219.  
  220. #ifndef OLDARGS
  221. /**=============================================================**/
  222.  
  223. struct FontMan *globarg_fnt_root;
  224.  
  225. static void __stdargs    fkw_conc_dirs
  226.         Args((struct string_parse *p, char *line));
  227. static void __stdargs    fkw_parse_string
  228.         Args((struct string_parse *p, char *line, char *string));
  229. static void __stdargs    fkw_dir
  230.         Args((struct string_parse *p, char *line,
  231.             long *res, char *where));
  232. static void __stdargs    fkw_define_flib
  233.         Args((struct string_parse *p, char *line,
  234.             long *res, char *path));
  235. static void __stdargs    fkw_define_font
  236.         Args((struct string_parse *p, char *line,
  237.             char *name, long *res, char *path));
  238.  
  239. /* There should be better ways to do this, but I don't want to refer
  240. to absolute array indices. */
  241. #define ARG_CONC_FLIB    1
  242. #define ARG_CONC_PK    2
  243. #define ARG_STR_FLIB    1
  244. #define ARG_STR_PK    2
  245. #define ARG_STR_BASEPKD    3
  246. #define ARG_STR_PKDIR    4
  247. #define ARG_STR_FLIBFNT    5
  248. #define ARG_PKDIR    1    /*don't you dare change this (see func)!*/
  249. #define ARG_BASEPKDIR    2    /*don't you dare change this (see func)!*/
  250.  
  251. static struct string_parse font_config[] = {
  252.     {
  253.     "flibenv",
  254.     NULL,
  255.     (string_parse_function) fkw_conc_dirs,
  256.     PAF_ARGS,
  257.     ARG_CONC_FLIB
  258.     },
  259.     {
  260.     "pkenv",
  261.     NULL,
  262.     (string_parse_function) fkw_conc_dirs,
  263.     PAF_ARGS,
  264.     ARG_CONC_PK
  265.     },
  266.     {
  267.     "flib_str",
  268.     "%s",
  269.     (string_parse_function) fkw_parse_string,
  270.     PAF_1_ARG,
  271.     ARG_STR_FLIB
  272.     },
  273.     {
  274.     "pk_str",
  275.     "%s",
  276.     (string_parse_function) fkw_parse_string,
  277.     PAF_1_ARG,
  278.     ARG_STR_PK
  279.     },
  280.     {
  281.     "basepkdir_str",
  282.     "%s",
  283.     (string_parse_function) fkw_parse_string,
  284.     PAF_1_ARG,
  285.     ARG_STR_BASEPKD
  286.     },
  287.     {
  288.     "pkdir_str",
  289.     "%s",
  290.     (string_parse_function) fkw_parse_string,
  291.     PAF_1_ARG,
  292.     ARG_STR_PKDIR
  293.     },
  294.     {
  295.     "flib_fnt_str",
  296.     "%s",
  297.     (string_parse_function) fkw_parse_string,
  298.     PAF_1_ARG,
  299.     ARG_STR_FLIBFNT
  300.     },
  301.     {
  302.     "flib",
  303.     "%d %s",
  304.     (string_parse_function) fkw_define_flib,
  305.     PAF_2_ARGS
  306.     },
  307.     {
  308.     "pkdir",
  309.     "%ld %s",
  310.     (string_parse_function) fkw_dir,
  311.     PAF_2_ARGS,
  312.     ARG_PKDIR
  313.     },
  314.     {
  315.     "basepkdir",
  316.     "%ld %s",
  317.     (string_parse_function) fkw_dir,
  318.     PAF_2_ARGS,
  319.     ARG_BASEPKDIR
  320.     },
  321.     {
  322.     "font",
  323.     "%s %d %s",
  324.     (string_parse_function) fkw_define_font,
  325.     PAF_3_ARGS
  326.     },
  327.     {
  328.     NULL
  329.     }
  330. };
  331. #endif
  332.  
  333. /*
  334.  ************************************************************************
  335.  *    external functions                        *
  336.  ************************************************************************
  337.  *
  338.  * void resetfont    Args((void));
  339.  * void setup_ctfmw    Args((struct Font *font));
  340.  * void SetFntNum    Args((long fntnum));
  341.  * int  HasBeenRead    Args((long fntnum));
  342.  * void LoadFont    Args((int  action,          0: define only
  343.  *                  long fntnum,         1: load only
  344.  *                  char *fntname,         2: define & load
  345.  *                  long chksum,
  346.  *                  long d,
  347.  *                  long s,
  348.  *                  long fontmag,
  349.  *                  long fontmag5));
  350.  * int  init_fontmt    Args((char show));         0: dviprint, 1: showdvi
  351.  * long alloc_char    Args((ulong size));         ret = -1 -> no memory
  352.  *
  353.  *
  354.  */
  355.  
  356.  
  357. /*
  358.  ************************************************************************
  359.  *    local functions                            *
  360.  ************************************************************************
  361.  */
  362.  
  363. static void         MarkFile        Args((char * full_name));
  364. #ifdef PASEIT
  365. static int parsit                Args((char *line,
  366.                               char ***array));
  367. #endif
  368. static void setup_sealst            Args((struct FontMan *fnt_root));
  369. static int split_env_string            Args((struct SeaLst *sl,
  370.                               char *env_var,
  371.                               char *def_value));
  372. static long compute_vert            Args((long hdpi));
  373. static void my_sprintf                Args((char buffer[],
  374.                               int length,
  375.                               char fmt[],
  376.                               char fntname[],
  377.                               long dpi,
  378.                               long dpi5));
  379. static void        InitFontMan        Args((char is_show));
  380. static long        test_pk_file        Args((char *pk_name));
  381. static void        setup_lru_flib        Args((struct LibLst *list,
  382.                               struct Fnt_Lib *lib));
  383. static void        setup_lru_font        Args((struct FontLst *list,
  384.                               struct Font *font));
  385. static struct Fnt_Lib    *what_lru_flib        Args((struct LibLst *list));
  386. static struct Font    *what_lru_font        Args((struct FontLst *list));
  387. static void        close_flibs        Args((struct FontMan *fnt_root));
  388. static struct CommonFontGroups
  389.             *search_font_group    Args((char *fntname,
  390.                               struct FontMan *fnt_root));
  391. static struct Font    *search_font        Args((char *fntname,
  392.                               long magnification,
  393.                               long magnification5,
  394.                               struct FontMan *fnt_root));
  395. static struct Font    *search_font_location    Args((char *fntname,
  396.                               long dpi,
  397.                               long dpi5,
  398.                               struct FontMan *fnt_root));
  399. static struct Font     *is_font_in_font_list    Args((char *fntname,
  400.                               long dpi,
  401.                               long dpi5,
  402.                               struct FontLst *fnt_list,
  403.                               struct FontMan *fnt_root));
  404. static struct Font    *is_font_in_lib_list    Args((char *fntname,
  405.                               long dpi,
  406.                               long dpi5,
  407.                               struct FontMan *fnt_root));
  408. static struct Font     *is_font_in_pk_dirs    Args((char * fntname,
  409.                               long dpi,
  410.                               long dpi5,
  411.                               struct FontMan *fnt_root));
  412. static struct Font     *is_font_in_pred_pk_dirs Args((char * fntname,
  413.                               long dpi,
  414.                               long dpi5,
  415.                               struct FontMan *fnt_root,
  416.                               short base));
  417. static struct Font    *define_test_pk_font    Args((char *path,
  418.                               char *fntname,
  419.                               long dpi,
  420.                               long dpi5,
  421.                               char *format_str,
  422.                               struct FontMan *fnt_root));
  423. static struct Font    *search_in_defined_libs    Args((char *fntname,
  424.                               long dpi,
  425.                               long dpi5,
  426.                               struct FontMan *fnt_root));
  427. static struct Font    *search_in_rest_pathes    Args((char *fntname,
  428.                               long dpi,
  429.                               long dpi5,
  430.                               struct FontMan *fnt_root));
  431. static struct Font    *find_font_in_flib    Args((char *fntname,
  432.                               long dpi,
  433.                               long dpi5,
  434.                               struct Fnt_Lib *flib,
  435.                               struct FontMan *fnt_root));
  436. static void        read_font_def_file    Args((struct FontMan *fnt_root,
  437.                               char *file_name));
  438. static void        parse_line        Args((struct FontMan *fnt_root,
  439.                               char *line));
  440. static void        conc_dirs        Args((char *str,
  441.                               struct SeaLst *sl));
  442. static void        define_flib        Args((struct FontMan *fnt_root,
  443.                               long dpi,
  444.                               char *path));
  445. static void        define_font        Args((struct FontMan *fnt_root,
  446.                               long dpi,
  447.                               char *path,
  448.                               char *name));
  449.  
  450. struct Font        *mag_substitution    Args((char *fntname,
  451.                               long dpi,
  452.                               struct FontMan *fnt_root));
  453. struct Font        *dpi_substitution    Args((char *fntname,
  454.                               long magnification,
  455.                               struct FontMan *fnt_root));
  456.  
  457. static void         init_mem        Args((ulong size));
  458. static long         *open_charmap        Args((void));
  459. static long         close_charmap        Args((void));
  460. static void        adjust_mem        Args((long *start,
  461.                               long size));
  462. static int        do_garcol        Args((void));
  463.  
  464. #ifdef AMIGA
  465. static struct Font    *read_atex_file        Args((char *fntname,
  466.                               long dpi,
  467.                               long dpi5,
  468.                               struct FontMan *fnt_root));
  469. static int        copy_file        Args((char *source,
  470.                               char *drain));
  471. static int        create_path        Args((char *path));
  472. #endif
  473.  
  474.  
  475.  
  476.  
  477.  
  478. /*
  479.  ************************************************************************
  480.  *    mark the file full_name                        *
  481.  ************************************************************************
  482.  */
  483.  
  484. static void MarkFile(char * full_name)
  485. {
  486.   if (mark_fonts) {
  487.     __aligned struct FileInfoBlock fib;
  488.     char comment[80];
  489.     struct DateStamp ds;
  490.     long old;
  491.     BPTR lck = Lock(full_name, ACCESS_READ);
  492.     if (lck) {
  493.       (void)DateStamp(&ds);
  494.       Examine(lck, &fib);
  495.       if (fib.fib_Comment[0] == '\0' || sscanf(fib.fib_Comment+10, "%d", &old) != 1) {
  496.         old = 0;
  497.       }
  498.       sprintf(comment, "FontUsed: %d (%d %d %d)", old+1, ds.ds_Days, ds.ds_Minute, ds.ds_Tick);
  499.       UnLock(lck);
  500.       if (!SetComment(full_name, comment)) {
  501.         ; //printf("SetComment %d fehlgeschlagen!\n", comment);
  502.       }
  503.     }
  504.   }
  505. }
  506.  
  507.  
  508.  
  509. /*
  510.  ************************************************************************
  511.  *    release all unpacked chars                    *
  512.  ************************************************************************
  513.  */
  514.  
  515. void release_mem(void)
  516. {
  517.   struct FontLst *flist;
  518.   long i,j;
  519.  
  520.   if (FontRoot != NULL) {
  521.     /* release chars */
  522.     if (FontRoot->unpacked_mem > 0) {
  523.       j=0L;
  524.       for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font) {
  525.         for (i=0; i<NPXLCHARS; i++) {
  526.           if (flist->font.common->ch[i].unpacked != NULL) {
  527.             xfree(flist->font.common->ch[i].unpacked);
  528.             flist->font.common->ch[i].unpacked = NULL;
  529.             j++;
  530.           }
  531.         }
  532.       }
  533.       Logging(MSG_RELEASE_CHARS,FontRoot->unpacked_mem, j);
  534.       FontRoot->unpacked_mem = 0L;
  535.     }
  536.   }
  537. }
  538.  
  539.  
  540.  
  541.  
  542. /*
  543.  ************************************************************************
  544.  *    parse a line and returns int argc, char *argv[]            *
  545.  ************************************************************************
  546.  */
  547.  
  548. #ifdef PASEIT
  549. static int parsit(char *line,char ***array)
  550. {
  551.   char **argv;
  552.   char *word;
  553.   char *linecp;
  554.   int  i,j, num_words, longest_word;
  555.  
  556.   argv = *array;
  557.   if (argv != (char **)NULL) {
  558.     for (i=0; argv[i] != (char*) NULL; i++) {
  559.       xfree(argv[i]);        /* free the old array */
  560.     }
  561.     xfree((char *)argv);        /* and then free the ptr itself */
  562.   }
  563.   
  564.   linecp = line;
  565.   num_words = longest_word = 0;
  566.   while (1) {
  567.     for (; *linecp == ' ' || *linecp == '\t'; ++linecp) ;
  568.     if (*linecp == '\0') {
  569.       break;
  570.     }
  571.     word = linecp;
  572.     for (; *linecp != ' ' && *linecp != '\t' && *linecp != '\0'; ++linecp) ;
  573.     num_words++;
  574.     if ((i = linecp-word) > longest_word) {
  575.       longest_word = i;
  576.     }
  577.     if (*linecp == '\0') {
  578.       break;
  579.     }
  580.   }
  581.   
  582.   if ((argv = (char **)xmalloc((size_t)(num_words +1) * 4)) == (char **)NULL) {
  583.     Warning(MSG_NO_MEM);
  584.     return (0);
  585.   }
  586.   
  587.   if ((word = (char *)xmalloc((size_t)(longest_word+2))) == (char *)NULL) {
  588.     Warning(MSG_NO_MEM);
  589.     return (0);
  590.   }
  591.   
  592.   j = i = 0;
  593.   while (1) {
  594.     for (; *line == ' ' || *line == '\t'; line++) ;
  595.     if (*line == '\0') {
  596.       break;
  597.     }
  598.     i = 0;
  599.     for (; *line != ' ' && *line != '\t' && *line != '\0'; line++) {
  600.       word[i++] = *line;
  601.     }
  602.     word[i] = '\0';
  603.     argv[j] = xmalloc((size_t)strlen(word+1));
  604.     if (argv[j] == (char *)NULL) {
  605.       xfree(word);
  606.       Warning(MSG_NO_MEM);
  607.       return (0);
  608.     }
  609.     (void)strcpy(argv[j], word);
  610.     j++;
  611.     if (*line == '\0') {
  612.       break;
  613.     }
  614.   }
  615.   argv[j] = (char *)NULL;    /* NULL at end of list */
  616.   *array = argv;
  617.   xfree(word);
  618.   return (j);
  619. }
  620. #endif
  621.  
  622.  
  623. /*
  624.  ************************************************************************
  625.  *    compute the vertical resolution                    *
  626.  ************************************************************************
  627.  */
  628.  
  629. static long compute_vert(long hdpi)
  630. {
  631.   return ((hdpi * vconvresolution + hconvresolution/2) / hconvresolution);
  632. }
  633.  
  634.  
  635.  
  636. /*
  637.  ************************************************************************
  638.  *    make in path a complete path-string                *
  639.  ************************************************************************
  640.  */
  641.  
  642. void mk_correct_path(char *path)
  643. {
  644.     int length = strlen(path);
  645. #if defined(HARDDEB)
  646.     if (NULL == path) printf("mk_correct_path == NULL!\n");
  647. #endif
  648.     if ('\n' == path[length-1]) path[--length] = '\0';
  649. #  ifdef ATARI
  650.     if (path[length-1] != ':' && path[length-1] != '\\') {
  651.       path[length] = '\\';
  652.       path[length+1] = '\0';
  653.     }
  654. #  else
  655.     if (0 < length && path[length-1] != ':' && path[length-1] != '/') {
  656.       path[length] = '/';
  657.       path[length+1] = '\0';
  658.     }
  659. #  endif
  660. }
  661.  
  662.  
  663. /*
  664.  ************************************************************************
  665.  *    insert dpi and fontname in fmt string                *
  666.  ************************************************************************
  667.  */
  668.  
  669. static void my_sprintf(char *buffer, int buf_length, char *fmt,
  670.             char *fntname, long dpi, long dpi5)
  671. {
  672.   char c, *t, work[16], hbuf[128];
  673.  
  674.   if (buffer == NULL || fmt == NULL || fntname == NULL) {
  675.     Fatal(20, MSG_INTERNAL_ERROR_SPRINTF);
  676.   }
  677.  
  678.   --buf_length;        /* there has to be a '\0' char at the end ! */
  679.  
  680.   while( *fmt != '\0' && buf_length > 0 ) {
  681.     if( *fmt != '%' ) {        /* copy all chars up to a '%' sign */
  682.       *buffer++ = *fmt++;
  683.       --buf_length;
  684.       continue;
  685.     }
  686.  
  687.     /* we have found a '%' */
  688.     fmt++;
  689.     if( *fmt == '%' ) {        /* for '%%' insert one '%' */
  690.       *buffer++ = *fmt++;
  691.       --buf_length;
  692.       continue;
  693.     }
  694.  
  695.     /* copy '%...X' part from `fmt' into work[] */
  696.     t = work;
  697.     *t++ = '%';
  698.  
  699.     /* Zwischen % und Zeichen sind nur Zahlen+Punkt erlaubt */
  700.     while( (c = *fmt) != '\0' && strchr(".0123456789", c) != NULL
  701.         && t < &work[16-2] )
  702.     *t++ = *fmt++;
  703.  
  704.     *t = 'd';        /* 'd' is most common case, orig char is in `c' */
  705.     *(t+1) = '\0';
  706.     /* weitere Fehlerabfrage wird im default-case des switch erledigt */
  707.  
  708.     if (c != '\0')
  709.       fmt++;
  710.  
  711.     switch (c) {
  712.     case 'h' :
  713.     case 'd' :    sprintf(hbuf, work, (int)dpi);    /* insert dpi        */
  714.         break;
  715.     case 'v' :    sprintf(hbuf, work, (int)compute_vert(dpi));
  716.         break;
  717. #ifdef FONT_MAG
  718.     case 'x' :    { int pxl = (dpi5 * resolution * 5 + 500)/1000;
  719.           sprintf(hbuf, work, pxl);    /* insert dpi*5        */
  720.         }
  721.         break;
  722.     case 'y' :    { int pxl = (dpi5 * resolution * 5 + 500)/1000;
  723.           sprintf(hbuf, work, (int)compute_vert(pxl));
  724.         }
  725.         break;
  726.     case 'M' :    sprintf(hbuf, work, dpi5);    /* insert font mag */
  727.         break;
  728.     case 'm' :    *t = 'f';            /* insert font mag/1000 */
  729.         sprintf(hbuf, work, (float)dpi5/1000.0);
  730.         break;
  731. #else
  732.     case 'x' :    sprintf(hbuf, work, (int)dpi5);    /* insert dpi*5 */
  733.         break;
  734.     case 'y' :    sprintf(hbuf, work, (int)compute_vert(dpi5));
  735.         break;
  736. #endif
  737.     case 's' :  *t = 's';
  738.         sprintf(hbuf, work, fntname);    /* insert font name */
  739.         break;
  740.     default  :    Fatal(5, MSG_UNKNOWN_FORMAT_SPRINTF);
  741.         return;
  742.     }
  743.  
  744.     if (strlen(hbuf) > 100) {
  745.       Fatal(20, MSG_STRING_OVERFLOW_SPRINTF);
  746.       /* NOT REACHED */
  747.     }
  748.  
  749.     if (strlen(hbuf) >= buf_length)
  750.       hbuf[buf_length] = '\0';    /* Cut rest of hbuf (with warning?) */
  751.  
  752.     strcpy(buffer, hbuf);
  753.     buffer += strlen(hbuf);
  754.     buf_length -= strlen(hbuf);
  755.   }
  756.  
  757.   *buffer = '\0';    /* null-terminate string */
  758. }
  759.  
  760.  
  761. /* string only for logging ! */
  762. void get_full_name(char *str, struct Font *fnt)
  763. {
  764.    char fontname[PK_NAME_SIZE], name[PATH_SIZE+PK_NAME_SIZE];
  765.  
  766.    if (fnt->common->where_is_font == WHERE_LIB) {
  767.      /* font in lib: fontname == Lib-name, name == full name of Lib */
  768.      my_sprintf(fontname, PK_NAME_SIZE,
  769.         fnt->common->location.fnt_library->format_str,
  770.                 fnt->common->fnt_group->fnt_name,
  771.                 fnt->common->resolution,
  772.                 fnt->common->resolution5);
  773.      strcpy(name,fnt->common->location.fnt_library->path);
  774.      mk_correct_path(name);
  775.      strcat(name,fontname);
  776.      strcat(name," [");
  777.      strcat(name,fnt->common->fnt_group->fnt_name);
  778.      strcat(name,"]");
  779.    }
  780.    else {
  781.      /* font as pk-file: fontname: full pk-name (without path) */
  782.      strcpy(name,fnt->common->location.pk_directory->path);
  783.      mk_correct_path(name);
  784.      my_sprintf(fontname, PK_NAME_SIZE,
  785.         fnt->common->location.pk_directory->format_str,
  786.         fnt->common->fnt_group->fnt_name,
  787.         fnt->common->resolution,
  788.         fnt->common->resolution5);
  789.      strcat(name, fontname);
  790.    }
  791.  
  792.    strcpy(str, name);
  793. }
  794.  
  795.  
  796.  
  797. /*
  798.  ************************************************************************
  799.  *    split a env-string and saves it in a search-list        *
  800.  ************************************************************************
  801.  */
  802.  
  803. static int split_env_string(struct SeaLst *sl, char *env_var, char *def_value)
  804. {
  805.   char *tmp, *ptr, save[300];
  806.   int i;
  807.   char *string;
  808.   struct SeaEle *ele, *ele2;
  809.  
  810.  
  811.   save[0] = '\0';    /* init for strcat() */
  812.  
  813.   tmp = getenv(env_var);
  814.   if (tmp != NULL) {
  815.     strcpy(save, tmp);
  816.     for (ptr = save; *ptr != '\0'; ptr++) {
  817.       if (*ptr == '!' || *ptr == ',') {        /* env-seperators */
  818.         *ptr = ' ';
  819.       }        /* !! no spaces in pathes of environmentstring !! */
  820.     }
  821.     strcat(save, " ");
  822.   }
  823.  
  824.   if (PXLpath != NULL) {    /* -a option given */
  825.     strcat(save, PXLpath);
  826.     strcat(save, " ");
  827.   }
  828.  
  829. #ifdef ALWAYS_DEFAULT
  830.   strcat(save, def_value);
  831. #else
  832.   if (strlen(save) == 0)
  833.     strcat(save, def_value);
  834. #endif
  835.  
  836.   i = 1;
  837.   string = xmalloc(strlen(save)+1);
  838.   strcpy(string,save);
  839.  
  840.   ele = xmalloc(sizeof(struct SeaEle));
  841.   sl->first_ele = ele;
  842.   ele->path = string;
  843.   ele->next_ele = NULL;
  844.  
  845.   while (*string != '\0' && isspace(*string)) { string++; }
  846.  
  847.   while (*string != '\0') {
  848.     while (*string != '\0' && !isspace(*string)) { string++; }
  849.     if (*string != '\0') {
  850.       *string = '\0';
  851.       string++;
  852.       while (*string != '\0' && isspace(*string)) { string++; }
  853.       if (*string != '\0') {
  854.         ele2 = xmalloc(sizeof(struct SeaEle));
  855.         ele2->path = string;
  856.         ele2->next_ele = NULL;
  857.         ele->next_ele = ele2;
  858.         ele = ele2;
  859.         i++;
  860.       }
  861.     }
  862.   }
  863.  
  864.   sl->number = i;
  865.  
  866.   return 0;
  867. }
  868.  
  869.  
  870. /*
  871.  ************************************************************************
  872.  *    setup the search list for flibs/pk-dirs                *
  873.  ************************************************************************
  874.  */
  875.  
  876. static void setup_sealst(struct FontMan *fnt_root)
  877. {
  878.   if (split_env_string(&(fnt_root->s_list_flib),ENV_FLIB_DIRS,FLIB_AREA) != 0) {
  879.     Warning(MSG_ERROR_SEARCH_LIST_LIB);
  880.   }
  881.   if (split_env_string(&(fnt_root->s_list_pkdirs),ENV_PK_DIRS,PK_AREA) != 0) {
  882.     Warning(MSG_ERROR_SEARCH_LIST_PK);
  883.   }
  884. }
  885.  
  886.  
  887. /*
  888.  ************************************************************************
  889.  *    is the file a pk-file, returns size of pk-file or 0 if not    *
  890.  ************************************************************************
  891.  */
  892. static long test_pk_file(char *pk_name)
  893. {
  894.   long size;
  895.  
  896. #undef SAVETY_PK
  897. #ifdef SAVETY_PK
  898.   char ptr[2];
  899.   FILE *fp;
  900.  
  901.   fp = BINARYOPEN(pk_name);
  902.   if (fp != NULL) {
  903.     if (fread(ptr,1,2,fp) != 2) {
  904.       fclose(fp);
  905.       return 0L;
  906.     }
  907.     if (*((unsigned short *)ptr) != PK_MAGIC) {
  908.       fclose(fp);
  909.       return 0L;
  910.     }
  911.     fclose(fp);
  912. #endif
  913.  
  914. #ifdef ATARI
  915.   {
  916.    struct stat pkstat;
  917.    
  918.    if (stat(pk_name, &pkstat) == -1)
  919.     {
  920.      return(0L);
  921.     }
  922.    return(pkstat.st_size);
  923.   }
  924. #endif
  925. #ifdef AMIGA
  926.     {
  927.       struct FileInfoBlock *fib;
  928. #    ifdef LATTICE
  929.       BPTR lock;
  930. #    else
  931.       struct FileLock *lock;
  932. #    endif
  933.  
  934.       lock = Lock(pk_name,ACCESS_READ);
  935.       if (lock == NULL) {
  936.         return 0L;
  937.       }
  938.       fib = (struct FileInfoBlock *)xmalloc(sizeof(struct FileInfoBlock));
  939.       if (Examine(lock,fib)==0) {
  940.         xfree(fib);
  941.         UnLock((BPTR)lock);
  942.         return 0L;
  943.       }
  944.       size = fib->fib_Size;
  945.       xfree(fib);
  946.       UnLock((BPTR)lock);
  947.     }
  948. #endif
  949. #ifdef SAVETY_PK
  950.   }
  951. #endif
  952.  
  953.   return size;
  954. }
  955.  
  956.  
  957.  
  958. /*
  959.  ************************************************************************
  960.  *    advance the lru-count of all lib's expect lib            *
  961.  ************************************************************************
  962.  */
  963.  
  964. static void setup_lru_flib (struct LibLst *list, struct Fnt_Lib *lib)
  965. {
  966.   struct LibLst *temp;
  967.  
  968. #if 0
  969.   for (temp = list; temp != NULL; temp = temp->next_lib) {
  970.     if (&(temp->flib) == lib) {
  971.       temp->flib.lru_count = 0;
  972.     }
  973.     else {
  974.       temp->flib.lru_count++;
  975.     }
  976.   }
  977. #else
  978.   /* (br) so sollte es klappen... und es ist schneller ;-) */
  979.   for (temp = list; temp != NULL; temp = temp->next_lib) {
  980.     temp->flib.lru_count++;
  981.   }
  982.   lib->lru_count = 0;
  983. #endif
  984. }
  985.  
  986. /*
  987.  ************************************************************************
  988.  *    advance the lru-count of all font's expect font            *
  989.  ************************************************************************
  990.  */
  991.  
  992. static void setup_lru_font (struct FontLst *list, struct Font *font)
  993. {
  994.   register struct FontLst *temp;
  995.  
  996.   /* (br) dto. */
  997.   for (temp = list; temp != NULL; temp = temp->next_font) {
  998.     temp->font.common->lru_count++;
  999.   }
  1000.   font->common->lru_count = 0L;
  1001. }
  1002.  
  1003.  
  1004. /*
  1005.  ************************************************************************
  1006.  *    search the lib with the highest lru-count and fileptr != NULL    *
  1007.  ************************************************************************
  1008.  */
  1009.  
  1010. static struct Fnt_Lib *what_lru_flib (struct LibLst *list)
  1011. {
  1012.   register struct LibLst *temp, *res = NULL;
  1013.   long s = 0;
  1014.  
  1015.   /*** used for closing older flibs ***/
  1016.   for (temp = list; temp != NULL; temp = temp->next_lib) {
  1017.     if (temp->flib.lru_count > s && temp->flib.lib_status == LIB_OPEND) {
  1018.       s = temp->flib.lru_count;
  1019.       res = temp;
  1020.     }
  1021.   }
  1022.   if (res == NULL) {
  1023.     res = list;
  1024.   }
  1025.   return &(res->flib);
  1026. }
  1027.  
  1028. /*
  1029.  ************************************************************************
  1030.  *    search the font with the highest lru-count            *
  1031.  ************************************************************************
  1032.  */
  1033.  
  1034. static struct Font *what_lru_font (struct FontLst *list)
  1035. {
  1036.   struct FontLst *temp, *res;
  1037.   long s;
  1038.  
  1039.   s = 0;
  1040.   res = NULL;
  1041.  
  1042.   /*** used for deleting font from the ram ***/
  1043.   for (temp = list; temp != NULL; temp = temp->next_font) {
  1044.     if ((temp->font.common->lru_count >= s && temp->font.common->fnt_status == FNT_OLD_LOADED) ||
  1045.         (temp->font.common->lru_count >= s && temp->font.common->fnt_status == FNT_DEFINED_OLOADED) ||
  1046.         (temp->font.common->lru_count > s && temp->font.common->fnt_status == FNT_LOADED)) {
  1047.       s = temp->font.common->lru_count;
  1048.       res = temp;
  1049.     }
  1050.   }
  1051.   if (res == NULL) {
  1052.     return NULL;
  1053.   }
  1054.   else {
  1055.     return &(res->font);
  1056.   }
  1057. }
  1058.  
  1059.  
  1060. /*
  1061.  ************************************************************************
  1062.  *    close the flibs whith highest lru-count                *
  1063.  ************************************************************************
  1064.  */
  1065.  
  1066. static void close_flibs(struct FontMan *fnt_root)
  1067. {
  1068.   /* close files */
  1069.   short to_close = abs(fnt_root->files_left);
  1070.   short cl, res=0;
  1071.   struct Fnt_Lib *lib;
  1072.  
  1073.   if (fnt_root->files_left > 0) {
  1074.     return;
  1075.   }
  1076.  
  1077.   for (cl=0; cl <= to_close; cl++) {
  1078.     lib = what_lru_flib(fnt_root->flib_list);
  1079.     if (lib->file_ptr != NULL) {
  1080.       fclose(lib->file_ptr);
  1081.       lib->file_ptr = NULL;
  1082.       lib->lib_status = LIB_READ_CLOSED;
  1083.       res++;
  1084.     }
  1085.   }
  1086.   fnt_root->files_left += res;
  1087. }
  1088.  
  1089.  
  1090. /*
  1091.  ************************************************************************ *
  1092.  *    setup the global fontmanagement-structure            * *
  1093.  ************************************************************************ *
  1094.  */
  1095.  
  1096. static void InitFontMan(char is_show)
  1097. {
  1098.   register struct FontMan *fr;
  1099.  
  1100.   /* (br) Why not a static & initialized FontRoot ??? */
  1101.  
  1102.   fr = (struct FontMan *)xmalloc((size_t)sizeof(struct FontMan));
  1103.   
  1104.   FontRoot = fr;
  1105.  
  1106. #ifdef OLD_NOFONT
  1107.   fr->noFontList            = NULL;
  1108. #endif
  1109.   fr->s_list_flib.number        = 0L;
  1110.   fr->s_list_flib.first_ele        = NULL;
  1111.   fr->s_list_pkdirs.number        = 0L;
  1112.   fr->s_list_pkdirs.first_ele        = NULL;
  1113.   fr->s_list_pkdpi.number        = 0L;
  1114.   fr->s_list_pkdpi.first_ele        = NULL;
  1115.   fr->s_list_base_pkdpi.number        = 0L;
  1116.   fr->s_list_base_pkdpi.first_ele    = NULL;
  1117.   fr->font_list                = NULL;
  1118.   fr->flib_list                = NULL;
  1119.   fr->group_list            = NULL;
  1120.   fr->files_left            = MAXOPEN;
  1121.   fr->unpacked_mem            = 0L;
  1122.  
  1123.   if (is_show) {
  1124.     fr->driver_type        = (char)DRIVER_TYPE_SHOWDVI;
  1125.   }
  1126.   else {
  1127.     fr->driver_type        = (char)DRIVER_TYPE_DVIPRINT;
  1128.   }
  1129.  
  1130.   fr->flib_fmt      = strdup(FLIB_STRING);
  1131.   fr->pk_fmt        = strdup(PK_STRING);
  1132.   fr->pkdir_fmt     = strdup(PKDIR_STRING);
  1133.   fr->basepkdir_fmt = strdup(BASE_PK_STRING);
  1134.   fr->flib_fnt_fmt  = strdup(FLIB_FNT_STRING);
  1135.  
  1136.   if (fr->flib_fmt == NULL || fr->pk_fmt == NULL ||
  1137.     fr->pkdir_fmt == NULL || fr->flib_fnt_fmt == NULL) {
  1138.     Fatal(10, MSG_NO_MEM);
  1139.   }
  1140.  
  1141.   setup_sealst(fr);
  1142.   
  1143.   read_font_def_file(fr, is_show ? SFONT_DEF_FILE : DFONT_DEF_FILE);
  1144. }
  1145.  
  1146.  
  1147. /*
  1148.  *    ********    global functions    *******
  1149.  */
  1150.  
  1151.  
  1152. /*
  1153.  ************************************************************************ *
  1154.  *    initialize all                            * *
  1155.  ************************************************************************ *
  1156.  */
  1157.  
  1158. void init_fontmt(char show)
  1159. {
  1160.   init_mem(fontmemsize);
  1161.   InitFontMan(show);        /* showdvi OR dviprint    */
  1162. }
  1163.  
  1164.  
  1165.  
  1166. /*
  1167.  ************************************************************************ *
  1168.  *    reset the status of all fonts                    * *
  1169.  ************************************************************************ *
  1170.  */
  1171.  
  1172. void resetfont(void)
  1173. {
  1174.   struct FontLst *fntlst;
  1175.  
  1176.   for (fntlst = FontRoot->font_list; fntlst != NULL; fntlst = fntlst->next_font) {
  1177.     if (fntlst->font.common->fnt_status == FNT_DEFINED) {
  1178.       fntlst->font.common->fnt_status = FNT_FOUND;
  1179.     } else if (fntlst->font.common->fnt_status == FNT_LOADED
  1180.         || fntlst->font.common->fnt_status == FNT_DEFINED_OLOADED) {
  1181.       fntlst->font.common->fnt_status = FNT_OLD_LOADED;
  1182.     }
  1183.     fntlst->font.fnt_number = -1L;
  1184.     fntlst->font.ctfmw_valid = (char)FALSE;
  1185.   }
  1186. }
  1187.  
  1188.  
  1189. /*
  1190.  ************************************************************************ *
  1191.  *    setup the ctfmw[] array of the font                * *
  1192.  ************************************************************************ *
  1193.  */
  1194.  
  1195. void setup_ctfmw(struct Font *font)        /* dies wird auch in fast_cp.c gebraucht */
  1196. {
  1197.   int i, maxchar;
  1198.  
  1199.   maxchar = font->common->maxchars;
  1200.  
  1201.   /* printf("setup_ctfmw(%s, %d): maxchar = %d\n", font->common->fnt_group->fnt_name, font->fnt_number, maxchar);*/
  1202.  
  1203.   for (i = 0; i < maxchar; i++) {
  1204.     font->ctfmw[i] =
  1205.     scalewidth(font->common->fnt_group->tfmw[i], font->space_faktor);
  1206.   }
  1207.   for (; i < NPXLCHARS; i++) {
  1208.     font->ctfmw[i] = 0L;
  1209.   }
  1210.  
  1211.   font->ctfmw_valid = (char)TRUE;
  1212. }
  1213.  
  1214.  
  1215.  
  1216. /*
  1217.  ************************************************************************ *
  1218.  *    load the font fntnum                        * *
  1219.  ************************************************************************ *
  1220.  */
  1221.  
  1222. void SetFntNum (long fntnum)
  1223. { 
  1224.   struct FontLst *fntlst;
  1225.  
  1226.   for (fntlst = FontRoot->font_list;
  1227.        fntlst != NULL && fntlst->font.fnt_number != fntnum;
  1228.        fntlst = fntlst->next_font);
  1229.  
  1230.   if (fntlst == NULL) {
  1231.      Fatal(5, MSG_FONT_UNDEFINED, fntnum);
  1232.   }
  1233.  
  1234.   cfontptr = &(fntlst->font);        /* this is the actual font now */
  1235.  
  1236.   if (cfontptr->common->fnt_status == FNT_DEFINED ||
  1237.       cfontptr->common->fnt_status == FNT_DEFINED_OLOADED) {
  1238.     LoadFont(1,fntnum,(char *)NULL,0L,0L,0L,0L,0L);    /* load font */
  1239.   }
  1240.   else {
  1241.     setup_lru_font (FontRoot->font_list, cfontptr);
  1242.     if (!cfontptr->ctfmw_valid)
  1243.     setup_ctfmw(cfontptr);
  1244.   }
  1245.  
  1246.   /* nachfolgendes sollte man besser als zusaetzliche Information zum
  1247.    * Font ablegen (z.B. tenquadpxl = 10 * size of font in pt als Naeherung
  1248.    * fuer 1 quad; siehe Level0-Draft)
  1249.    */
  1250.   { double tenquad;
  1251.     unsigned long tenquadpxl;
  1252.     extern double alpha;
  1253.     extern long mag;
  1254.     extern int thinspace, backspace, vertsmallspace;
  1255.  
  1256.     tenquad = ((((double)(mag * cfontptr->space_faktor))/
  1257.         ((double)0x100000 * 100.0)) / alpha);
  1258.     tenquadpxl = (unsigned long)
  1259.         (tenquad * (100 * resolution) / 7227.0 + 0.5);
  1260. #if 0
  1261.     Logging("Font #%d >%s< at %ld = %ld  (ss: %lx  ds: %lx)",
  1262.     cfontptr->fnt_number, cfontptr->common->fnt_group->fnt_name,
  1263.     (long)floor(tenquad),
  1264.     tenquadpxl, cfontptr->space_faktor, cfontptr->design_faktor);
  1265. #endif
  1266.     vertsmallspace = 8 * tenquadpxl / 100;
  1267.     thinspace = 2 * tenquadpxl / 100;
  1268.     backspace = -(9 * tenquadpxl / 100);
  1269.   }
  1270. }
  1271.  
  1272.  
  1273. /*
  1274.  ************************************************************************ *
  1275.  *    is this font already defined?                    * *
  1276.  ************************************************************************ *
  1277.  */
  1278.  
  1279. int HasBeenRead(long fntnum)
  1280. {
  1281.   register struct FontLst *fntlst;
  1282.  
  1283.   for(fntlst = FontRoot->font_list; fntlst != NULL; fntlst = fntlst->next_font)
  1284.     if( fntlst->font.fnt_number == fntnum )
  1285.     return TRUE;
  1286.  
  1287.   return FALSE;
  1288. }
  1289.  
  1290.  
  1291.  
  1292. /*
  1293.  ************************************************************************
  1294.  *    search a font-group                        *
  1295.  ************************************************************************
  1296.  */
  1297.  
  1298. /*
  1299.  *  Search font `fntname' in group_list, if not found, make new group and
  1300.  *  insert it in group_list.
  1301.  */
  1302.  
  1303.   static struct CommonFontGroups *
  1304. search_font_group(char *fntname, struct FontMan *fnt_root)
  1305. {
  1306.   struct GroupLst *glst;
  1307.  
  1308.   for (glst = fnt_root->group_list; glst != NULL; glst = glst->next_group) {
  1309.     if( 0 == stricmp(fntname, glst->fnt_group.fnt_name) )
  1310.     return &(glst->fnt_group);
  1311.   }
  1312.  
  1313.   /* group not found: make a new one */
  1314.  
  1315.   /* Dirty Trick (but supported by all C-Compiler):
  1316.    * struct includes "char fnt_name[1]" declaration as last(!) part,
  1317.    * we have to allocate the struct and the string mem
  1318.    */
  1319.   glst = (struct GroupLst *) xmalloc(sizeof(struct GroupLst) + strlen(fntname));
  1320.  
  1321.   /**** Initialize structure: ****/
  1322.   { struct CommonFontGroups *gp;
  1323.     int i;
  1324.  
  1325.     gp = &(glst->fnt_group);
  1326.     strcpy(gp->fnt_name, fntname);
  1327.  
  1328.     /* set TFM width of all chars to ZERO */
  1329.     for( i = 0; i < NPXLCHARS; i++ ) {
  1330.     gp->tfmw[i] = 0L;
  1331.     }
  1332.   }
  1333.  
  1334.   /* and insert new group node at the beginning of group_list */
  1335.   glst->next_group = fnt_root->group_list;
  1336.   fnt_root->group_list = glst;
  1337.  
  1338.   return &(glst->fnt_group);
  1339. }
  1340.  
  1341.  
  1342. /*
  1343.  ************************************************************************ *
  1344.  *    make new fontlist and commonelement nodes for the font        * *
  1345.  ************************************************************************ *
  1346.  */
  1347.  
  1348. /*
  1349.  *  Make new font description for `fntname' and insert it in font_list.
  1350.  */
  1351.  
  1352.   static struct Font *
  1353. make_new_fontdesc(char *fntname, struct FontMan *fnt_root)
  1354. {
  1355.   struct Font *fnt;
  1356.   struct FontLst *fontlst;
  1357.     
  1358.   fontlst = (struct FontLst *)xmalloc((size_t)sizeof(struct FontLst));
  1359.   fnt = &(fontlst->font);
  1360.  
  1361.   fnt->common = (struct CommonFontElems *)
  1362.             xmalloc((size_t)sizeof(struct CommonFontElems));
  1363.  
  1364.   /* Search for the group of this font, if none found, make a new group */
  1365.   fnt->common->fnt_group        = search_font_group(fntname, FontRoot);
  1366.  
  1367.   /* Initialize... */
  1368.   fnt->common->fnt_length        = 0L;
  1369.   fnt->common->lru_count        = 0L;
  1370.   fnt->common->ch_start_bm        = NULL;
  1371.   fnt->common->ch_len            = 0L;
  1372.   fnt->common->location.pk_directory    = NULL;
  1373.   /* search_font_group initialize the TFM width info to 0L for new group
  1374.    * => it's save to set maxchars to NPXLCHARS
  1375.    * (=> if this font doesn't exist, it uses the whole tfmw array)
  1376.    */
  1377.   fnt->common->maxchars            = NPXLCHARS;
  1378.  
  1379.   fnt->space_faktor        = 0L;
  1380.   fnt->design_faktor        = 0L;
  1381.   fnt->chksum            = 0L;
  1382.   fnt->ctfmw_valid        = (char)FALSE;
  1383.  
  1384.   /* insert font at the beginning of the font-list */
  1385.   fontlst->next_font  = fnt_root->font_list;
  1386.   fnt_root->font_list = fontlst;
  1387.  
  1388.   return fnt;
  1389. }
  1390.  
  1391.  
  1392. /*
  1393.  ************************************************************************ *
  1394.  *    load / define a font                        * *
  1395.  *    where we must search the font?                    * *
  1396.  *        - user defs / pk-dirs / flib-dirs or            * *
  1397.  *        - user defs / flib-dirs / pk-dirs or ...?        * *
  1398.  ************************************************************************ *
  1399.  */
  1400.  
  1401. void LoadFont(int  action, long fntnum, char *fntname,
  1402.           long chksum, long d, long s, long fontmag, long fontmag5)
  1403.     /*
  1404.      * 0: define only    \
  1405.      * 1: load only         => action
  1406.      * 2: define & load    /
  1407.      */
  1408. {
  1409.   struct FontLst *fntlst;
  1410.   struct Font *fnt;
  1411.   char full_name[PATH_SIZE+FLIB_NAME_SIZE];
  1412.   int i, is_subst = FALSE;
  1413.  
  1414.  
  1415.   /* search font with the correct fntnum */
  1416.   for (fntlst = FontRoot->font_list;
  1417.        fntlst != NULL && fntlst->font.fnt_number != fntnum;
  1418.        fntlst = fntlst->next_font);
  1419.  
  1420.   if (fntlst != NULL)        /* font with fntnum found -> font defined */
  1421.    {
  1422.     if (action != 1)        /* define font, but font already defined?? */
  1423.      {
  1424.        Fatal(5, MSG_FONT_ALREADY_DEFINED, fntname, fntnum);
  1425.      }
  1426.     fnt = &(fntlst->font);
  1427.    }
  1428.   else                /* no font with fntnum found -> font undefined */
  1429.    {
  1430.     if (action == 1) {        /* load only, but font not defined?? */
  1431.       Fatal(5, MSG_FONT_STR_UNDEFINED, fntname, fntnum);
  1432.     }
  1433.  
  1434.     /****    and now -> search the font    ****/
  1435.     fnt = search_font(fntname, fontmag, fontmag5, FontRoot);
  1436.    }
  1437.  
  1438.  
  1439.   if (fnt == NULL) {
  1440.     /* Oh no, NO font */
  1441.     /* Warning already printed */
  1442.  
  1443.     fnt = make_new_fontdesc(fntname, FontRoot);
  1444.  
  1445.     fnt->fnt_number            = fntnum;
  1446.     fnt->common->fnt_status    = FNT_NOT_EXISTS;
  1447.     fnt->common->resolution    = fontmag;
  1448.     fnt->common->resolution5   = fontmag5;
  1449.     fnt->orig_dpi              = fontmag;
  1450.     fnt->space_faktor          = s;
  1451.     fnt->design_faktor         = d;
  1452.     fnt->chksum                = chksum;
  1453.     
  1454.     for (i=0; i < NPXLCHARS; i++)     /* mark the chars */
  1455.      {
  1456.       fnt->common->ch[i].packed_data = -1L;
  1457.      }
  1458.  
  1459.     /*
  1460.      * Here we can read the tfm-file of this font (if it exists).
  1461.      * Currently we use the tfmw info of another font in the same font
  1462.      * group for the char width info.
  1463.      */
  1464.     return;                /* =========>>>>> and return */
  1465.   }
  1466.  
  1467.   /* ======================================== */
  1468.   /* ===   We know, that fnt != NULL      === */
  1469.   /* ======================================== */
  1470.  
  1471.   /* here it is */
  1472.  
  1473.   if (action != 1) {            /* not ONLY load the font */
  1474.       /* define the font */
  1475.  
  1476.       /* is this font a substituted font ?? */
  1477.       if (fnt->fnt_number != fntnum &&
  1478.       (fnt->common->fnt_status == FNT_DEFINED || 
  1479.        fnt->common->fnt_status == FNT_DEFINED_OLOADED || 
  1480.        fnt->common->fnt_status == FNT_LOADED)) {
  1481.  
  1482.         /* problem with substituted fonts -> same font with different fntnum */
  1483.         struct FontLst *fontlst;
  1484.  
  1485.     is_subst = TRUE;
  1486.         fontlst = (struct FontLst *)xmalloc((size_t)sizeof(struct FontLst));
  1487.         fontlst->font.common        = fnt->common;
  1488.         fontlst->font.orig_dpi      = fontmag;
  1489.  
  1490.         /* sort font into font-list */
  1491.         fontlst->next_font = FontRoot->font_list;
  1492.         FontRoot->font_list = fontlst;
  1493.  
  1494.         fnt = &(fontlst->font);        /* this is now the current font */
  1495.       }
  1496.  
  1497.       fnt->fnt_number    = fntnum;    /* define the font */
  1498.       fnt->space_faktor  = s;
  1499.       fnt->design_faktor = d;
  1500.       fnt->chksum        = chksum;
  1501.       fnt->ctfmw_valid   = (char)FALSE;
  1502.       
  1503. #if 0    /* bin mir nicht sicher, ob das gemacht werden muss */
  1504.       /* Bei den substituierten Fonts muss das ctfmw Feld wieder aufgefrischt werden! */
  1505.       if (is_subst && (fnt->common->fnt_status == FNT_DEFINED_OLOADED || 
  1506.                   fnt->common->fnt_status == FNT_LOADED)) {
  1507.         fnt->common->fnt_status = FNT_LOADED;
  1508.         setup_ctfmw(fnt);
  1509.       }
  1510. #endif
  1511.  
  1512.   }    /* if (action != 1) */
  1513.  
  1514.   /* exist's the font ?? */
  1515.   if (fnt->common->fnt_status == FNT_NOT_EXISTS) {
  1516.       return;                /* =========>>>>> and return */
  1517.   }
  1518.  
  1519.   if (action == 0) {            /* only define the font */
  1520.       /* FNT_LOADET ist auch moeglich (wb. Substituierung..) */
  1521.       if (fnt->common->fnt_status != FNT_OLD_LOADED && 
  1522.       fnt->common->fnt_status != FNT_LOADED) {
  1523.         fnt->common->fnt_status = FNT_DEFINED;
  1524.       } else {
  1525.         fnt->common->fnt_status = FNT_DEFINED_OLOADED;
  1526. #if 0    /* bin mir nicht sicher, ob das gemacht werden muss */
  1527.         setup_ctfmw(fnt);
  1528. #endif
  1529.       }
  1530.       return;                /* =========>>>>> and return */
  1531.   }
  1532.  
  1533.   /* ================================================================= */
  1534.   /* === The font is defined, it exists ... and now: load the font === */
  1535.   /* ================================================================= */
  1536.  
  1537.   if (fnt->common->fnt_status == FNT_OLD_LOADED
  1538.     || fnt->common->fnt_status == FNT_DEFINED_OLOADED
  1539.     || (is_subst && fnt->common->fnt_status == FNT_LOADED)) {
  1540.     /* pk-file already loaded */
  1541.     if (!is_subst) {
  1542.       sprintf(m_string,GetTeXString(MSG_RELOAD_FONT),
  1543.         fnt->common->fnt_group->fnt_name, fnt->common->resolution);
  1544.       /** Message(m_string); reload ist auf'n Bildschirm nicht so interessant **/
  1545.       sprintf(full_name,GetTeXString(MSG_FONTMEM_USED),
  1546.             (long)(100L-(end_mem-lowmem)*100L/fontmemsize));
  1547.       strcat(m_string,full_name);
  1548.       LoggingStr(m_string);
  1549.     }
  1550.  
  1551.     setup_lru_font (FontRoot->font_list, fnt);
  1552.     fnt->common->fnt_status = FNT_LOADED;
  1553.  
  1554.     setup_ctfmw(fnt);
  1555.     return;                /* =========>>>>> and return */
  1556.   }
  1557.  
  1558.   /* ======================= */
  1559.   /* === Load a new font === */
  1560.   /* ======================= */
  1561.   
  1562.   /* So nun sollte eigentlich der Font ins Fontmemory geladen werden.    */
  1563.   /* Alles ist bestens vorbereitet, ein Aufruf Load_really(fnt) taets.    */
  1564.   /* Aber es wird nicht gemacht! Es wird verzoegert, bis wirklich ein    */
  1565.   /* Zeichen aus dem Font benoetigt wird. Sprich erst wenn ein Zeichen    */
  1566.   /* in SetChar nicht gefunden wird. Falls der Font nur definiert ist,    */
  1567.   /* so wird ein Load_really() probiert.                */
  1568.   /* Das hat den Vorteil, wenn ein Font 'removed' wurde, die        */
  1569.   /* benoetigten Chars aber schon im Speicher sind, muss der Font nicht    */
  1570.   /* gleich wieder geladen werden, sonder eben erst, wenn ein Char    */
  1571.   /* auszupacken ist.                        (hes)    */
  1572.  
  1573.   /* printf("Load new font %s %d (was loaded %d, status %d, valid %d)\n", fnt->common->fnt_group->fnt_name, */
  1574.   /*    fnt->fnt_number, fnt->common->was_loadet, fnt->common->fnt_status, fnt->ctfmw_valid);*/
  1575.  
  1576.   if (!fnt->common->was_loadet) {
  1577.     /* dieser Font ist noch nie geladen worden... */
  1578.     /* also lade ihn zum ersten Mal. Dabei werden */
  1579.     /* auch die Chars Strukturen initialisiert.   */
  1580.     struct Chars *cd;
  1581.  
  1582.     fnt->common->was_loadet = TRUE;
  1583.  
  1584.     /* Initialisiere das ganze nur *einmal* pro Font! */
  1585.     cd = fnt->common->ch;
  1586.     for (i=0; i<NPXLCHARS; i++) {
  1587.       cd->pixelwidth  = 0;
  1588.       cd->packed_data = -1;    /* NIL pointer in internal memory */
  1589.       cd->unpacked    = NULL;
  1590.       cd++;
  1591.     }
  1592.  
  1593.     Load_really(fnt);    /* beim ersten Mal wird's gleich geladen! */
  1594.   }
  1595.   else {
  1596.     setup_ctfmw(fnt);    /* der Font war zwar schon mal geladen, aber ctfmw muss wieder geupdated werden */
  1597.   }
  1598. }
  1599.  
  1600.  
  1601.  
  1602.  
  1603.  
  1604. /*
  1605.  ************************************************************************ *
  1606.  *    macht nun den letzten Schritt: Laed den Font in das fontmem    * *
  1607.  ************************************************************************ *
  1608.  */
  1609.  
  1610.  
  1611. void Load_really(struct Font *fnt)    
  1612.                     /* fnt_root wird *global* genommen */
  1613. {
  1614.   FILE *pkfile;
  1615.   char libname[FLIB_NAME_SIZE];
  1616.   char full_name[PATH_SIZE+FLIB_NAME_SIZE];
  1617.   long fntnum;
  1618.   char *fntname;
  1619.  
  1620.   fntnum = fnt->fnt_number;
  1621.   fntname = &(fnt->common->fnt_group->fnt_name[0]);
  1622.  
  1623.   if (fnt->common->fnt_status == FNT_LOADED) {
  1624.     Fatal(5,MSG_LOAD_LOADED_FONT,fntname,fntnum);
  1625.   }
  1626.  
  1627.   Message(MSG_LOAD_FONT,fnt->common->fnt_group->fnt_name,fnt->common->resolution);
  1628.  
  1629.   if (fnt->common->where_is_font == WHERE_LIB) {
  1630.     setup_lru_flib(FontRoot->flib_list, fnt->common->location.fnt_library);
  1631.     pkfile = fnt->common->location.fnt_library->file_ptr;
  1632.     if (pkfile == NULL) {
  1633.        if (fnt->common->location.fnt_library->lib_status == LIB_READ_CLOSED) {
  1634.  
  1635.       my_sprintf(libname,FLIB_NAME_SIZE,fnt->common->location.fnt_library->format_str /*FontRoot->flib_fmt*/,
  1636.             fnt->common->fnt_group->fnt_name,
  1637.             fnt->common->resolution,
  1638.             fnt->common->resolution5);
  1639.       strcpy(full_name,fnt->common->location.fnt_library->path);
  1640.       mk_correct_path(full_name);
  1641.       strcat(full_name,libname);
  1642.  
  1643.       pkfile = BINARYOPEN(full_name);
  1644.       if (pkfile != NULL) {
  1645.         FontRoot->files_left--;
  1646.         fnt->common->location.fnt_library->lib_status = LIB_OPEND;
  1647.         fnt->common->location.fnt_library->file_ptr   = pkfile;
  1648.         MarkFile(full_name);
  1649.       }
  1650.       else {
  1651.                 Fatal(5,MSG_CANT_OPEN,full_name);
  1652.       }
  1653.        }
  1654.        else {
  1655.       Fatal(20,MSG_INTERNAL_ERROR_LIB_MISMATCH);
  1656.        }
  1657.     }
  1658.     fseek(pkfile,fnt->common->where_in_lib,0);
  1659.   }
  1660.   else {
  1661.     /* load pk-file */
  1662.     strcpy(full_name,fnt->common->location.pk_directory->path);
  1663.     mk_correct_path(full_name);
  1664.     my_sprintf(libname,FLIB_NAME_SIZE,
  1665.         fnt->common->location.pk_directory->format_str,
  1666.         fnt->common->fnt_group->fnt_name,
  1667.         fnt->common->resolution, fnt->common->resolution5);
  1668.  
  1669. #ifdef UNNOETIG
  1670.     if (fnt->common->where_is_font == WHERE_PKDIR) {
  1671.       my_sprintf(libname,FLIB_NAME_SIZE,
  1672.         fnt->common->location.pk_directory->format_str /*FontRoot->pkdir_fmt*/,
  1673.         fnt->common->fnt_group->fnt_name,
  1674.         fnt->common->resolution, fnt->common->resolution5);
  1675.     }
  1676.     else {
  1677.       my_sprintf(libname,FLIB_NAME_SIZE,
  1678.         fnt->common->location.pk_directory->format_str /*FontRoot->pk_fmt*/,
  1679.         fnt->common->fnt_group->fnt_name,
  1680.         fnt->common->resolution, fnt->common->resolution5);
  1681.     }
  1682. #endif
  1683.     strcat(full_name,libname);
  1684.     if (fnt->common->fnt_status == FNT_PATH_DEFINED) {    /* shouldn't occur */
  1685.       fnt->common->fnt_length = test_pk_file(full_name);    /* check size */
  1686.       if (fnt->common->fnt_length == 0L) {
  1687.         Fatal(5,MSG_CANT_OPEN,full_name);
  1688.       }
  1689.     }
  1690.     pkfile = BINARYOPEN(full_name);
  1691.     if (pkfile == NULL) {
  1692.       Fatal(5,MSG_CANT_OPEN,full_name);
  1693.     }
  1694.     MarkFile(full_name);
  1695.   }
  1696.  
  1697.   if (pkfile == NULL) {        /* unnoetig, da schon abgefragt */
  1698.     FatalStr(20,"pkfile == NULL");
  1699.   }
  1700.  
  1701.   setup_lru_font(FontRoot->font_list, fnt);
  1702.  
  1703.   fnt->common->copied = (char)FALSE;
  1704.   fnt->common->ch_start_bm = open_charmap ();
  1705.  
  1706.   loadfont(fnt, pkfile);    /* NEW (laed nur pk-file, packt _nicht_ aus) */
  1707.  
  1708.   fnt->common->ch_len = close_charmap ();
  1709.   fnt->common->fnt_status  = FNT_LOADED;
  1710.   setup_ctfmw(fnt);
  1711.  
  1712.   if (fnt->common->where_is_font != WHERE_LIB) {
  1713.     fclose(pkfile);
  1714.   }
  1715.  
  1716.   Logging(MSG_LOAD_FONT_MEM_USED,
  1717.     fnt->common->fnt_group->fnt_name,
  1718.     fnt->common->resolution,
  1719.     100L-(end_mem-lowmem)*100L/fontmemsize);
  1720.  
  1721.   if (Stats) {
  1722.     if (fnt->common->where_is_font == WHERE_LIB) {
  1723.       my_sprintf(full_name, PATH_SIZE+FLIB_NAME_SIZE, fnt->common->location.fnt_library->format_str,
  1724.         fnt->common->fnt_group->fnt_name,
  1725.         fnt->common->resolution, fnt->common->resolution5);
  1726.       Logging(MSG_FOUND_IN_LIB,
  1727.         fnt->common->location.fnt_library->path, full_name);
  1728.     }
  1729.     else {
  1730.       my_sprintf(full_name, PATH_SIZE+FLIB_NAME_SIZE, fnt->common->location.pk_directory->format_str,
  1731.         fnt->common->fnt_group->fnt_name,
  1732.         fnt->common->resolution, fnt->common->resolution5);
  1733.       Logging(MSG_FOUND_AS_PK,
  1734.         fnt->common->location.pk_directory->path, full_name);
  1735.     }
  1736.   }
  1737. }
  1738.  
  1739.  
  1740.  
  1741. /*
  1742.  ************************************************************************ *
  1743.  *    alloc the memory for a character                * *
  1744.  ************************************************************************ *
  1745.  */
  1746.  
  1747. long alloc_char (size)
  1748.   ulong size;
  1749. { 
  1750.   char *memstart;
  1751.  
  1752. #if 0
  1753.   size += (4 - (size % 4));    /* if size%4 == 0, add 4 ???? */
  1754. #else
  1755.   size = (size + 3) & ~3L;    /* long alignment */
  1756. #endif
  1757.  
  1758.   while (size > (long)(end_mem - lowmem)) {
  1759.      if( do_garcol() != 0 )
  1760.     return (-1L);    /* no memory */
  1761.   }
  1762.  
  1763.   memstart = lowmem;
  1764. #if 0
  1765.   lowmem = (char *)((ulong)lowmem + size);
  1766. #else
  1767.   lowmem += size;
  1768. #endif
  1769.  
  1770.   if (lowmem  < start_mem || charmap < start_mem ||
  1771.       lowmem  > end_mem   || charmap > end_mem ) {
  1772.     Fatal(10,MSG_MEMORY_ERROR);
  1773.   }
  1774.  
  1775.   return (long)((memstart - charmap)/sizeof(long));    /* / bytesperlong */
  1776. }
  1777.  
  1778.  
  1779. /* (br)
  1780.  * Substitution von Fonts sollte man noch verbessern, z.B. ist es
  1781.  * manchmal im Previewer wuenschenswert, wenn man kurz auf eine hoehere
  1782.  * Magnification gehen kann und trotzdem noch die meisten Fonts gefunden
  1783.  * werden (wenn man Fonts komplett in allen maghalf-Steps hat).
  1784.  *
  1785.  * Nachfolgend ist ein Ansatz, wie man dies machen kann.
  1786.  *
  1787.  * Um nicht zu grosse Rundungsfehler zu haben, sollte die Resolution, DPI
  1788.  * bzw. DPI5 (oder Magnification bzgl. DPI) eines Fonts besser mit einem
  1789.  * Faktor zwischen 2^8 und 2^16 multipliziert im Font-Struct abgelegt werden.
  1790.  * (Danach muss man jedoch auf Overflows achten !)
  1791.  */
  1792.  
  1793. /*
  1794.  ************************************************************************
  1795.  *    try to substitute a font within magscale list            *
  1796.  ************************************************************************
  1797.  */
  1798.  
  1799. struct Font *mag_substitution(fntname, dpi, fnt_root)
  1800.   char          *fntname;
  1801.   long          dpi;
  1802.   struct FontMan  *fnt_root;
  1803. {
  1804.   struct Font *fnt;
  1805.   int i, nr;
  1806.   long diff, temp, new_dpi, new_dpi5;
  1807.  
  1808.   diff = 1L<<30;            /* max diff */
  1809.   nr = 0;
  1810.  
  1811.   for ( i = 0; i < NRMAGS; i++ ) {
  1812.     /** new_dpi  = ((long)resolution * mags[nr] + 500L) / 1000L; **/
  1813.     new_dpi  = ((long)resolution * mags[i] + 500L) / 1000L;
  1814.     temp = abs(dpi - new_dpi);
  1815.     /* subst. Font sollte nicht groesser als 5% ueber tatsaechlichem sein */
  1816.     /* (Heuristik) */
  1817.     if (temp < diff && (new_dpi <= dpi || temp <= (resolution * 5)/100) ) {
  1818.         nr = i;
  1819.         diff = temp;
  1820.     }
  1821.   }
  1822.  
  1823.   fnt = NULL;
  1824.  
  1825.   while (nr >= 0 && fnt == NULL) {
  1826.       new_dpi  = ((long)resolution * mags[nr] + 500L) / 1000L;
  1827. #ifdef FONT_MAG
  1828.       new_dpi5 = mags[nr];
  1829. #else
  1830.       new_dpi5 = ((long)resolution * 5 * mags[nr] + 500L) / 1000L;
  1831. #endif
  1832.       if (new_dpi != dpi) {
  1833.         fnt = search_font_location(fntname, new_dpi, new_dpi5, fnt_root);
  1834.       }
  1835.       if (fnt == NULL) {
  1836.         nr--;
  1837.         if (fnt_root->files_left <= 0) {
  1838.           close_flibs(fnt_root);
  1839.         }
  1840.       }
  1841.   }
  1842.  
  1843.   if (nr >= 0) {
  1844.       /* substitute font */
  1845.       Logging(MSG_SUBSTITUTE_FONT,fntname,dpi,new_dpi);
  1846.       Message(MSG_SUBSTITUTE_FONT,fntname,dpi,new_dpi);
  1847.   }
  1848.   else {
  1849. #ifdef OLD_NOFONT
  1850.     /* no font found */
  1851.     struct noFont *nf;
  1852.   
  1853.     /* Dirty Trick (string alloc) */
  1854.     nf = (struct noFont *)xmalloc(sizeof(struct noFont) + strlen(fntname));
  1855.  
  1856.     strcpy(nf->fnt_name, fntname);
  1857.     nf->resolution = dpi;
  1858.  
  1859.     nf->next = fnt_root->noFontList;
  1860.     fnt_root->noFontList = nf;
  1861. #endif
  1862.     if (hconvresolution == vconvresolution) {
  1863.       Warning(MSG_FONT_NOT_FOUND, fntname, dpi);
  1864.     }
  1865.     else {
  1866.       Warning(MSG_FONT_XY_NOT_FOUND, fntname, dpi, compute_vert(dpi));
  1867.     }
  1868.   }
  1869.  
  1870.   return fnt;
  1871. }
  1872.  
  1873. /*
  1874.  ************************************************************************
  1875.  *    try to substitute a font with defined fonts/flibs        *
  1876.  ************************************************************************
  1877.  */
  1878.  
  1879. #if 0    /* dass muss ich mir erst mal spaeter in Ruhe ansehen (hes) */
  1880.  
  1881. struct Font *dpi_substitution(fntname, magnification, fnt_root)
  1882.   char          *fntname;
  1883.   long          magnification;
  1884.   struct FontMan  *fnt_root;
  1885. {
  1886.   struct Font *fnt;
  1887.   struct LibLst *lp;
  1888.   long diff, ndiff, dpi, best_dpi = 0L;
  1889.  
  1890.   diff = 1L << 30;
  1891.  
  1892.   for(lp = fnt_root->flib_list; lp != NULL; lp = lp->next_lib) {
  1893.     if( lp->flib.lib_status == LIB_NONE
  1894.     || lp->flib.lib_status == LIB_NOT_EXISTS )
  1895.       continue;
  1896.     dpi = lp->flib.resolution;
  1897.     ndiff = abs(magnification - dpi);
  1898.     /* subst. Font sollte nicht groesser als 5% ueber tatsaechlichem sein */
  1899.     if( ndiff < diff && (dpi <= magnification || ndiff <= 5*resolution/100) ) {
  1900.     diff = ndiff;
  1901.     best_dpi = dpi;
  1902.     }
  1903.   }
  1904.  
  1905.   Logging(MSG_TRY_SUBSTITUTE,fntname, magnification, best_dpi);
  1906.  
  1907.   fnt = NULL;
  1908.  
  1909.   if( best_dpi > 0L ) {        /* wir haben was gefunden */
  1910.     long dpi5;
  1911.  
  1912.     /* Oouch, this could be totally buggy! */
  1913. #ifdef FONT_MAG
  1914.     dpi5 = (best_dpi * 1000 + resolution/2) / resolution;
  1915. #else
  1916.     dpi5 = best_dpi * 5;
  1917. #endif
  1918.  
  1919.     fnt = search_font_location(fntname, best_dpi, dpi5, fnt_root);
  1920.   }
  1921.  
  1922.   if( fnt != NULL ) {
  1923.       /* substitute font */
  1924.       Logging(MSG_SUBSTITUTE_FONT,fntname, magnification, best_dpi);
  1925.       Message(MSG_SUBSTITUTE_FONT,fntname, magnification, best_dpi);
  1926.   }
  1927.  
  1928.   return fnt;
  1929. }
  1930.  
  1931. #endif
  1932.  
  1933.  
  1934. /*
  1935.  ************************************************************************
  1936.  *    search a font, substitute fonts if necessary            *
  1937.  ************************************************************************
  1938.  */
  1939.  
  1940. static struct Font *search_font(fntname, magnification, magnification5, fnt_root)
  1941.   char          *fntname;
  1942.   long          magnification;
  1943.   long          magnification5;
  1944.   struct FontMan  *fnt_root;
  1945. {
  1946.   struct Font *fnt;
  1947.  
  1948.   fnt = search_font_location(fntname, magnification, magnification5, fnt_root);
  1949.  
  1950. #ifdef AMIGA
  1951.   if (fnt == NULL) {
  1952.     char pkname[PK_NAME_SIZE];
  1953.     char pkdir[PATH_SIZE];
  1954.     char *format;
  1955.     struct SeaEleDpi *dele;
  1956.     short found;
  1957.  
  1958.     found = FALSE;
  1959.     for (dele = FontRoot->s_list_base_pkdpi.first_ele; dele != NULL && !found; dele = dele->next_ele) {
  1960.       if (dele->hdpi == hconvresolution && dele->vdpi == vconvresolution) {
  1961.         strcpy(pkdir, dele->path);
  1962.         mk_correct_path(pkdir);
  1963.         format = dele->format_str;
  1964.         found = TRUE;
  1965.       }
  1966.     }
  1967.     if (!found) {
  1968.       strcpy(pkdir, "TeX:pk/");
  1969.       format = fnt_root->pk_fmt;
  1970.     }
  1971.  
  1972.     my_sprintf(pkname, PK_NAME_SIZE, format, fntname, magnification, magnification5);
  1973.  
  1974.     if (call_mf(fntname, magnification, hconvresolution, vconvresolution,
  1975.         (long)fnt_root->driver_type, pkname, pkdir)) {    /* call metafont */
  1976.       fnt = search_font_location(fntname, magnification, magnification5,
  1977.                       fnt_root);
  1978.     }
  1979.   }
  1980. #endif /* AMIGA */
  1981.  
  1982.   if (fnt == NULL) {
  1983.     /* not found => try to substitute, find first matching magstep */
  1984.     fnt = mag_substitution(fntname, magnification, fnt_root);
  1985.   }
  1986.  
  1987. #if 0    /* das geh ich erst spaeter an... (hes) */
  1988.   if (fnt == NULL) {
  1989.     /* search dpi-list of defined flibs, pk's etc. for a possible subst */
  1990.     fnt = dpi_substitution(fntname, magnification, fnt_root);
  1991.   }
  1992. #endif
  1993.  
  1994.   if (fnt != NULL) {
  1995.     /* font found => set lru counter */
  1996.     setup_lru_font(fnt_root->font_list, fnt);
  1997.   }
  1998.   
  1999.   if (fnt_root->files_left <= 0) {
  2000.     /* close files */
  2001.     close_flibs(fnt_root);
  2002.   }
  2003.  
  2004.   return (fnt);
  2005. }
  2006.  
  2007.  
  2008. /*
  2009.  ************************************************************************
  2010.  *    where is the font?                        *
  2011.  ************************************************************************
  2012.  */
  2013.  
  2014. static struct Font *search_font_location(fntname, dpi, dpi5, fnt_root)
  2015.   char          *fntname;
  2016.   long          dpi, dpi5;
  2017.   struct FontMan  *fnt_root;
  2018. {
  2019.   /* search only for the location of the font.                */
  2020.   /* Returns NULL if the font cannot be found.                */
  2021.   /* return:                                */
  2022.   /*    font structure with fnt_name/fnt_status/where_is_font/resol.    */
  2023.  
  2024.   struct Font *fnt;
  2025.  
  2026.   /* Ist der Font einzeln definiert?                 --------------------*/
  2027.   fnt = is_font_in_font_list(fntname, dpi, dpi5, fnt_root->font_list, fnt_root);
  2028.  
  2029.   if (fnt == NULL) {
  2030.     /* Ist eine passende Library einzeln oder per ENV definiert? -------------------*/
  2031.     fnt = is_font_in_lib_list(fntname, dpi, dpi5, fnt_root);
  2032.  
  2033.     if (fnt == NULL) {
  2034.       /* Ist der Font in einem vordefinierten Base-DPI Verzeichnis? ----------------*/
  2035.       fnt = is_font_in_pred_pk_dirs(fntname, dpi, dpi5, fnt_root, (short)1);
  2036.  
  2037.       if (fnt == NULL) {
  2038.         /* Ist der Font in einem PK-Dir, definiert in der ENV Variable? ------------*/
  2039.         fnt = is_font_in_pk_dirs(fntname, dpi, dpi5, fnt_root);
  2040.  
  2041.         if (fnt == NULL) {
  2042.           /* Ist der Font in einem fuer eine bestimmte DPI ausgelegten Directory? --*/
  2043.           /* Diese Moeglichkeit ist mehr zum Fontsubstituieren gedacht,            */
  2044.           /* deshalb wird dies erst nach dem Durchsuchen der ENV Pfade gemacht.        */
  2045.           fnt = is_font_in_pred_pk_dirs(fntname, dpi, dpi5, fnt_root, (short)0);
  2046.  
  2047. #ifdef AMIGA
  2048.           if (fnt == NULL) {
  2049.             /* Ist der Font ueber das TeX:pk/fontvols File zu finden? --------------*/
  2050.             fnt = read_atex_file(fntname, dpi, dpi5, fnt_root);
  2051.           }
  2052. #endif
  2053.         }
  2054.       }
  2055.     }
  2056.   }
  2057.  
  2058.   return (fnt);
  2059. }
  2060.  
  2061.  
  2062. /*
  2063.  ************************************************************************
  2064.  *    is the font in the font list                    *
  2065.  ************************************************************************
  2066.  */
  2067.  
  2068. static struct Font *is_font_in_font_list(fntname, dpi, dpi5, fnt_list, fnt_root)
  2069.   char *fntname;
  2070.   long dpi, dpi5;
  2071.   struct FontLst *fnt_list;
  2072.   struct FontMan *fnt_root;
  2073. {
  2074.   /* easy function. Looks only in the list of the defined fonts    */
  2075.   /* ^^^^ naja (rbs)                        */
  2076.   /* this function doesn't define a NEW font!            */
  2077.   /* only changes the status of a font                */
  2078.  
  2079.   struct FontLst *lst;
  2080.   char pkname[PK_NAME_SIZE], full_name[PATH_SIZE+FLIB_NAME_SIZE];
  2081.   long size;
  2082.  
  2083.   lst = fnt_list;
  2084.   if (lst == NULL)
  2085.     return NULL;
  2086.  
  2087.   do {
  2088.     if (lst->font.common->resolution == dpi
  2089.     && stricmp(lst->font.common->fnt_group->fnt_name, fntname) == 0) {
  2090.       if (lst->font.common->fnt_status == FNT_FOUND
  2091.       || lst->font.common->fnt_status == FNT_DEFINED
  2092.       || lst->font.common->fnt_status == FNT_LOADED
  2093.       || lst->font.common->fnt_status == FNT_DEFINED_OLOADED
  2094.       || lst->font.common->fnt_status == FNT_OLD_LOADED) {
  2095.         return &(lst->font);
  2096.       }
  2097.       if (lst->font.common->fnt_status == FNT_PATH_DEFINED) {
  2098.         if (lst->font.common->where_is_font == WHERE_LIB) {
  2099.           Fatal(10,MSG_PREDEF_FONT_IN_LIB);
  2100.       /* NOT REACHED */
  2101.     }
  2102.         my_sprintf(pkname, PK_NAME_SIZE,
  2103.         lst->font.common->location.pk_directory->format_str /*fnt_root->pk_fmt*/,
  2104.         fntname, dpi, dpi5);
  2105.         strcpy(full_name, lst->font.common->location.pk_directory->path);
  2106.         mk_correct_path(full_name);
  2107.         strcat(full_name,pkname);
  2108.         size = test_pk_file(full_name);
  2109.         if (size != 0L) {
  2110.           lst->font.common->fnt_status = FNT_FOUND;
  2111.           lst->font.common->fnt_length = size;
  2112.           return &(lst->font);
  2113.     }
  2114.     /* (size == 0L) */
  2115.         lst->font.common->fnt_status = FNT_NOT_EXISTS;
  2116.         Logging(MSG_PREDEF_FONT_NOT_FOUND,fntname,dpi);
  2117.       }
  2118.     }
  2119.   } while( (lst = lst->next_font) != NULL );
  2120.  
  2121.   return NULL;
  2122. }
  2123.  
  2124.  
  2125. /*
  2126.  ************************************************************************
  2127.  *    is the font in a fontlibrary                    *
  2128.  ************************************************************************
  2129.  */
  2130.  
  2131. static struct Font *is_font_in_lib_list(fntname, dpi, dpi5, fnt_root)
  2132.   char *fntname;
  2133.   long dpi, dpi5;
  2134.   struct FontMan *fnt_root;
  2135. {
  2136.   /* this function looks in all directories for the fontlibraries    */
  2137.   /* then it looks if the fontlib in this directory is already opened    */
  2138.   /* if this is successful, then define a new font and a new fontlibrary */
  2139.  
  2140.   struct Font *font;
  2141.  
  2142.   /**** search in the list of predefined libs ****/
  2143.   font = search_in_defined_libs(fntname, dpi, dpi5, fnt_root);
  2144.  
  2145.   if (font == NULL) {
  2146.     /**** font not in a predefined lib => search in the rest of the pathes ****/
  2147.     font = search_in_rest_pathes(fntname, dpi, dpi5, fnt_root);
  2148.   }
  2149.  
  2150.   return (font);
  2151. }
  2152.  
  2153.  
  2154. /*
  2155.  ************************************************************************
  2156.  *    is the font in a pk-directory (not predefined)            *
  2157.  ************************************************************************
  2158.  */
  2159.  
  2160. static struct Font *is_font_in_pk_dirs(fntname, dpi, dpi5, fnt_root)
  2161.   char *fntname;
  2162.   long dpi, dpi5;
  2163.   struct FontMan *fnt_root;
  2164. {
  2165.   struct Font    *font;
  2166.   struct SeaEle    *ele;
  2167.  
  2168.   ele = fnt_root->s_list_pkdirs.first_ele;
  2169.   font = NULL;
  2170.  
  2171.   while (font == NULL && ele != NULL) {
  2172.     font = define_test_pk_font(ele->path, fntname, dpi, dpi5,
  2173.                 fnt_root->pk_fmt, fnt_root);
  2174.     ele = ele->next_ele;
  2175.   }
  2176.   return (font);
  2177. }
  2178.  
  2179.  
  2180. /*
  2181.  ************************************************************************
  2182.  *    is the font in a pk-directory (defined in *.fnt)        *
  2183.  ************************************************************************
  2184.  */
  2185.  
  2186. static struct Font *is_font_in_pred_pk_dirs(fntname, dpi, dpi5, fnt_root, base)
  2187.   char *fntname;
  2188.   long dpi, dpi5;
  2189.   struct FontMan *fnt_root;
  2190.   short base;    /* search in base pk-dirs or in normal pk-dirs? */
  2191. {
  2192.   struct Font        *font;
  2193.   struct SeaEleDpi    *ele;
  2194.  
  2195.   if (base) {
  2196.     ele = fnt_root->s_list_base_pkdpi.first_ele;
  2197.   }
  2198.   else {
  2199.     ele = fnt_root->s_list_pkdpi.first_ele;
  2200.   }
  2201.   font = NULL;
  2202.  
  2203.   while (font == NULL && ele != NULL) {
  2204.     /* printf("base: %ld, ele->dpi: %ld, dpi: %ld, hc: %ld\n", base, ele->dpi, dpi, hconvresolution); */
  2205.     /* stimmt die Base-Dpi? */
  2206.     if ((base && ele->hdpi == hconvresolution && ele->vdpi == vconvresolution) ||
  2207.         (!base && ele->hdpi == dpi && ele->vdpi == compute_vert(dpi))) {
  2208.       font = define_test_pk_font(ele->path, fntname, dpi, dpi5,
  2209.                 ele->format_str, fnt_root);
  2210.       if (font != NULL) {
  2211.         font->common->where_is_font = WHERE_PKDIR;
  2212.       }
  2213.     }
  2214.     ele = ele->next_ele;
  2215.   }
  2216.   return (font);
  2217. }
  2218.  
  2219. /*
  2220.  ************************************************************************
  2221.  *    test a pk-file and define the font if the pk-file exists    *
  2222.  ************************************************************************
  2223.  */
  2224.  
  2225. static struct Font *define_test_pk_font(path, fntname, dpi, dpi5, format_str, fnt_root)
  2226.   char *path;
  2227.   char *fntname;
  2228.   long dpi, dpi5;
  2229.   char *format_str;
  2230.   struct FontMan *fnt_root;
  2231. {
  2232.   char whole_name[PATH_SIZE+FONT_NAME_SIZE];
  2233.   char pkname[PK_NAME_SIZE];
  2234.   struct Font     *font;
  2235.   long size;            /* size in bytes of pk-file */
  2236.   BPTR lck;
  2237.  
  2238.   if (format_str == NULL) Fatal(20, MSG_INTERNAL_ERROR_FMT_STR);
  2239.  
  2240.   my_sprintf(pkname, PK_NAME_SIZE, format_str, fntname, dpi, dpi5);
  2241.  
  2242.   strcpy(whole_name,path);
  2243.   mk_correct_path(whole_name);
  2244.   strcat(whole_name,pkname);
  2245.  
  2246.   lck = Lock(whole_name, ACCESS_READ);    /* read access ? */
  2247.   if (!lck) return NULL;
  2248.   
  2249.   UnLock(lck); 
  2250.   lck = NULL;
  2251.  
  2252.  
  2253.   /* font is found, now define the font-structure */
  2254.   size = test_pk_file(whole_name);
  2255.   if (size == 0L)
  2256.     return (struct Font *)NULL;
  2257.  
  2258.  
  2259.   font = make_new_fontdesc(fntname, fnt_root);
  2260.  
  2261.   font->fnt_number            = -1L;
  2262.   font->common->fnt_status    = FNT_FOUND;
  2263.   font->common->where_is_font = WHERE_PK;
  2264.   font->common->where_in_lib  = 0L;
  2265.   font->common->fnt_length    = size;
  2266.   font->common->resolution    = dpi;
  2267.   font->common->resolution5   = dpi5;
  2268.   font->orig_dpi          = dpi;
  2269.  
  2270.   font->common->location.pk_directory = 
  2271.     (struct PK_Dir *)xmalloc((size_t)sizeof(struct PK_Dir));
  2272.   strcpy(font->common->location.pk_directory->path, path);
  2273.   font->common->location.pk_directory->format_str = format_str;
  2274.  
  2275.   return font;
  2276. }
  2277.  
  2278.  
  2279. /*
  2280.  ************************************************************************
  2281.  *    search a font in the list of fontlibraries            *
  2282.  ************************************************************************
  2283.  */
  2284.  
  2285. static struct Font *search_in_defined_libs(fntname, dpi, dpi5, fnt_root)
  2286.   char *fntname;
  2287.   long dpi, dpi5;
  2288.   struct FontMan *fnt_root;
  2289. {
  2290.   int ret;
  2291.   struct LibLst  *liblist;
  2292.   FILE         *file;
  2293.   struct Font     *font;
  2294.   char libname[FLIB_NAME_SIZE];
  2295.   char full_name[PATH_SIZE+FLIB_NAME_SIZE];
  2296.   int version;
  2297.  
  2298.   /**** search in the list of predefined libs ****/
  2299.  
  2300.   for(liblist = fnt_root->flib_list; liblist != NULL;
  2301.                     liblist = liblist->next_lib) {
  2302.     if (liblist->flib.resolution == dpi) {
  2303.       /* here is already a lib defined */
  2304.       if (liblist->flib.lib_status == LIB_PATH_DEFINED) {
  2305.         /* open the lib and read the directory */
  2306.     my_sprintf(libname, FLIB_NAME_SIZE, liblist->flib.format_str, fntname, dpi, dpi5);
  2307.     strcpy(full_name,liblist->flib.path);
  2308.     mk_correct_path(full_name);
  2309.     strcat(full_name,libname);
  2310.         file = open_flib(full_name, B_OPEN_READ, &version, (short)0);
  2311.         liblist->flib.directory.version = version;
  2312.         if (file != NULL) {
  2313.           /* here is really a flib */
  2314.           ret = read_dir(file,&(liblist->flib.directory));
  2315.           if (ret) {        /* all ok */
  2316.             fnt_root->files_left--;
  2317.             liblist->flib.lib_status = LIB_OPEND;
  2318.             liblist->flib.file_ptr   = file;
  2319.             setup_lru_flib(fnt_root->flib_list,&(liblist->flib));
  2320.           }
  2321.           else {        /* corrupted file ? */
  2322.             fclose(file);
  2323.             liblist->flib.lib_status = LIB_NOT_EXISTS;
  2324.           }
  2325.         }
  2326.         else {            /* can't open the file */
  2327.           liblist->flib.lib_status = LIB_NOT_EXISTS;
  2328.         }
  2329.       }
  2330.       if (liblist->flib.lib_status == LIB_OPEND || 
  2331.         liblist->flib.lib_status == LIB_READ_CLOSED) {
  2332.         /* the directoy of the lib is already in the ram */
  2333.         font = find_font_in_flib(fntname, dpi, dpi5, &(liblist->flib), fnt_root);
  2334.         if (font != NULL)
  2335.       return font;        /* ======>>>>> found it */
  2336.       }
  2337.     }
  2338.   }
  2339.  
  2340.   return (struct Font *)NULL;
  2341. }
  2342.  
  2343. /*
  2344.  ************************************************************************
  2345.  *    search in this places, where no lib is found            *
  2346.  ************************************************************************
  2347.  */
  2348.  
  2349. static struct Font *search_in_rest_pathes(fntname, dpi, dpi5, fnt_root)
  2350.   char *fntname;
  2351.   long dpi, dpi5;
  2352.   struct FontMan *fnt_root;
  2353. {
  2354.   int ret;
  2355.   char *path, libname[FLIB_NAME_SIZE];
  2356.   char full_name[PATH_SIZE+FLIB_NAME_SIZE];
  2357.   struct LibLst  *liblist;
  2358.   FILE         *file;
  2359.   struct Font     *font;
  2360.   struct SeaEle     *ele;
  2361.   int version;
  2362.  
  2363.   /**** font not in a predefined lib => search in the rest of the pathes ****/
  2364.  
  2365.   my_sprintf(libname, FLIB_NAME_SIZE, fnt_root->flib_fmt, fntname, dpi, dpi5);
  2366.   ele = fnt_root->s_list_flib.first_ele;
  2367.  
  2368.   while (ele != NULL) {
  2369.     path = ele->path;
  2370.     ele = ele->next_ele;
  2371.  
  2372.     /* is this flib (whith this path) already defined?? */
  2373.     for (liblist = fnt_root->flib_list;
  2374.      liblist != NULL && (liblist->flib.resolution != dpi ||
  2375.         (stricmp(liblist->flib.path,path) != 0));
  2376.      liblist = liblist->next_lib);
  2377.  
  2378.     if (liblist == NULL) {        /* no, nix defined */
  2379.       /* this path is a new path */
  2380.       liblist = (struct LibLst *)xmalloc((size_t)sizeof(struct LibLst));
  2381.       strcpy(full_name,path);
  2382.       mk_correct_path(full_name);
  2383.       strcat(full_name,libname);
  2384.       file = open_flib(full_name, B_OPEN_READ, &version, (short)0);
  2385.       liblist->flib.directory.version = version;
  2386.  
  2387.       /* and now, sort the flib into the flib-list */
  2388.       liblist->next_lib = fnt_root->flib_list;
  2389.       fnt_root->flib_list = liblist;
  2390.  
  2391.       liblist->flib.resolution  = dpi;
  2392.       liblist->flib.lru_count   = 0;
  2393.       liblist->flib.format_str  = fnt_root->flib_fmt;
  2394.       strcpy(liblist->flib.path, path);
  2395.  
  2396.       if (file != NULL) {
  2397.         /* here is really a flib */
  2398.         ret = read_dir(file,&(liblist->flib.directory));
  2399.         if (ret) {
  2400.           /* define a new fontlibrary */
  2401.           fnt_root->files_left--;
  2402.           liblist->flib.file_ptr    = file;
  2403.           liblist->flib.lib_status  = LIB_OPEND;
  2404.           setup_lru_flib(fnt_root->flib_list,&(liblist->flib));
  2405.  
  2406.           font = find_font_in_flib(fntname, dpi, dpi5, &(liblist->flib), fnt_root);
  2407.           if (font != NULL)
  2408.         return font;
  2409.         }
  2410.         else {
  2411.           fclose(file);
  2412.           liblist->flib.file_ptr    = NULL;
  2413.           liblist->flib.lib_status  = LIB_NOT_EXISTS;
  2414.         }
  2415.       }
  2416.       else {    /* can't open flib */
  2417.         liblist->flib.file_ptr    = NULL;
  2418.         liblist->flib.lib_status  = LIB_NOT_EXISTS;
  2419.       }
  2420.     }
  2421.   }
  2422.  
  2423.   return (struct Font *)NULL;
  2424. }
  2425.  
  2426.  
  2427. /*
  2428.  ************************************************************************
  2429.  *    search-define a font in a fontlibrary                *
  2430.  ************************************************************************
  2431.  */
  2432.  
  2433. static struct Font *find_font_in_flib(fntname, dpi, dpi5, flib, fnt_root)
  2434.   char *fntname;
  2435.   long dpi, dpi5;
  2436.   struct Fnt_Lib *flib;
  2437.   struct FontMan *fnt_root;
  2438. {
  2439.   /* this function search in a flib a font and if it is found, the font    */
  2440.   /* would be defined and in the font-list inserted.            */
  2441.  
  2442.   char name[FONT_NAME_SIZE];
  2443.   struct dirlist *dirlist;
  2444.   struct Font     *font;
  2445.  
  2446.   my_sprintf(name, FONT_NAME_SIZE, fnt_root->flib_fnt_fmt, fntname, dpi, dpi5);
  2447.  
  2448.   dirlist = findmod(&(flib->directory),name);
  2449.  
  2450.   if (dirlist == NULL)
  2451.     return (struct Font *)NULL;
  2452.  
  2453.   /* font found, now define the font-structure */
  2454.  
  2455.   font = make_new_fontdesc(fntname, fnt_root);
  2456.  
  2457.   font->fnt_number                   = -1L;
  2458.   font->common->fnt_status           = FNT_FOUND;
  2459.   font->common->where_is_font        = WHERE_LIB;
  2460.   font->common->where_in_lib         = dirlist->dirent.where;
  2461.   font->common->fnt_length           = dirlist->dirent.size;
  2462.   font->common->resolution           = dpi;
  2463.   font->common->resolution5          = dpi5;
  2464.   font->orig_dpi             = dpi;
  2465.   font->common->location.fnt_library = flib;
  2466.  
  2467.   return (font);
  2468. }
  2469.  
  2470.  
  2471. /*
  2472.  * writes font definitions into log (!) file    (by AbortRun if Stats)
  2473.  */
  2474. void write_font_def_file(void)
  2475. {
  2476.  struct LibLst      *llist;
  2477.  struct FontLst     *flist;
  2478.  struct SeaEle        *ele;
  2479.  struct SeaEleDpi    *dele;
  2480.  long            i, j;
  2481.  char            *last_format;
  2482.  
  2483.  if (FontRoot != NULL)
  2484.   {
  2485.    j=0L;
  2486.    for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font) {
  2487.      for (i=0; i<NPXLCHARS; i++) {
  2488.        if (flist->font.common->ch[i].unpacked != NULL) {
  2489.      j++;
  2490.        }
  2491.      }
  2492.    }
  2493.  
  2494.    LoggingStr("");
  2495.    Logging(MSG_BYTES_USED_FOR_CHARS,FontRoot->unpacked_mem,j);
  2496.  
  2497.    LoggingStr("");
  2498.    Logging(MSG_SEARCHPATH_LIB_ENTRIES_NR,FontRoot->s_list_flib.number);
  2499.    strcpy(m_string,"\t");
  2500.    for (ele = FontRoot->s_list_flib.first_ele; ele != NULL; ele = ele->next_ele) {
  2501.      strcat(m_string,ele->path);
  2502.      if (ele->next_ele != NULL) {
  2503.        strcat(m_string,", ");
  2504.      }
  2505.    }
  2506.    LoggingStr(m_string);
  2507.  
  2508.    LoggingStr("");
  2509.    Logging(MSG_SEARCHPATH_PK_ENTRIES_NR,FontRoot->s_list_pkdirs.number);
  2510.    strcpy(m_string,"\t");
  2511.    for (ele = FontRoot->s_list_pkdirs.first_ele; ele != NULL; ele = ele->next_ele) {
  2512.      strcat(m_string,ele->path);
  2513.      if (ele->next_ele != NULL) {
  2514.        strcat(m_string,", ");
  2515.      }
  2516.    }
  2517.    LoggingStr(m_string);
  2518.  
  2519.  
  2520.  
  2521.    last_format = FontRoot->flib_fmt;
  2522.  
  2523.    LoggingStr("");
  2524.    LoggingStr("");
  2525.    Logging(MSG_LOG_FONTDEF_START);
  2526.    for (llist=FontRoot->flib_list; llist != NULL; llist = llist->next_lib)
  2527.     {
  2528.      if (stricmp(llist->flib.format_str, last_format) != 0) {
  2529.        last_format = llist->flib.format_str;
  2530.        LoggingStr("flib_str\t%s", last_format);
  2531.      }
  2532.      switch (llist->flib.lib_status)
  2533.       {
  2534.        case LIB_READ_CLOSED:
  2535.        case LIB_OPEND:
  2536.         Logging(MSG_LOG_FONTDEF_LIB_FOUND,
  2537.             llist->flib.resolution,
  2538.             llist->flib.path);
  2539.         break;
  2540.        case LIB_PATH_DEFINED:
  2541.         Logging(MSG_LOG_FONTDEF_LIB_DEF,
  2542.             llist->flib.resolution,
  2543.             llist->flib.path);
  2544.         break;
  2545.        case LIB_NOT_EXISTS:
  2546.         Logging(MSG_LOG_FONTDEF_LIB_NOT_FOUND,
  2547.             llist->flib.resolution,
  2548.             llist->flib.path);
  2549.         break;
  2550.        default:
  2551.         break;
  2552.       }
  2553.     }
  2554.    if (stricmp(FontRoot->flib_fmt, last_format) != 0) {
  2555.      LoggingStr("flib_str\t%s", FontRoot->flib_fmt);
  2556.    }
  2557.  
  2558.    for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font) {
  2559.      flist->font.common->copied = (char)FALSE;
  2560.    }
  2561.  
  2562.  
  2563.    last_format = FontRoot->pk_fmt;
  2564.  
  2565.    for (flist=FontRoot->font_list; flist != NULL; flist = flist->next_font)
  2566.     {
  2567.      if (flist->font.common->copied == (char)FALSE)
  2568.       {
  2569.        flist->font.common->copied = (char)TRUE;
  2570.        if (flist->font.common->where_is_font != WHERE_LIB)
  2571.         {
  2572.          if (flist->font.common->location.pk_directory != NULL)
  2573.           {
  2574.            if (stricmp(flist->font.common->location.pk_directory->format_str,
  2575.             last_format) != 0) {
  2576.              last_format = flist->font.common->location.pk_directory->format_str;
  2577.              LoggingStr("pk_str\t\t%s", last_format);
  2578.            }
  2579.           }
  2580.          switch (flist->font.common->fnt_status)
  2581.           {
  2582.            case FNT_FOUND:
  2583.            case FNT_LOADED:
  2584.            case FNT_OLD_LOADED:
  2585.              Logging(MSG_LOG_FONTDEF_PK_FOUND,
  2586.                      flist->font.common->fnt_group->fnt_name,
  2587.                      flist->font.common->resolution,
  2588.                      flist->font.common->location.pk_directory->path);
  2589.              break;
  2590.            case FNT_PATH_DEFINED:
  2591.              Logging(MSG_LOG_FONTDEF_PK_PREDEF,
  2592.                      flist->font.common->fnt_group->fnt_name,
  2593.                      flist->font.common->resolution,
  2594.                      flist->font.common->location.pk_directory->path);
  2595.              break;
  2596.            case FNT_NOT_EXISTS:
  2597.             {
  2598.              struct PK_Dir *dir;
  2599.              
  2600.              dir = flist->font.common->location.pk_directory;
  2601.              if (dir != NULL)
  2602.               {
  2603.                Logging(MSG_LOG_FONTDEF_PK_PREDEF_NOT_FOUND,
  2604.                      flist->font.common->fnt_group->fnt_name,
  2605.                      flist->font.common->resolution,
  2606.                      flist->font.common->location.pk_directory->path);
  2607.               }
  2608.              break;
  2609.             }
  2610.            default:
  2611.              break;
  2612.           }
  2613.         }
  2614.       }
  2615.     }
  2616.    for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font)
  2617.     {
  2618.      flist->font.common->copied = (char)FALSE;
  2619.     }
  2620.    if (stricmp(FontRoot->pk_fmt, last_format) != 0) {
  2621.      LoggingStr("pk_str\t\t%s", FontRoot->pk_fmt);
  2622.    }
  2623.  
  2624.  
  2625.    /**** logge die base-pk-directories zu einer bestimmten Grundaufloesung***/
  2626.  
  2627.    last_format = FontRoot->basepkdir_fmt;
  2628.  
  2629.    if (FontRoot->s_list_base_pkdpi.number > 0) {
  2630.      LoggingStr("");
  2631.      Logging(MSG_LOG_FONTDEF_NR_BASE_PK_DIRS_PREDEF, FontRoot->s_list_base_pkdpi.number);
  2632.      for (dele = FontRoot->s_list_base_pkdpi.first_ele; dele != NULL; dele = dele->next_ele) {
  2633.        if (stricmp(dele->format_str, last_format) != 0) {
  2634.          last_format = dele->format_str;
  2635.          LoggingStr("basepkdir_str\t%s", last_format);
  2636.        }
  2637.        LoggingStr("basepkdir\t%ld\t%ld\t%s", dele->hdpi, dele->vdpi, dele->path);
  2638.      }
  2639.      /** das wird hier nicht benoetigt, da ja keine Eintraege dynamisch hinzukommen!
  2640.      if (stricmp(FontRoot->basepkdir_fmt, last_format) != 0) {
  2641.        LoggingStr("basepkdir_str\t%s", FontRoot->basepkdir_fmt);
  2642.      }
  2643.      **/
  2644.    }
  2645.  
  2646.  
  2647.    /**** logge die pk-directories zu einer bestimmten Aufloesung***/
  2648.  
  2649.    last_format = FontRoot->pkdir_fmt;
  2650.  
  2651.    if (FontRoot->s_list_pkdpi.number > 0) {
  2652.      LoggingStr("");
  2653.      Logging(MSG_LOG_FONTDEF_NO_PK_DIRS_PREDEF, FontRoot->s_list_pkdpi.number);
  2654.      for (dele = FontRoot->s_list_pkdpi.first_ele; dele != NULL; dele = dele->next_ele) {
  2655.        if (stricmp(dele->format_str, last_format) != 0) {
  2656.          last_format = dele->format_str;
  2657.          LoggingStr("pkdir_str\t%s", last_format);
  2658.        }
  2659.        LoggingStr("pkdir\t\t%ld\t%ld\t%s", dele->hdpi, dele->vdpi, dele->path);
  2660.      }
  2661.      /** das wird hier nicht benoetigt, da ja keine Eintraege dynamisch hinzukommen!
  2662.      if (stricmp(FontRoot->pkdir_fmt, last_format) != 0) {
  2663.        LoggingStr("pkdir_str\t%s", FontRoot->pkdir_fmt);
  2664.      }
  2665.      **/
  2666.    }
  2667.  
  2668.    Logging(MSG_LOG_FONTDEF_END);
  2669.    LoggingStr("");
  2670.   }
  2671. }
  2672.  
  2673. /*
  2674.  ************************************************************************
  2675.  *    read font definition file                    *
  2676.  ************************************************************************
  2677.  */
  2678. static void read_font_def_file(fnt_root, file_name)
  2679.   struct FontMan *fnt_root;
  2680.   char *file_name;
  2681. {
  2682.   FILE *f;
  2683. #ifndef AMIGA
  2684.   char def_file[PATH_SIZE], *d;
  2685. #endif
  2686.  
  2687. #ifdef AMIGA
  2688.   f = OpenConfigFile(file_name, MODE_READ);
  2689. #else
  2690.   d = getenv(ENV_DEFAULT_PATH);
  2691.   if (d == NULL) {        /** no environment var defined **/
  2692.     strcpy(def_file,DEFAULT_PATH);
  2693.   }
  2694.   else {            /** take the defined path **/
  2695.     strcpy(def_file,d);
  2696.   }
  2697.   mk_correct_path(def_file);
  2698.   strcat(def_file,file_name);
  2699.   f = fopen(def_file,"r");
  2700. #endif
  2701.  
  2702.   if (f == NULL)
  2703.    {
  2704. #ifdef ATARI
  2705.     strcpy(def_file, file_name);
  2706.     if (shel_find(def_file)==0)
  2707.      {
  2708.       char *shenv;
  2709.  
  2710.       Logging("*** Can't open font/flib configuration file \"%s\"!",file_name);
  2711.       Logging("    Font/flib configuration file has been searched in following pathes:");
  2712.       if (d != NULL)
  2713.        {
  2714.         Logging("     - via environment variable \"%s\" ('%s')",
  2715.             ENV_DEFAULT_PATH, d);
  2716.        }
  2717.       else
  2718.        {
  2719.         Logging("     - via default path ('%s')",
  2720.             DEFAULT_PATH);
  2721.        }
  2722.       shel_envrn(&shenv,"PATH=");
  2723.       strcpy(def_file, (shenv==NULL) ? "" : shenv);
  2724.       Logging("     - via system environment variable \"PATH=\" ('%s')", def_file);
  2725.       return;
  2726.      }
  2727.     f = fopen(def_file,"r");
  2728.     if (f == NULL)
  2729.      {
  2730.       Logging("*** Can't open font/flib configuration file \"%s\"!",def_file);
  2731.       return;
  2732.      }
  2733. #else
  2734.     Logging(MSG_CANT_OPEN_FONT_CONFIG,file_name);
  2735.     return;
  2736. #endif
  2737.    }
  2738.   Logging(MSG_LOAD_FONT_CONFIG,file_name);
  2739. #ifdef OLDARGS
  2740.   { char line[256], *s;
  2741.    line[255] = '\0';
  2742.    while(fgets(line,255,f) != NULL) {
  2743.     s = strrchr(line,'\n');
  2744.     if (s != NULL) *s = '\0';
  2745.  
  2746.     s = strchr(line,';');
  2747.     if (s != NULL) *s = '\0';        /* skip comment */
  2748.  
  2749.     parse_line(fnt_root,line);
  2750.    }
  2751.   }
  2752. #else
  2753.   globarg_fnt_root = fnt_root;
  2754.   parse_file(font_config,f, 0); /* ignore unknown keywords */
  2755. #endif
  2756.  
  2757.   fclose(f);
  2758. }
  2759.  
  2760.  
  2761. #ifdef OLDARGS
  2762. /*
  2763.  ************************************************************************
  2764.  *    read a line of a font-def-file                    *
  2765.  ************************************************************************
  2766.  */
  2767.  
  2768. static void parse_line(fnt_root,line)
  2769.   struct FontMan *fnt_root;
  2770.   char *line;
  2771. {
  2772.   char key[20], arg1[100], arg2[100], arg3[100];
  2773.   long number_dpi;
  2774.   short mark;
  2775.   
  2776.   for (; (*line == ' ' || *line == '\t') && *line != '\0'; line++);
  2777.   if (*line == '\0') {        /* empty line */
  2778.     return;
  2779.   }
  2780.  
  2781. #ifndef ATARI
  2782.   if (sscanf(line,"%19s %99s %99s %99s",key,arg1,arg2,arg3) < 2) {
  2783.     Warning(MSG_CANT_PARSE_FONT_CONFIG_LINE,line);
  2784.   }
  2785. #else
  2786.   if (sscanf(line,"%20s %100s",key,arg1) < 2) {
  2787.     Warning("Can't parse line \"%s\"!",line);
  2788.   }
  2789. #endif
  2790.  
  2791.  /***      FLIBENV    *******************************************************/
  2792.  if (stricmp("flibenv",key) == 0) {
  2793.    if (*arg1 == '\0') {
  2794.      Warning(MSG_TOO_FEW_ARGS, "flibenv");
  2795.    }
  2796.    else {
  2797.      conc_dirs(line, &(fnt_root->s_list_flib));
  2798.    }
  2799.    return;
  2800.  }
  2801.  
  2802.  /***    PKENV     *******************************************************/
  2803.  if (stricmp("pkenv",key) == 0) {
  2804.    if (*arg1 == '\0') {
  2805.      Warning(MSG_TOO_FEW_ARGS, "pkenv");
  2806.    }
  2807.    else {
  2808.      conc_dirs(line, &(fnt_root->s_list_pkdirs));
  2809.    }
  2810.    return;
  2811.  }
  2812.  
  2813.  /***    FLIB_STR  *******************************************************/
  2814.  if (stricmp("flib_str",key) == 0) {
  2815.         if (*arg1 == '\0') {
  2816.           Warning(MSG_TOO_FEW_ARGS, "flib_str");
  2817.         }
  2818.         else {
  2819.           if ((fnt_root->flib_fmt = strdup(arg1)) == NULL) {
  2820.             Fatal(10, MSG_NO_MEM);
  2821.           }
  2822.         }
  2823.    return;
  2824.   }
  2825.  
  2826.  /***    PK_STR    *******************************************************/
  2827.  if (stricmp("pk_str",key) == 0) {
  2828.           if (*arg1 == '\0') {
  2829.             Warning(MSG_TOO_FEW_ARGS, "pk_str");
  2830.           }
  2831.           else {
  2832.             if ((fnt_root->pk_fmt = strdup(arg1)) == NULL) {
  2833.               Fatal(10, MSG_NO_MEM);
  2834.             }
  2835.           }
  2836.     return;
  2837.   }
  2838.  
  2839.  /*** BASEPKDIR_STR   *******************************************************/
  2840.  if (stricmp("basepkdir_str",key) == 0) {
  2841.           if (*arg1 == '\0') {
  2842.             Warning(MSG_TOO_FEW_ARGS, "basepkdir_str");
  2843.           }
  2844.           else {
  2845.             if ((fnt_root->basepkdir_fmt = strdup(arg1)) == NULL) {
  2846.               Fatal(10, MSG_NO_MEM);
  2847.             }
  2848.           }
  2849.     return;
  2850.   }
  2851.  
  2852.  /***    PKDIR_STR   *******************************************************/
  2853.  if (stricmp("pkdir_str",key) == 0) {
  2854.           if (*arg1 == '\0') {
  2855.             Warning(MSG_TOO_FEW_ARGS, "pkdir_str");
  2856.           }
  2857.           else {
  2858.             if ((fnt_root->pkdir_fmt = strdup(arg1)) == NULL) {
  2859.               Fatal(10, MSG_NO_MEM);
  2860.             }
  2861.           }
  2862.     return;
  2863.   }
  2864.  
  2865.  /***    FLIB_FNT_STR  *******************************************************/
  2866.  if (stricmp("flib_fnt_str",key) == 0) {
  2867.           if (*arg1 == '\0') {
  2868.             Warning(MSG_TOO_FEW_ARGS, "flib_fnt_str");
  2869.           }
  2870.           else {
  2871.             if ((fnt_root->flib_fnt_fmt = strdup(arg1)) == NULL) {
  2872.               Fatal(10, MSG_NO_MEM);
  2873.             }
  2874.           }
  2875.     return;
  2876.   }
  2877.  
  2878. #ifdef ATARI
  2879.   if (sscanf(line,"%20s %100s %100s",key,arg1,arg2) < 3) {
  2880.     Warning("Can't parse line \"%s\"!",line);
  2881.   }
  2882. #endif
  2883.  
  2884.  /***    FLIB    *******************************************************/
  2885.  if (stricmp("flib",key) == 0) {
  2886.     if (*arg2 == '\0' || *arg1 == '\0') {
  2887.         Warning(MSG_TOO_FEW_ARGS, "flib");
  2888.       }
  2889.       else {
  2890.     long dpi;
  2891.     sscanf(arg1,"%ld",&dpi);
  2892.         define_flib(fnt_root,dpi,arg2);
  2893.       }
  2894.     return;
  2895.   }
  2896.  
  2897.  /*** PKDIR -- BASEPKDIR *********************************************/
  2898.   mark = 0;
  2899.   if (stricmp("pkdir",key) == 0) {
  2900.     mark = 1;
  2901.   }
  2902.   if (stricmp("basepkdir",key) == 0) {
  2903.     mark = 2;
  2904.   }
  2905.  
  2906.   if (mark != 0) {
  2907.     struct SeaEleDpi *ele, *new;
  2908.     char *larg;
  2909.  
  2910.     if (*arg2 == '\0' || *arg1 == '\0') {
  2911.       Warning(MSG_TOO_FEW_ARGS, (mark == 1) ? "pkdir" : "basepkdir");
  2912.       return;
  2913.     }
  2914.  
  2915.     /* arg1 == dpi, arg2 == vdpi, arg2/3 (larg) == path */
  2916.     new = xmalloc(sizeof(struct SeaEleDpi));
  2917.     if (sscanf(arg1, "%ld",&(new->hdpi)) != 1) {
  2918.           xfree(new);
  2919.           Warning(MSG_NOT_A_VALID_INT,arg1);
  2920.           return;    /* ** weg ** */
  2921.     }
  2922.     if (isdigit(*arg2)) {
  2923.       if (sscanf(arg2, "%ld",&(new->vdpi)) != 1) {
  2924.             xfree(new);
  2925.             Warning(MSG_NOT_A_VALID_INT,arg1);
  2926.             return;    /* ** weg ** */
  2927.       }
  2928.       larg = &(arg3[0]);
  2929.       if (*larg == '\0') {
  2930.             xfree(new);
  2931.         Warning(MSG_TOO_FEW_ARGS, (mark == 1) ? "pkdir" : "basepkdir");
  2932.         return;    /* ** weg ** */
  2933.       }
  2934.     }
  2935.     else {
  2936.       new->vdpi = new->hdpi;
  2937.       larg = &(arg2[0]);
  2938.     }
  2939.     new->path = strdup(larg);
  2940.     if (new->path == NULL) {
  2941.       xfree(new);
  2942.       return;    /* ** weg ** */
  2943.     }
  2944.     if (mark == 1) {
  2945.         new->format_str = strdup(fnt_root->pkdir_fmt);
  2946.     }
  2947.     else {
  2948.         new->format_str = strdup(fnt_root->basepkdir_fmt);
  2949.     }
  2950.         if (new->format_str == NULL) {
  2951.           xfree(new->path);
  2952.           xfree(new);
  2953.           return;    /* ** weg ** */
  2954.         }
  2955.         new->next_ele = NULL;
  2956.         if (mark == 1) {
  2957.           fnt_root->s_list_pkdpi.number++;
  2958.           ele = fnt_root->s_list_pkdpi.first_ele;
  2959.           if (ele == NULL) {
  2960.             fnt_root->s_list_pkdpi.first_ele = new;
  2961.           }
  2962.           else {
  2963.             for (; ele->next_ele != NULL; ele = ele->next_ele);
  2964.             ele->next_ele = new;
  2965.           }
  2966.         }
  2967.         else {
  2968.           fnt_root->s_list_base_pkdpi.number++;
  2969.           ele = fnt_root->s_list_base_pkdpi.first_ele;
  2970.           if (ele == NULL) {
  2971.             fnt_root->s_list_base_pkdpi.first_ele = new;
  2972.           }
  2973.           else {
  2974.             for (; ele->next_ele != NULL; ele = ele->next_ele);
  2975.             ele->next_ele = new;
  2976.           }
  2977.         }
  2978.     return;
  2979.   }
  2980.  
  2981. #ifdef ATARI
  2982.   if (sscanf(line,"%20s %100s %100s %100s",key,arg1,arg2,arg3) < 4) {
  2983.     Warning("Can't parse line \"%s\"!",line);
  2984.   }
  2985. #endif
  2986.  
  2987.   /***    FONT   *******************************************************/
  2988.   if (stricmp("font",key) == 0) {
  2989.     if (*arg3 == '\0' || *arg2 == '\0' || *arg1 == '\0') {
  2990.       Warning(MSG_TOO_FEW_ARGS, "font");
  2991.     }
  2992.     else {
  2993.       if (sscanf(arg2,"%ld",&number_dpi) == 1) {
  2994.         define_font(fnt_root,number_dpi,arg3,arg1);
  2995.       }
  2996.       else {
  2997.         Warning(MSG_CANT_READ_DPI_FONT_COMM);
  2998.       }
  2999.     }
  3000.     return;
  3001.   }
  3002.  Warning(MSG_UNKNOWN_KEYWORD_IN_CONFIG,key);
  3003. }
  3004.  
  3005. #else /* OLDARGS */
  3006.  
  3007. /*    fkw_conc_dirs
  3008.  *
  3009.  * Called when a list of directories needs to be parsed.
  3010.  */
  3011. static void __stdargs fkw_conc_dirs
  3012.     (struct string_parse *p, char *line)
  3013. {
  3014.   struct SeaLst *sl;
  3015.   switch (p->paf_userdata) {
  3016.     case ARG_CONC_FLIB:
  3017.       sl = &globarg_fnt_root->s_list_flib;
  3018.       break;
  3019.     case ARG_CONC_PK:
  3020.       sl = &globarg_fnt_root->s_list_pkdirs;
  3021.       break;
  3022. #if defined(HARDDEB)
  3023.     default: Fatal(20,"fkw_conc_dirs() : illegal switch!");
  3024. #endif
  3025.   }
  3026.   conc_dirs(line, sl);
  3027. }
  3028.  
  3029. /*    fkw_parse_string
  3030.  *
  3031.  * Called when a full string needs to be parsed.
  3032.  */
  3033. static void __stdargs fkw_parse_string
  3034.     (struct string_parse *p, char *line, char *string)
  3035. {
  3036.   char **s;
  3037.   switch(p->paf_userdata) {
  3038.     case ARG_STR_FLIB:
  3039.       s=&globarg_fnt_root->flib_fmt;
  3040.       break;
  3041.     case ARG_STR_PK:
  3042.       s=&globarg_fnt_root->pk_fmt;
  3043.       break;
  3044.     case ARG_STR_BASEPKD:
  3045.       s=&globarg_fnt_root->basepkdir_fmt;
  3046.       break;
  3047.     case ARG_STR_PKDIR:
  3048.       s=&globarg_fnt_root->pkdir_fmt;
  3049.       break;
  3050.     case ARG_STR_FLIBFNT:
  3051.       s=&globarg_fnt_root->flib_fnt_fmt;
  3052.       break;
  3053. #if defined(HARDDEB)
  3054.     default: Fatal(20,"fkw_parse_string(): Illegal switch!");
  3055. #endif
  3056.   }
  3057.   if (NULL == (*s = strdup(string)))
  3058.     Fatal(10,"Not enough memory!");
  3059. }
  3060.  
  3061. /*    fkw_dir
  3062.  *
  3063.  * Called through 'pkdir'and 'basepkdir' keywords
  3064.  */
  3065. static void __stdargs fkw_dir
  3066.     (struct string_parse *p, char *line, long *dpi, char *path)
  3067. {
  3068.   int mark = p->paf_userdata;
  3069.     struct SeaEleDpi *ele, *new;
  3070.  
  3071.     new = xmalloc(sizeof(struct SeaEleDpi));
  3072.     new->dpi = *dpi;
  3073.  
  3074.         new->path = xmalloc(strlen(path)+1);
  3075.         if (mark == 1) {    /*    pkdir        */
  3076.             new->format_str = strdup(globarg_fnt_root->pkdir_fmt);
  3077.         }
  3078.         else {        /*    basepkdir    */
  3079.             new->format_str = strdup(globarg_fnt_root->basepkdir_fmt);
  3080.         }
  3081.             if (new->format_str == NULL) {
  3082.               xfree(new);
  3083.             }
  3084.             else {
  3085.               strcpy(new->path, path);
  3086.               new->next_ele = NULL;
  3087.               if (mark == 1) {
  3088.                   globarg_fnt_root->s_list_pkdpi.number++;
  3089.                   ele = globarg_fnt_root->s_list_pkdpi.first_ele;
  3090.                   if (ele == NULL) {
  3091.                     globarg_fnt_root->s_list_pkdpi.first_ele = new;
  3092.                   }
  3093.                   else {
  3094.                     for (; ele->next_ele != NULL; ele = ele->next_ele);
  3095.                     ele->next_ele = new;
  3096.                   }
  3097.               }
  3098.               else {
  3099.                   globarg_fnt_root->s_list_base_pkdpi.number++;
  3100.                   ele = globarg_fnt_root->s_list_base_pkdpi.first_ele;
  3101.                   if (ele == NULL) {
  3102.                     globarg_fnt_root->s_list_base_pkdpi.first_ele = new;
  3103.                   }
  3104.                   else {
  3105.                     for (; ele->next_ele != NULL; ele = ele->next_ele);
  3106.                     ele->next_ele = new;
  3107.                   }
  3108.               }
  3109.             }
  3110. }
  3111.  
  3112. static void __stdargs fkw_define_flib
  3113.     (struct string_parse *p, char *line, long *dpi, char *path)
  3114. {
  3115.   define_flib(globarg_fnt_root, *dpi, path);
  3116. }
  3117.  
  3118. static void __stdargs fkw_define_font
  3119.     (struct string_parse *p, char *line, char *name, long *dpi, char *where)
  3120. {
  3121.   define_font(globarg_fnt_root, *dpi, where, name);
  3122. }
  3123.  
  3124. #endif /* OLDARGS */
  3125.  
  3126.  
  3127. /*
  3128.  ************************************************************************
  3129.  *    parse string and append the entries to the search list        *
  3130.  ************************************************************************
  3131.  */
  3132.  
  3133. static void conc_dirs(char *str, struct SeaLst *sl)
  3134. {
  3135.   short nr = 0;
  3136.   char *token;
  3137.   struct SeaEle *se, *nse, *lse;
  3138.  
  3139.   for (se = sl->first_ele;
  3140.     se != NULL && se->next_ele != NULL && se->next_ele->next_ele != NULL;
  3141.     se = se->next_ele);
  3142.   /* last ele should be last ele */
  3143.   if (se != NULL) {            /* no ele ? */
  3144.     if (se->next_ele == NULL) {        /* only one ele ? */
  3145.      lse = se;
  3146.      se = NULL;
  3147.     }
  3148.     else {
  3149.       lse = se->next_ele;
  3150.     }
  3151.   }
  3152.  
  3153.   (void) strtok(str, " ,\t");    /* skip key word */
  3154.   do {
  3155.     token = strtok(NULL, " ,\t");
  3156.     if (token != NULL) {
  3157.       if ((nse = xmalloc(sizeof(struct SeaEle))) == NULL) {
  3158.         sl->number += nr;
  3159.         return;
  3160.       }
  3161.       if ((nse->path = strdup(token)) == NULL) {
  3162.         xfree(nse);
  3163.         sl->number += nr;
  3164.         return;
  3165.       }
  3166.       nse->next_ele = lse;    /* next ele is every time the last ele */
  3167.       if (se == NULL) {
  3168.        sl->first_ele = nse;
  3169.       }
  3170.       else {
  3171.         se->next_ele = nse;
  3172.       }
  3173.       nr++;
  3174.       se = nse;
  3175.     }
  3176.   } while (token != NULL);
  3177.   sl->number += nr;
  3178. }
  3179.  
  3180.  
  3181. /*
  3182.  ************************************************************************
  3183.  *    define a flib                            *
  3184.  ************************************************************************
  3185.  */
  3186.  
  3187. static void define_flib (fnt_root, dpi, path)
  3188.   struct FontMan *fnt_root;
  3189.   long dpi;
  3190.   char *path;
  3191. {
  3192.   struct LibLst *entry;
  3193.  
  3194.   entry = (struct LibLst *)xmalloc((size_t)sizeof(struct LibLst));
  3195.  
  3196.   entry->flib.lib_status = LIB_PATH_DEFINED;
  3197.   strcpy(entry->flib.path,path);
  3198.   entry->flib.resolution = dpi;
  3199.   entry->flib.format_str = fnt_root->flib_fmt;
  3200.   entry->flib.lru_count = 0;
  3201.  
  3202.   entry->next_lib = fnt_root->flib_list;
  3203.   fnt_root->flib_list = entry;
  3204. }
  3205.  
  3206.  
  3207. /*
  3208.  ************************************************************************
  3209.  *    define a pk-font                        *
  3210.  ************************************************************************
  3211.  */
  3212.  
  3213. static void define_font (fnt_root, dpi, path, name)
  3214.   struct FontMan *fnt_root;
  3215.   long dpi;
  3216.   char *path;
  3217.   char *name;
  3218. {
  3219.   struct Font *entry;
  3220.   struct PK_Dir *p;
  3221.  
  3222.   /* Huch.... warum wird hier eigentlich auf jeden Fall ein neues font-common angelegt ??? */
  3223.   /* (br) soll es oder soll es nicht ??? */
  3224.   /* (hes) wuesste nicht warum ? */
  3225.  
  3226.   entry = make_new_fontdesc(name, fnt_root);
  3227.  
  3228.   p = (struct PK_Dir *)xmalloc(sizeof(struct PK_Dir));
  3229.  
  3230.   strcpy(p->path, path);
  3231.   p->format_str = fnt_root->pk_fmt;
  3232.  
  3233.   entry->fnt_number                    = -1L;
  3234.   entry->common->fnt_status            = FNT_PATH_DEFINED;
  3235.   entry->common->location.pk_directory = p;
  3236.   entry->common->resolution            = dpi;
  3237.   entry->common->resolution5           = dpi * 5;    /* not exactely */
  3238.   entry->common->where_is_font         = WHERE_PK;
  3239.   entry->orig_dpi               = dpi;
  3240. }
  3241.  
  3242.  
  3243. /*---------------------------------------------*/
  3244.  
  3245. /*
  3246.  ************************************************************************
  3247.  *    initialize the memory-pool for the fonts            *
  3248.  ************************************************************************
  3249.  */
  3250.  
  3251. static void init_mem (ulong size)
  3252. {
  3253.   if (size % 2) size++;        /* byte alignment */
  3254.  
  3255.   lowmem = xmalloc((unsigned)size);
  3256.  
  3257.   start_mem = lowmem;
  3258. #if 0
  3259.   /* wrong !! compiler/machine-dependent   (unsigned long) != (char *) */
  3260.   end_mem = (char *)((unsigned long)lowmem + (unsigned long)size);
  3261. #else
  3262.   end_mem = lowmem + size;
  3263. #endif
  3264.  
  3265. }
  3266.  
  3267.  
  3268. static long *open_charmap (void)
  3269. {
  3270.   charmap = lowmem;
  3271.   return ((long *)charmap);
  3272. }
  3273.  
  3274. static long close_charmap (void)
  3275. {
  3276. #if 0
  3277.   return (((long)lowmem - (long)charmap) >> 2);    /* length in long's */
  3278. #else
  3279.   return (long)((lowmem - charmap)/sizeof(long));    /* length in long's */
  3280. #endif
  3281. }
  3282.  
  3283.  
  3284. /*  verschiebe Bereich von (start + size*4  ...  lowmem)
  3285.  *                    nach (start  ...  lowmem - size*4)
  3286.  *  d.h. Bereich (start  ...  start + size*4 - 1) wird "geloescht"
  3287.  */
  3288.  
  3289. static void adjust_mem (long *start,long size)
  3290. { 
  3291.   long len;
  3292.   long *copy;
  3293.  
  3294.   copy = start + size;        /* first source-adr */
  3295.   len = (long)((lowmem - (char *)copy) / sizeof(long));    /* len in byte's */
  3296. #if 0
  3297.   lowmem = (char *) ((long *)lowmem - size);
  3298. #else
  3299.   lowmem = lowmem - (size * sizeof(long));
  3300. #endif
  3301.  
  3302.   while (len-- > 0)
  3303.     *start++ = *copy++;
  3304.  
  3305. #ifdef MYDEBUG
  3306.   /* After copying: start == lowmem !! */
  3307.   if( (char *)start != lowmem ) {
  3308.     LoggingStr("ERROR: adjust_mem() start: 0x%x lowmem: 0x%x size: 0x%x",
  3309.     start, lowmem, size);
  3310.   }
  3311. #endif
  3312. }
  3313.  
  3314.  
  3315. static int do_garcol(void)
  3316. { 
  3317.   struct Font *rmFont;
  3318.   struct FontLst *flist;
  3319.   long size;            /* size of deleted font in long's */
  3320.  
  3321.   /* find font to remove */
  3322.   rmFont = what_lru_font(FontRoot->font_list);
  3323.  
  3324.   if (rmFont == NULL) return (TRUE);
  3325.  
  3326.   /* remove font `rmFont' */
  3327.   size = rmFont->common->ch_len;        /* len in long's */
  3328.   adjust_mem(rmFont->common->ch_start_bm, size);
  3329.  
  3330.   /* don't forget to change bm_pointer of fonts in moved area */
  3331.   for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font) {
  3332.     flist->font.common->copied = (char)FALSE;
  3333.   }
  3334.   for (flist = FontRoot->font_list; flist != NULL; flist = flist->next_font) {
  3335.     if (flist->font.common->ch_start_bm != NULL
  3336.     && flist->font.common->ch_start_bm > rmFont->common->ch_start_bm
  3337.     && flist->font.common->copied == (char)FALSE) {
  3338.       flist->font.common->ch_start_bm -= size;
  3339.       flist->font.common->copied       = (char)TRUE;
  3340.     }
  3341.   }
  3342.  
  3343.   charmap = charmap - size * sizeof(long);
  3344.  
  3345.   rmFont->common->ch_start_bm = NULL;
  3346.   rmFont->common->ch_len      = 0;
  3347.  
  3348.   if (rmFont->common->fnt_status == FNT_LOADED ||
  3349.       rmFont->common->fnt_status == FNT_DEFINED_OLOADED) {
  3350.     rmFont->common->fnt_status = FNT_DEFINED;
  3351.   }
  3352.   else {
  3353.     rmFont->common->fnt_status = FNT_FOUND;
  3354.   }
  3355.  
  3356.   Message(MSG_FONT_REMOVED,
  3357.     rmFont->common->fnt_group->fnt_name, rmFont->common->resolution);
  3358.   Logging(MSG_FONT_REMOVED_USED,
  3359.     rmFont->common->fnt_group->fnt_name, rmFont->common->resolution,
  3360.     100L-(end_mem-lowmem)*100L/fontmemsize);
  3361.  
  3362.   return (FALSE);
  3363. }
  3364.  
  3365.  
  3366. #ifdef AMIGA
  3367. /*
  3368.  ************************************************************************
  3369.  *    read the AmigaTeX "fontvols" file and search a pk-font        *
  3370.  ************************************************************************
  3371.  */
  3372.  
  3373. static struct Font *read_atex_file(char *fntname,
  3374.                    long dpi, long dpi5,
  3375.                    struct FontMan *fnt_root)
  3376. {
  3377.   FILE *fontvols;
  3378.   struct Font *fnt = NULL;
  3379.   char *s, *t, *ptr, c;
  3380.   long d_entry, d_v_entry, read_dpi, read_v_dpi;
  3381.   int end, linenr;
  3382.   char *memory, *line, *path, *pkname, *source_name, *dest_name;
  3383.  
  3384.   /**  
  3385.   Allociere die Arrays per malloc, damit 4kB Stack ausreichen!!
  3386.   char line[256], path[PATH_SIZE], pkname[PK_NAME_SIZE];
  3387.   char source_name[PATH_SIZE+FONT_NAME_SIZE], dest_name[PATH_SIZE+FONT_NAME_SIZE],
  3388.   **/
  3389.   memory = xmalloc(256+PATH_SIZE+PK_NAME_SIZE+2*(PATH_SIZE+FONT_NAME_SIZE));
  3390.   line = memory;
  3391.   path = line+256;
  3392.   pkname = path+PATH_SIZE;
  3393.   source_name = pkname+PK_NAME_SIZE;
  3394.   dest_name = source_name+PATH_SIZE+FONT_NAME_SIZE;
  3395.  
  3396.   /* suche erst im TEXCONFIG Pfad */
  3397.   fontvols = OpenConfigFile("fontvols", MODE_READ);
  3398.   if (fontvols == NULL) {
  3399.     fontvols = fopen("TeX:pk/fontvols", "r");
  3400.   }
  3401.  
  3402.   if (fontvols != NULL) {
  3403.     line[255] = '\0';
  3404.     linenr = 0;
  3405.     while(fnt == NULL && fgets(line,255,fontvols) != NULL) {
  3406.       d_entry = d_v_entry = 0;
  3407.       linenr++;
  3408.       
  3409.       t = strrchr(&(line[0]), '\n');        /* skip trailing Return */
  3410.       if (t != NULL) *t = '\0';
  3411.       t = strchr(&(line[0]), ';');        /* skip trailing comment */
  3412.       if (t != NULL) *t = '\0';
  3413.  
  3414.       t = &(line[0]);                /* skip leading blanks */
  3415.       while (*t != '\0' && isspace(*t)) t++;
  3416.       
  3417.       if (*t == '\0') continue;            /* skip blank line */
  3418.  
  3419.       s = strchr(line,'=');
  3420.       if (s == NULL) {
  3421.     Warning(MSG_ERROR_IN_FONTVOLS, "`='", linenr);
  3422.       }
  3423.       else {
  3424.         *s++ = '\0';
  3425.         t = strchr(s, 'd');
  3426.         if (t != NULL) {
  3427.           if (sscanf(s, "%ldx%ld", &d_entry, &d_v_entry) != 2) {
  3428.             d_v_entry = d_entry;    /* kein ddxdd entry */
  3429.           }
  3430.           s = t+1;    /* setze s auf eins nach 'd', sollte ein '.' sein */
  3431.         }
  3432.  
  3433.     end = FALSE;
  3434.     if (t == NULL || *s != '.') {
  3435.           Warning(MSG_ERROR_IN_FONTVOLS, 
  3436.         (t == NULL) ? "`d' key" : GetTeXString(MSG_FONTVOLS_FIRST_DOT), linenr);
  3437.       end = TRUE;
  3438.     }
  3439.         /* hier wird noch getestet, ob die Zeile auch zur richtigen Aufloesung gehoert */
  3440.     end = end || (d_entry != 0 && d_entry != hconvresolution && d_v_entry != vconvresolution);
  3441.  
  3442.     /**
  3443.         printf("d: %ld, vd: %ld, hc: %ld, vc: %ld, end: %ld, &t: %x, *s: %c\n", 
  3444.             d_entry, d_v_entry, hconvresolution, vconvresolution, end, t, *s);
  3445.     **/
  3446.  
  3447.     s++;            /* skip point */
  3448.     while (fnt == NULL && !end) {
  3449.       /* now read entry */
  3450.           for (t=s; *t != '\0' && *t != '.' && *t != '\n'; t++);
  3451.           if (*t == '\n' || *t == '\0') { end = TRUE; }
  3452.           *t = c = '\0';
  3453.           if (sscanf(s,"%ld%c", &read_dpi, &c) > 0) {
  3454.             if (c == 'x') {
  3455.               ptr = strchr(s, c);    /* da sollte nun wirklich nie NULL rauskommen */
  3456.               if (ptr == NULL || sscanf(ptr+1, "%ld", &read_v_dpi) != 1) {
  3457.                 read_v_dpi = read_dpi; /* da nehmen wir quadratisch an... */
  3458.               }
  3459.             }
  3460.             else {
  3461.               read_v_dpi = read_dpi;
  3462.             }
  3463.             /* teste auf x und y resolution */
  3464.             if (read_dpi == dpi && read_v_dpi == compute_vert(dpi)) {
  3465.           char *dest_path;
  3466.           struct SeaEleDpi    *ele;
  3467.  
  3468.               strcpy(path,line);
  3469.               strcat(path,":");
  3470.  
  3471.           /* falls basepkdir definiert wird dieses als Ziel verwendet */
  3472.           ele = fnt_root->s_list_base_pkdpi.first_ele;
  3473.           /* suche passendes Dir... */
  3474.           while (ele != NULL && (ele->hdpi != hconvresolution || ele->vdpi != vconvresolution)) {
  3475.             ele = ele->next_ele;
  3476.           }
  3477.           /* wenn ein basepkdir gefunden, nimm den Formatstring davon */
  3478.               fnt = define_test_pk_font(path, fntname, dpi, dpi5,
  3479.             (ele == NULL) ? fnt_root->pk_fmt : ele->format_str, fnt_root);
  3480.  
  3481.               if (fnt != NULL) {
  3482.  
  3483.         my_sprintf(pkname, PK_NAME_SIZE, fnt->common->location.pk_directory->format_str, fntname, dpi, dpi5);
  3484.         strcpy(source_name,path);
  3485.         mk_correct_path(source_name);
  3486.         strcat(source_name,pkname);
  3487.         
  3488.         /* hier wird nun path[] zu dem Zielpfad */
  3489.  
  3490.         if (ele != NULL) {
  3491.           /* BasePKDir gefunden */
  3492.           my_sprintf(pkname, PK_NAME_SIZE, ele->format_str, fntname, dpi, dpi5);
  3493.           strncpy(dest_name, ele->path, PATH_SIZE);
  3494.           strncpy(path, ele->path, PATH_SIZE);
  3495.           mk_correct_path(dest_name);
  3496.           strncat(dest_name, pkname, PATH_SIZE+FONT_NAME_SIZE);
  3497.           dest_path = ele->path;
  3498.         }
  3499.         else {
  3500.           /* ansonsten nimm default 'TeX:pk' */
  3501.           my_sprintf(pkname, PK_NAME_SIZE, fnt_root->pk_fmt, fntname, dpi, dpi5);
  3502.           strcpy(dest_name, PK_AREA);    /* keine Ueberpruefung noetig! */
  3503.           strcpy(path, PK_AREA);
  3504.           mk_correct_path(dest_name);
  3505.           strncat(dest_name, pkname, PATH_SIZE+FONT_NAME_SIZE);
  3506.           dest_path = PK_AREA;
  3507.         }
  3508.  
  3509.  
  3510.         Logging(MSG_COPY_FONT_TO_CACHE,fntname,dpi,dest_path);
  3511.         Message(MSG_COPY_FONT_TO_CACHE,fntname,dpi,dest_path);
  3512.  
  3513.         /** fnt_root->files_left =-2;     CRASH **/
  3514.         /** close_flibs(fnt_root);     CRASH **/
  3515.         if (!copy_file(source_name,dest_name)) {
  3516.           Warning(MSG_CANT_COPY_FONT_TO_CACHE);
  3517.         }
  3518.         else {
  3519.           /* Wenn der Font kopiert...dann setze den Pfad auf die Kopie    */
  3520.           /* damit die Diskette nicht mehr benoetigt wird!        */
  3521.           strncpy(fnt->common->location.pk_directory->path, path, PK_NAME_SIZE);
  3522.         }
  3523.         /** fnt_root->files_left =+2;    CRASH **/
  3524.               }
  3525.             }
  3526.           }
  3527.           s = t+1;
  3528.     }    /* end while */
  3529.       }
  3530.     }
  3531.     fclose(fontvols);
  3532.   }
  3533.  
  3534.   xfree(memory);  
  3535.   return fnt;
  3536. }
  3537.  
  3538.  
  3539. /*
  3540.  ************************************************************************
  3541.  *    copy the file source to the file drain (make directory)        *
  3542.  ************************************************************************
  3543.  */
  3544.  
  3545. static int copy_file(char *source, char *drain)
  3546. {
  3547.   FILE *sf, *df;
  3548.   long len;
  3549.   char *buffer;
  3550.  
  3551.   /* erzeuge alle noetigen Unterdirectories */
  3552.   if (!create_path(drain)) {
  3553.     return FALSE;
  3554.   }
  3555.  
  3556.   /* xmalloc() liefert nie NULL */
  3557.   buffer = xmalloc(CPBUFSIZE*sizeof(char));
  3558.   if ((sf = fopen(source,"r")) == NULL) {
  3559.     xfree(buffer);
  3560.     return FALSE;
  3561.   }
  3562.   if ((df = fopen(drain,"w")) == NULL) {
  3563.     fclose(sf);
  3564.     xfree(buffer);
  3565.     return FALSE;
  3566.   }
  3567.   while ((len = fread(buffer,sizeof(char),CPBUFSIZE,sf)) == CPBUFSIZE) {
  3568.     if (fwrite(buffer,sizeof(char),CPBUFSIZE,df) != CPBUFSIZE) {
  3569.         fclose(sf);
  3570.         fclose(df);
  3571.         xfree(buffer);
  3572.         return FALSE;
  3573.     }
  3574.   }
  3575.   if (len > 0) {
  3576.     if (fwrite(buffer,sizeof(char),len,df) != len) {
  3577.         fclose(sf);
  3578.         fclose(df);
  3579.         xfree(buffer);
  3580.         return FALSE;
  3581.     }
  3582.   }
  3583.   fclose(sf);
  3584.   fclose(df);
  3585.   xfree(buffer);
  3586.   
  3587.   return TRUE;
  3588. }
  3589.  
  3590.  
  3591. static int create_path(char *path)
  3592. {
  3593.   char *dir, *ptr;
  3594.   BPTR lock;
  3595.  
  3596.   ptr = path;
  3597.   while ((dir = strchr(ptr,'/')) != NULL) {
  3598.     *dir = '\0';
  3599.     lock = Lock(path,ACCESS_READ);
  3600.     if (lock == NULL) {
  3601.       lock = CreateDir(path);
  3602.       if (lock == NULL) {
  3603.         return FALSE;
  3604.       }
  3605.     }
  3606.     UnLock((BPTR)lock);
  3607.     *dir = '/';
  3608.     ptr = dir+1;
  3609.   }
  3610.   return TRUE;
  3611. }
  3612.  
  3613. #endif
  3614.