home *** CD-ROM | disk | FTP | other *** search
/ Atari FTP / ATARI_FTP_0693.zip / ATARI_FTP_0693 / Tex / Dvi / shdvi10b.zoo / src / flib.c < prev    next >
C/C++ Source or Header  |  1990-08-23  |  45KB  |  1,727 lines
  1. /*
  2.  *    Fontlibrary program.
  3.  *
  4.  *        used for our TeX-system to save disk space and for
  5.  *        speed up the loading of fonts for "showdvi" and "dviprint".
  6.  *
  7.  *    This program is freely redistributable. You may modify and use this
  8.  *    program to your heart's content, so long as you send modifications
  9.  *    to Georg Hessmann or Robert Stabl. It can be included in any 
  10.  *    distribution, commercial or otherwise, so long as the banner string
  11.  *    defined in the constant HEADER is not modified (except for the version
  12.  *    number and the machine type) and this banner is printed on programs
  13.  *    invocation, or can be printed on programs invocation with the -? option.
  14.  *
  15.  *    For further information read the README file.
  16.  *
  17.  *      31.01.90        (C) Copyright Georg Hessmann.
  18.  *
  19.  *      12.02.90 v1.01    new flib-format, rename command
  20.  *
  21.  *      14.02.90  (rbs) ported to Atari ST
  22.  *
  23.  *      25.04.90  (jrb) fixed up for Atari ST gcc
  24.  *
  25.  *    05.06.90 v1.02    little bug fixes, add flib links (hes/rbs)
  26.  *
  27.  *    10.06.90  (rbs) fixed bug for Turbo_C argv[0]
  28.  *
  29.  *    23.08.90 v1.03    bug fix in adding files to existing lib
  30.  *          (rbs)    (only in version for Turbo C)
  31.  */
  32.  
  33.  
  34. /* Is the compiler a ANSI-C compiler */
  35. #ifdef AMIGA
  36. #  ifdef LATTICE
  37. #    define ANSI
  38. #  endif
  39. #  ifdef AZTEC_C
  40. #    undef ANSI
  41. #  endif /* AZTEC_C */
  42. #  ifdef _DCC
  43. #    define ANSI
  44. #  endif /* _DCC */
  45. #else
  46. #  ifdef ATARI
  47. #    ifdef __GNUC__
  48. #      define ANSI
  49. #    endif /* __GNUC__ */
  50. #  endif /* ATARI */
  51. #endif /* AMIGA */
  52.  
  53. /* standard includes */
  54. #include <stdio.h>
  55. #ifdef ANSI
  56. #  include <stdlib.h>
  57. #  include <string.h>
  58. #  ifdef AMIGA
  59. #    ifndef _DCC
  60. #      include <dos.h>
  61. #    endif /* !_DCC */
  62. #  endif /* AMIGA */
  63. #  ifdef ATARI
  64. #    ifndef __GNUC__
  65. #        include <tos.h>
  66. #        include <ext.h>
  67. #    else
  68. #        include <unixlib.h>
  69. #        include <fcntl.h>
  70. #        define S_IWRITE    W_OK
  71. #        define S_IREAD     R_OK
  72. #    endif /* __GNUC__ */
  73. #  endif /* ATARI */
  74. #endif /* ANSI */
  75.  
  76. #ifndef ANSI
  77. char *strchr();
  78. char *strrchr();
  79. #endif
  80.  
  81. /* open mode for files */
  82. #ifdef ATARI
  83. #  define OPEN_FOR_READING "rb"
  84. #  define OPEN_FOR_WRITING "wb"
  85. #  define OPEN_FOR_APPEND  "rb+"
  86. #  ifndef __GNUC__
  87.      extern int access(char *, int);
  88. #  endif /* __GNUC__ */
  89. #else
  90. #  define OPEN_FOR_READING "r"
  91. #  define OPEN_FOR_WRITING "w"
  92. #  define OPEN_FOR_APPEND  "r+"
  93. #endif
  94.  
  95. /* prototyping on/off */
  96. #ifdef ANSI
  97. #  define Args(x)    x
  98. #else
  99. #  define Args(x)    ()
  100. #endif /* ANSI */
  101.  
  102.  
  103. #ifdef AZTEC_C
  104.    void *malloc        Args((unsigned));
  105.    void free        Args((char *));
  106.    char *strchr();
  107.    char *strrchr();
  108. #endif /* AZTEC_C */
  109.  
  110.  
  111. #ifdef AMIGA
  112. #  ifdef LATTICE
  113. #    define perror(x)    poserr(x)
  114. #  endif /* LATTICE */
  115. #  ifdef AZTEC_C
  116. #    define remove(x)    unlink(x)
  117.      /* warning: AztecC seems to have problems with the returncode from fseek */
  118. #  endif /* AZTEC_C */
  119. #else AMIGA
  120. #  ifndef ANSI
  121. #    define remove(x)    unlink(x)
  122. #  endif /* ANSI */
  123. #endif /* AMIGA */
  124.  
  125. #ifdef ATARI
  126. #  include <errno.h>
  127. #else
  128. extern int errno;
  129. #endif
  130.  
  131. /*    Structure of a fontlibrary :
  132.  *    +---------------------------------------+
  133.  *    |   magic number        4 Bytes    |
  134.  *    |   number of direntries    4 Bytes    |
  135.  *    |   [flib_dirent]*            |
  136.  *    |   [modules]*                |
  137.  *    +---------------------------------------+
  138.  */
  139.  
  140.  
  141.  
  142. /* important constants */
  143. #define OLD_LIBMAGIC    0xA797F033L        /* magic number */
  144. #define LIBMAGIC    (((long)'F'<<24) | ((long)'L'<<16) | ((long)'I'<<8) | (long)'B')
  145. #define LNKMAGIC    (((long)'F'<<24) | ((long)'L'<<16) | ((long)'N'<<8) | (long)'K')
  146. #define FILENAMELEN    14
  147. #define NEWFILENAMELEN    22
  148. #define TMPFLIB        "tmpflib.tmp"
  149. #define BUFSIZE        20480
  150. #define DOSNAMESIZE    100
  151. #define MAXLINKLEVELS    20
  152.  
  153. #ifdef AMIGA
  154. #  define MACHINE    "AMIGA"
  155. #else
  156. #  ifdef ATARI
  157. #    define MACHINE    "ATARI"
  158. #  else
  159. #    define MACHINE    "UNIX"
  160. #    include <sys/file.h>
  161. #    define S_IWRITE    W_OK
  162. #    define S_IREAD    R_OK
  163. #  endif /* ATARI */
  164. #endif /* AMIGA */
  165.  
  166. #define VERSION        "1.03"
  167. #ifdef ATARI
  168. #  define HEADER        "FontLib Manager - Version %s for %s \275 1990 Georg Hessmann/Robert Stabl\n"
  169. #else
  170. #  define HEADER        "FontLib Manager - Version %s for %s (c) 1990 Georg Hessmann\n"
  171. #endif
  172.  
  173. #define    OLD_VERSION    0
  174. #define NEW_VERSION    1
  175.  
  176.  
  177. static char buffer[BUFSIZE];    /* used to copy modules */
  178.  
  179.  
  180. #ifndef FALSE
  181. #  define FALSE        0
  182. #endif /* FALSE */
  183. #ifndef TRUE
  184. #  define TRUE        (!FALSE)
  185. #endif /* TRUE */
  186.  
  187. #define offset(ptr,member)    ((long)(&((ptr)->member))-(long)(ptr))
  188.  
  189.  
  190. /************ structure definitions ***************/
  191. /* fontlib directory structures */
  192. struct flib_dirent { char mname[FILENAMELEN];        /* old version */
  193.                      long size;        /* size of pk-module in bytes */
  194.                      long where;    /* position in flib-file */
  195.                    };
  196.  
  197. struct new_flib_dirent { char  mname[NEWFILENAMELEN];    /* new version */
  198.              unsigned short checksum;
  199.              long  size;        /* size of pk-module in bytes */
  200.              long  where;        /* position in flib-file */
  201.                        };
  202.  
  203. union direntry { struct flib_dirent    old;
  204.          struct new_flib_dirent    new;
  205.            };
  206.  
  207.  
  208. /* internal representation of the flib-directory */
  209. struct dirlist { struct new_flib_dirent dirent;
  210.                  struct dirlist *next;
  211.            };
  212.  
  213. struct dir { long        total;
  214.          long        alloc;
  215.          int        version;    /* old or new flib */
  216.          int        is_link;
  217.              struct dirlist *dirlist;
  218.              char        real_name[DOSNAMESIZE];
  219.        };
  220.  
  221.  
  222. /*********   P R O T O T Y P E S   ********/
  223.  
  224.     /* main function                        */
  225. void main                Args((int argc, char *argv[]));
  226.  
  227.  
  228. /********* local functions **********/
  229.     /* print the help                        */
  230. static void  usage            Args((char *pname));
  231.     /* parse the first argument                    */
  232. static int   decode_args        Args((int argc, char **argv,
  233.                           int *table,
  234.                           int *extract,
  235.                           int *create,
  236.                           int *delete,
  237.                           int *compress,
  238.                           int *verbose,
  239.                           int *rename,
  240.                           int *test,
  241.                           int *link,
  242.                           int *term_input));
  243.     /* delete flib with the name "name" and rename the tmpflib to "name" */
  244.     /* nr is the number of modules in the flib => nr == 0 --> no flib    */
  245. static int   insert_name_into_dir    Args((char *name,
  246.                           struct dirlist **dirl,
  247.                           int version));
  248.     /* is module from "test" in "inp1" or "inp2" ? */
  249. static struct dirlist *exist_entry    Args((struct dirlist *inp1,
  250.                           struct dirlist *inp2,
  251.                           struct dirlist *test));
  252.     /* create a dirlist structure entry whith the module-name "name"    */
  253. static int   read_new_modules        Args((int term_input,
  254.                           int argc,
  255.                           char **argv,
  256.                           struct dir *directory,
  257.                           struct dirlist **start_dirl,
  258.                           int verbose));
  259.     /* read a list of modules from argv or from stdin        */
  260. static FILE *open_flib            Args((char *name,
  261.                           char *mode,
  262.                           struct dir *directory,
  263.                           short levels));
  264.     /* open a flib and test the magic-number            */
  265. static int   read_dir            Args((FILE *f,
  266.                           struct dir *directory));
  267.     /* read the directory from the flib (file-pointer must be on the first dir)       */
  268.     /* only this directory entries a correct where "where != 0" the others are unused */
  269. static void  print_dir            Args((struct dir *directory,
  270.                           char *lib_name,
  271.                           int verbose));
  272.     /* print the contents of the directory                */
  273. static int   ex_module            Args((struct dir *directory,
  274.                           char *mname,
  275.                           FILE *flib, int verbose));
  276.     /* search a module in the flib and copy it to a new file    */
  277. static int   create_new_flib        Args((struct dir *directory,
  278.                           char *name,
  279.                           int verbose));
  280.     /* create a complete (new) flib, copy only files into the flib    */
  281. static int   copy_module        Args((char *name,
  282.                           FILE *flib,
  283.                           long *size,
  284.                           long *where,
  285.                           unsigned short *check));
  286.     /* create a new flib and prepare the directory part        */
  287. static FILE *copy_directory        Args((struct dir *directory,
  288.                           char *name,
  289.                           int verbose));
  290.     /* copy a module (file) to the actual position in flib        */
  291. static FILE *copy_old_flib        Args((struct dir *directory,
  292.                           FILE *flib,
  293.                           char *name,
  294.                           int verbose));
  295.     /* copy the modules (from flib) with "where != 0" to flib (tmplib) */
  296. static int   append_modules_to_flib    Args((struct dir *directory,
  297.                           FILE *flib,
  298.                           int verbose));
  299.     /* copy the modules (files) with "where == 0" to flib (tmplib)     */
  300. static int   del_module_from_dir    Args((struct dir *directory,
  301.                           char *name,
  302.                           int verbose));
  303.     /* find a module and delete it from the directory list        */
  304. static void  copy_tmpflib        Args((char *name,
  305.                           long nr));
  306.     /* copy file source to file drain                 */
  307. static int   copy_file            Args((char *source,
  308.                           char *drain));
  309.     /* save directory to file                    */
  310. static int   update_dir            Args((struct dir *directory,
  311.                           FILE *flib,
  312.                           int verbose));
  313.     /* change module-names in directory                */
  314. static int   rename_entries        Args((struct dir *directory,
  315.                           struct dirlist *dirl,
  316.                           int verbose));
  317.     /* test all checksums of the fontlibrary            */
  318. static void  test_flib            Args((FILE *flib,
  319.                           struct dir *directory,
  320.                           int verbose));
  321.     /* read the directory structure                    */
  322. static int   freaddir            Args((union direntry *dir,
  323.                           int version,
  324.                           FILE *f));
  325.     /* read a four byte number <hihi lohi hilo lolo>        */
  326. static int   freadlong            Args((long *buf,
  327.                           FILE *f));
  328.     /* read a two byte number <hi lo>                */
  329. static int   freadshort            Args((unsigned short *buf,
  330.                           FILE *f));
  331.     /* write the directory structure                */
  332. static int   fwritedir            Args((union direntry *dir,
  333.                           int version,
  334.                           FILE *f));
  335.     /* write a four byte number <hihi lohi hilo lolo>        */
  336. static int   fwritelong            Args((long buf,
  337.                           FILE *f));
  338.     /* write a two byte number <hi lo>                */
  339. static int   fwriteshort        Args((unsigned short buf,
  340.                           FILE *f));
  341.  
  342.  
  343.  
  344. /********************   M A I N   ********************/
  345. void main(argc, argv)
  346.   int argc;
  347.   char *argv[];
  348. {
  349.   FILE *flib;
  350.   struct dir directory;
  351.   char input[256];
  352.   int table, extract, create, delete, compress, verbose, rename, test, link, term_input;
  353.   int i;
  354. #ifdef ATARI
  355. # ifndef __GNUC__
  356.   char progname [] = "flib";
  357.  
  358.   argv[0] = (char *)progname;
  359. # endif
  360. #endif
  361.  
  362.   if (argc < 3) {
  363.     usage(argv[0]);
  364.     exit(5);
  365.   }
  366.   directory.total   = directory.alloc = 0;
  367.   directory.dirlist = NULL;
  368.   directory.version = NEW_VERSION;    /* default version */
  369.   flib = NULL;
  370.  
  371.   if (!decode_args(argc, argv, &table, &extract, &create, &delete, &compress,
  372.         &verbose, &rename, &test, &link, &term_input)) {
  373.     usage(argv[0]);
  374.     exit(5);
  375.   }
  376.  
  377.   if (verbose) {
  378.     printf(HEADER,VERSION,MACHINE);
  379.   }
  380.  
  381.   /**************** extract **************/
  382.   if (extract) {
  383.     if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  384.         exit(5);
  385.     }
  386.     if (!read_dir(flib,&directory)) {
  387.         exit(5);
  388.     }
  389.     if (term_input) {
  390.         while (!feof(stdin)) {
  391.             if (gets(input) != NULL) {
  392.                 (void)ex_module(&directory,input,flib,verbose);
  393.             }
  394.         }
  395.     }
  396.     else {
  397.             if(argc == 3) { /* extract all if no modules specified ++jrb */
  398.             struct dirlist *dl;
  399.             for(dl = directory.dirlist; dl != NULL; dl = dl->next)
  400.             (void)ex_module(&directory,dl->dirent.mname,flib,
  401.                     verbose);
  402.         }
  403.         else { /* extract only modules specified */
  404.             for (i=3; i<argc; i++) {
  405.             (void)ex_module(&directory,argv[i],flib,verbose);
  406.             }
  407.         }
  408.     }
  409.     fclose(flib);
  410.     flib = NULL;
  411.   }
  412.   /**************** create **************/
  413.   if (create) {
  414. #if defined(AMIGA)
  415.     if (access(argv[2],6) == 0) {    /* read + write */
  416. #else
  417.     if (access(argv[2],S_IWRITE | S_IREAD) == 0) {    /* read + write */
  418. #endif
  419.         struct dirlist *dirl, *start_dirl;
  420.         FILE *tmplib;
  421.         int nr;
  422.  
  423.         if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  424.             exit(5);
  425.         }
  426.         if (!read_dir(flib,&directory)) {
  427.             exit(5);
  428.         }
  429.         /* append the rest */
  430.         /* internal directory */
  431.         for (dirl = directory.dirlist;
  432.             dirl != NULL && dirl->next != NULL;
  433.             dirl = dirl->next);
  434.         nr = read_new_modules(term_input,argc,argv,
  435.                     &directory,&start_dirl,verbose);
  436.         if (dirl == NULL) {
  437.             directory.dirlist = start_dirl;
  438.             directory.total = nr;
  439.         }
  440.         else {
  441.             dirl->next = start_dirl;
  442.             directory.total += nr;
  443.         }
  444.         directory.alloc += nr;
  445.         /* copy old flib with the new directory */
  446.         if ((tmplib = copy_old_flib(&directory,flib,argv[2],verbose)) == NULL) {
  447.             exit(5);
  448.         }
  449.         /* append the new modules */
  450.         if (!append_modules_to_flib(&directory,tmplib,verbose)) {
  451.             exit(5);
  452.         }
  453.         fclose(tmplib);
  454.         fclose(flib);
  455.         flib = NULL;
  456.         copy_tmpflib(directory.real_name,directory.total);
  457.     }
  458.     else {
  459.         directory.total = read_new_modules(term_input,argc,argv,
  460.                 &directory,&(directory.dirlist),verbose);
  461.         if (!create_new_flib(&directory,argv[2],verbose)) {
  462.             exit(5);
  463.         }
  464.     }
  465.   }
  466.   /**************** delete **************/
  467.   if (delete) {
  468.     FILE *tmplib;
  469.  
  470.     if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  471.         exit(5);
  472.     }
  473.     if (directory.version == OLD_VERSION) {
  474.         if (verbose) {
  475.             printf("This option only works with the new flib-version!\n");
  476.             printf("Convert first the flib with \"flib z %s\"\n",argv[2]);
  477.         }
  478.         else {
  479.             fprintf(stderr,"Wrong flib-version!\n");
  480.         }
  481.     }
  482.     if (!read_dir(flib,&directory)) {
  483.         exit(5);
  484.     }
  485.     if (term_input) {
  486.         while (!feof(stdin)) {
  487.             if (gets(input) != NULL) {
  488.                 (void)del_module_from_dir(&directory,input,verbose);
  489.             }
  490.         }
  491.     }
  492.     else {
  493.         if (argc==3) {
  494.             if (verbose) {
  495.                 printf("No module to delete!?!\n");
  496.             }
  497.             fclose(flib);
  498.             flib = NULL;
  499.             exit(0);
  500.         }
  501.         else {
  502.             for (i=3; i<argc; i++) {
  503.                 (void)del_module_from_dir(&directory,argv[i],verbose);
  504.             }
  505.         }
  506.     }
  507.     /* copy old flib with the new directory */
  508.     if ((tmplib = copy_old_flib(&directory,flib,argv[2],verbose)) == NULL) {
  509.         exit(5);
  510.     }
  511.     /* append the new modules */
  512.     if (!append_modules_to_flib(&directory,tmplib,verbose)) {
  513.         exit(5);
  514.     }
  515.     fclose(tmplib);
  516.     fclose(flib);
  517.     flib = NULL;
  518.     copy_tmpflib(directory.real_name,directory.total);
  519.   }
  520.   /**************** compress **************/
  521.   if (compress) {
  522.     FILE *tmplib;
  523.  
  524.     if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  525.         exit(5);
  526.     }
  527.     if (!read_dir(flib,&directory)) {
  528.         exit(5);
  529.     }
  530.     if (directory.version != NEW_VERSION) {
  531.         directory.version = NEW_VERSION;
  532.         if (verbose) {
  533.             printf("Converting old to new version.\n");
  534.         }
  535.     }
  536.     if (verbose) {
  537.         printf("Old directory size: %ld, new directory size: %ld.\n",
  538.             directory.alloc, directory.total);
  539.     }
  540.     /* copy old flib */
  541.     if ((tmplib = copy_old_flib(&directory,flib,argv[2],verbose)) == NULL) {
  542.         exit(5);
  543.     }
  544.     update_dir(&directory, tmplib, verbose);
  545.     fclose(tmplib);
  546.     fclose(flib);
  547.     flib = NULL;
  548.     copy_tmpflib(directory.real_name,directory.total);
  549.   }
  550.   /**************** rename **************/
  551.   if (rename) {
  552.     struct dirlist *dirl;
  553.     int nr;
  554.  
  555.     if ((flib = open_flib(argv[2],OPEN_FOR_APPEND,&directory,(short)0)) == NULL) {
  556.         exit(5);
  557.     }
  558.     if (directory.version == OLD_VERSION) {
  559.         if (verbose) {
  560.             printf("This option only works with the new flib-version!\n");
  561.             printf("Convert first the flib with \"flib z %s\"\n",argv[2]);
  562.         }
  563.         else {
  564.             fprintf(stderr,"Wrong flib-version!\n");
  565.         }
  566.     }
  567.     nr = read_new_modules(term_input,argc,argv,&directory,&dirl,verbose);
  568.     if (!read_dir(flib,&directory)) {
  569.         exit(5);
  570.     }
  571.     if (!rename_entries(&directory,dirl,verbose)) {
  572.         exit(5);
  573.     }
  574.     update_dir(&directory, flib, verbose);
  575.     fclose(flib);
  576.     flib = NULL;
  577.   }
  578.   /**************** test ***************/
  579.   if (test) {
  580.     if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  581.         exit(5);
  582.     }
  583.     if (directory.version == OLD_VERSION) {
  584.         if (verbose) {
  585.             printf("This option only works with the new flib-version!\n");
  586.             printf("Convert first the flib with \"flib z %s\"\n",argv[2]);
  587.         }
  588.         else {
  589.             fprintf(stderr,"Wrong flib-version!\n");
  590.         }
  591.     }
  592.     else {
  593.         if (directory.alloc == 0 && !read_dir(flib,&directory)) {
  594.             exit(5);
  595.         }
  596.         test_flib(flib,&directory,verbose);
  597.     }
  598.     fclose(flib);
  599.     flib = NULL;
  600.   }
  601.   /**************** link ***************/
  602.   if (link) {
  603.     char link_name[DOSNAMESIZE];
  604.  
  605.     if ((flib = fopen(argv[2],OPEN_FOR_WRITING)) == NULL) {
  606.     }
  607.     else {
  608.         if (!fwritelong(LNKMAGIC,flib)) {
  609.             perror("*** ");
  610.             fprintf(stderr,"*** Can't write to LNK-flib \"%s\"!\n",
  611.                 argv[2]);
  612.             exit(5);
  613.         }
  614.         link_name[0] = '<';
  615.         link_name[1] = '\0';
  616.         strcat(link_name,argv[3]);
  617.         strcat(link_name,">");
  618.         if (fwrite(link_name,sizeof(char),strlen(link_name),flib) != strlen(link_name)) {
  619.             perror("*** ");
  620.             fprintf(stderr,"*** Can't write to LNK-flib \"%s\"!\n",
  621.                 argv[2]);
  622.             exit(5);
  623.         }
  624.         fclose(flib);
  625.         flib = NULL;
  626.     }
  627.   }
  628.   /**************** table **************/
  629.   if (table) {
  630.     if (flib == NULL) {
  631.         if ((flib = open_flib(argv[2],OPEN_FOR_READING,&directory,(short)0)) == NULL) {
  632.             exit(5);
  633.         }
  634.         if (directory.alloc == 0 && !read_dir(flib,&directory)) {
  635.             exit(5);
  636.         }
  637.     }
  638.     print_dir(&directory,argv[2],verbose);
  639.     fclose(flib);
  640.   }
  641. }    /* main */
  642.  
  643.  
  644. /* print the help */
  645. static void usage(pname)
  646.   char *pname;
  647. {
  648.   fprintf(stderr,HEADER,VERSION,MACHINE);
  649.   fprintf(stderr,"usage: %s c|a|x|d|z|p|l|t[v] library [-|[modules]*]\n",pname);
  650.   fprintf(stderr,"\tc,a : create library / add (replace) module(s) to (in) library,\n");
  651.   fprintf(stderr,"\tx   : extract module(s) from library,\n");
  652.   fprintf(stderr,"\td   : delete module(s) in library,\n");
  653.   fprintf(stderr,"\tt   : print table,\n");
  654.   fprintf(stderr,"\tr   : rename module(s) in library,\n");
  655.   fprintf(stderr,"\tz   : create new flib from old flib,\n");
  656.   fprintf(stderr,"\tp   : test checksums of all modules,\n");
  657.   fprintf(stderr,"\tl   : create a flib link (second arg is the link destination),\n");
  658.   fprintf(stderr,"\tv   : verbose mode,\n");
  659.   fprintf(stderr,"\t?   : print this help,\n");
  660.   fprintf(stderr,"\t-   : read module name(s) from stdin.\n");
  661. }
  662.  
  663. /* parse the first argument */
  664. static int decode_args(argc, argv, table, extract, create,
  665.         delete, compress, verbose, rename, test, link, term_input)
  666.   int argc;
  667.   char **argv;
  668.   int *table, *extract, *create, *delete, *compress, *verbose,
  669.         *rename, *test, *link, *term_input;
  670. {
  671.   char *flags;
  672.   int c;
  673.  
  674.   *table = *extract = *create = *delete = *compress = *verbose =
  675.         *rename = *test = *link = *term_input = FALSE;
  676.   flags = argv[1];
  677.   if (*flags == '-') {
  678.     flags++;
  679.   }
  680.   c = 0;
  681.   for (; *flags != '\0'; flags++) {
  682.     switch (*flags) {
  683.         case 'c':
  684.         case 'a': *create   = TRUE; c++; break;
  685.         case 'x': *extract  = TRUE; c++; break;
  686.         case 'd': *delete   = TRUE; c++; break;
  687.         case 'z': *compress = TRUE; c++; break;
  688.         case 'r': *rename   = TRUE; c++; break;
  689.         case 'l': *link     = TRUE; c++; break;
  690.         case 'p': *test     = TRUE; break;
  691.         case 't': *table    = TRUE; break;
  692.         case 'v': *verbose  = TRUE; break;
  693.         case '?': return FALSE;
  694.         default : fprintf(stderr, "*** Unknown flag '%c'!\n",*flags);
  695.               return FALSE;
  696.     }
  697.   }
  698.   if (c >= 2) {
  699.     fprintf(stderr,"*** The flags 'c' 'x' 'd' 'z' 'r' 'l' are mutual exclusive!\n");
  700.     return FALSE;
  701.   }
  702.   if (!(*extract || *create || *delete || *table || *compress || *rename || *test || *link)) {
  703.     fprintf(stderr,"*** Missing one of the flags 'c' 'x' 'd' 'z' 't' 'p' 'l'!\n");
  704.     return FALSE;
  705.   }
  706.   if (*link && argc != 4) {
  707.     fprintf(stderr,"*** Incorrect number of arguments!\n");
  708.     return FALSE;
  709.   }
  710.   if (argc > 3 && strcmp(argv[3],"-") == 0) {
  711.     *term_input = TRUE;
  712.     if (*verbose && (*create || *extract || *delete || *rename)) {
  713.         printf("Reading module names from standard input.\n");
  714.     }
  715.   }
  716.   return TRUE;
  717. }
  718.  
  719. /* delete flib with the name "name" and rename the tmpflib to "name" */
  720. /* nr is the number of modules in the flib => nr == 0 --> no flib */
  721. static void copy_tmpflib(name, nr)
  722.   char *name;
  723.   long nr;
  724. {
  725.   if (remove(name) != 0) {
  726.     perror("*** ");
  727.     fprintf(stderr,"*** Can't remove flib \"%s\"!\n",name);
  728.   }
  729.   if (nr > 0) {
  730.     if (rename(TMPFLIB,name) != 0) {
  731.         if (!copy_file(TMPFLIB,name)) {
  732.             perror("*** ");
  733.             fprintf(stderr,"*** Can't rename temporary flib \"%s\" to \"%s\"!\n",
  734.                 TMPFLIB,name);
  735.         }
  736.         if (remove(TMPFLIB) != 0) {
  737.             perror("*** ");
  738.             fprintf(stderr,"*** Can't remove temporary flib \"%s\"!\n",TMPFLIB);
  739.         }
  740.     }
  741.   }
  742.   else {
  743.     if (remove(TMPFLIB) != 0) {
  744.         perror("*** ");
  745.         fprintf(stderr,"*** Can't remove temporary flib \"%s\"!\n",TMPFLIB);
  746.     }
  747.   }
  748. }
  749.  
  750. /* copy file source to file drain                 */
  751. static int copy_file(source, drain)
  752.   char *source;
  753.   char *drain;
  754. {
  755.   FILE *sf, *df;
  756.   long len;
  757.  
  758.   if ((sf = fopen(source,OPEN_FOR_READING)) == NULL) {
  759.     return FALSE;
  760.   }
  761.   if ((df = fopen(drain,OPEN_FOR_WRITING)) == NULL) {
  762.     fclose(sf);
  763.     return FALSE;
  764.   }
  765.   while ((len = fread(buffer,sizeof(char),BUFSIZE,sf)) == BUFSIZE) {
  766.     if (fwrite(buffer,sizeof(char),BUFSIZE,df) != BUFSIZE) {
  767.         fclose(sf);
  768.         fclose(df);
  769.         return FALSE;
  770.     }
  771.   }
  772.   if (len > 0) {
  773.     if (fwrite(buffer,sizeof(char),len,df) != len) {
  774.         fclose(sf);
  775.         fclose(df);
  776.         return FALSE;
  777.     }
  778.   }
  779.   fclose(sf);
  780.   fclose(df);
  781.   
  782.   return TRUE;
  783. }
  784.  
  785. /* create a dirlist structure entry with the module-name "name" */
  786. static int insert_name_into_dir(name,dirl,version)
  787.   char *name;
  788.   struct dirlist **dirl;
  789.   int version;
  790. {
  791.   int j;
  792.  
  793.   if ((version == NEW_VERSION && strlen(name) > NEWFILENAMELEN-1) ||
  794.         (version == OLD_VERSION && strlen(name) > FILENAMELEN-1)) {
  795.     fprintf(stderr,"*** Module name \"%s\" too long!\n",name);
  796.     return FALSE;
  797.   }
  798.   if ((*dirl = (struct dirlist *)
  799.         malloc(sizeof(struct dirlist))) == NULL) {
  800.     fprintf(stderr,"*** No memory for internal flib directory!\n");
  801.     exit(5);
  802.   }
  803.   for (j=0; j<NEWFILENAMELEN; j++) {    /* clear the string */
  804.     (*dirl)->dirent.mname[j] = '\0';
  805.   }
  806.   strcpy((*dirl)->dirent.mname,name);
  807.   (*dirl)->dirent.size  = 0L;
  808.   (*dirl)->dirent.where = 0L;
  809.   (*dirl)->next = NULL;
  810.   return TRUE;
  811. }
  812.  
  813. /* is module from "test" in "inp1" or "inp2" ? */
  814. static struct dirlist *exist_entry(inp1, inp2, test)
  815.   struct dirlist *inp1, *inp2;
  816.   struct dirlist *test;        /* only one entry in list */
  817. {
  818.   char *name = test->dirent.mname;
  819.  
  820.   for (; inp1 != NULL && strcmp(name,inp1->dirent.mname) != 0; inp1 = inp1->next);
  821.   if (inp1 != NULL) {
  822.     return inp1;
  823.   }
  824.   for (; inp2 != NULL && strcmp(name,inp2->dirent.mname) != 0; inp2 = inp2->next);
  825.   if (inp2 != NULL) {
  826.     return inp2;
  827.   }
  828.   return NULL;
  829. }
  830.  
  831. /* read a list of modules from argv or from stdin */
  832. static int read_new_modules(term_input,argc,argv,directory,start_dirl,verbose)
  833.   int term_input;
  834.   int argc;
  835.   char **argv;
  836.   struct dir *directory;
  837.   struct dirlist **start_dirl;
  838.   int verbose;
  839. {
  840.   int nr_modules, i;
  841.   struct dirlist *dirl, *old_dirl, *find_old;
  842.   char input[256];
  843.  
  844.   old_dirl = dirl = NULL;
  845.   nr_modules = 0;
  846.   *start_dirl = NULL;
  847.  
  848.   if (term_input) {
  849.     while (!feof(stdin)) {
  850.         if (gets(input) != NULL) {
  851.             if (insert_name_into_dir(input, &dirl,directory->version)) {
  852.                 if ((find_old = exist_entry(directory->dirlist,
  853.                         *start_dirl,dirl)) != NULL) {
  854.                     /* the module is already in the lib */
  855.                     /* replace it */
  856.                     find_old->dirent.where = 0L;
  857.                     /* now it must new inserted */
  858.                     if (verbose) {
  859.                         printf("Replacing module \"%s\".\n",
  860.                             find_old->dirent.mname);
  861.                     }
  862.                 }
  863.                 else {
  864.                     nr_modules++;
  865.                     if (old_dirl == NULL) {
  866.                         *start_dirl = dirl;
  867.                     }
  868.                     else {
  869.                         old_dirl->next = dirl;
  870.                     }
  871.                     old_dirl = dirl;
  872.                 }
  873.             }
  874.         }
  875.     }
  876.   }
  877.   else {
  878.     for (i=3; i<argc; i++) {
  879.         if (insert_name_into_dir(argv[i], &dirl, directory->version)) {
  880.             if ((find_old = exist_entry(directory->dirlist,
  881.                         *start_dirl,dirl)) != NULL) {
  882.                 /* the module is already in the lib */
  883.                 /* replace it */
  884.                 find_old->dirent.where = 0L;
  885.                 /* now it must new inserted */
  886.                 if (verbose) {
  887.                     printf("Replacing module \"%s\".\n",
  888.                         find_old->dirent.mname);
  889.                 }
  890.             }
  891.             else {
  892.                 nr_modules++;
  893.                 if (old_dirl == NULL) {
  894.                     *start_dirl = dirl;
  895.                 }
  896.                 else {
  897.                     old_dirl->next = dirl;
  898.                 }
  899.                 old_dirl = dirl;
  900.             }
  901.         }
  902.     }
  903.   }
  904.   if (dirl != NULL) {
  905.     dirl->next = NULL;
  906.   }
  907.   return nr_modules;
  908. }
  909.  
  910.  
  911. /* open a flib and test the magic-number */
  912. static FILE *open_flib(name,mode,directory,levels)
  913.   char *name;
  914.   char *mode;
  915.   struct dir *directory;
  916.   short levels;
  917. {
  918.   static char link_name[DOSNAMESIZE];
  919.   char *ptr;
  920.   FILE *f;
  921.   long magic;
  922.  
  923.   directory->is_link = FALSE;
  924.   directory->real_name[0] = '\0';
  925.  
  926.   if ((f = fopen(name,mode)) == NULL) {
  927.     fprintf(stderr,"*** Can't open library \"%s\"!\n",name);
  928.     return NULL;
  929.   }
  930.   if (!freadlong(&magic,f) ||
  931.     (magic != LIBMAGIC && magic != OLD_LIBMAGIC && magic != LNKMAGIC)) {
  932.         fclose(f);
  933.         fprintf(stderr,"*** File \"%s\" isn't a font library!\n",name);
  934.         return NULL;
  935.   }
  936.   if (magic == LNKMAGIC) {
  937.     (void)fread(link_name,sizeof(char),DOSNAMESIZE,f);
  938.     fclose(f);
  939.     if (link_name[0] != '<') {
  940.         fprintf(stderr,"*** Illegal flib-link \"%s\"!\n",name);
  941.         return NULL;
  942.     }
  943.     ptr = strrchr(link_name,'>');
  944.     if (ptr == NULL) {
  945.         fprintf(stderr,"*** Illegal flib-link \"%s\"!\n",name);
  946.         return NULL;
  947.     }
  948.     levels++;
  949.     if (levels > MAXLINKLEVELS) {
  950.         fprintf(stderr,"*** To many link levels!\n");
  951.         return NULL;
  952.     }
  953.     *ptr = '\0';
  954.     ptr = link_name;
  955.     ptr++;
  956.     f = open_flib(ptr,mode,directory,levels);
  957.     directory->is_link = TRUE;
  958.   }
  959.   else {
  960.     if (magic == LIBMAGIC) {
  961.         directory->version = NEW_VERSION;
  962.     }
  963.     else {
  964.         directory->version = OLD_VERSION;
  965.     }
  966.     strcpy(directory->real_name,name);
  967.   }
  968.  
  969.   return f;
  970. }
  971.  
  972. /* read the directory from the flib (file-pointer must be on the first dir) */
  973. /* only this directory entries a correct where "where != 0" the others are unused */
  974. static int read_dir(f,directory)
  975.   FILE *f;
  976.   struct dir *directory;
  977. {
  978.   long alloc;
  979.   union direntry dir;
  980.   struct dirlist *direntr, *old_direntry;
  981.   int i, j, nr;
  982.  
  983.   if (!freadlong(&alloc,f)) {
  984.     fprintf(stderr,"*** Error while reading internal flib directory!\n");
  985.     return FALSE;
  986.   }
  987.   direntr = old_direntry = NULL;
  988.   for (i=0, nr=0; i<alloc && !feof(f); i++) {
  989.     if (!freaddir(&dir,directory->version,f)) {
  990.         fprintf(stderr,"*** Error while reading internal flib directory!\n");
  991.         return FALSE;
  992.     }
  993.     if ((directory->version == NEW_VERSION && dir.new.where != 0) ||    /* used entry */
  994.         (directory->version == OLD_VERSION && dir.old.where != 0)) {
  995.         nr++;
  996.         if ((direntr = (struct dirlist *)
  997.                 malloc(sizeof(struct dirlist))) == NULL) {
  998.             fprintf(stderr,"*** No memory for internal flib directory!\n");
  999.             return FALSE;
  1000.         }
  1001.         for (j=0; j<NEWFILENAMELEN; j++) {    /* clear the string */
  1002.             direntr->dirent.mname[j] = '\0';
  1003.         }
  1004.         if (old_direntry == NULL ) {
  1005.             directory->dirlist = direntr;
  1006.         }
  1007.         else {
  1008.             old_direntry->next = direntr;
  1009.         }
  1010.         if (directory->version == NEW_VERSION) {
  1011.             direntr->dirent = dir.new;
  1012.         }
  1013.         else {
  1014.             strncpy(direntr->dirent.mname,dir.old.mname,FILENAMELEN);
  1015.             direntr->dirent.size     = dir.old.size;
  1016.             direntr->dirent.where    = dir.old.where;
  1017.             direntr->dirent.checksum = 0;
  1018.         }
  1019.         old_direntry = direntr;
  1020.     }
  1021.   }
  1022.   if (direntr != NULL) {
  1023.     direntr->next = NULL;
  1024.   }
  1025.   directory->total    = nr;
  1026.   directory->alloc    = alloc;
  1027.   if (nr == 0) {
  1028.     directory->dirlist = NULL;
  1029.   }
  1030.   return TRUE;
  1031. }
  1032.  
  1033. /* print the contents of the directory */
  1034. static void print_dir(directory, lib_name, verbose)
  1035.   struct dir *directory;
  1036.   char *lib_name;
  1037.   int verbose;
  1038. { 
  1039.   struct dirlist *temp;
  1040.  
  1041.   if (verbose) {
  1042.     if (directory->total == 1) {
  1043.         printf ("Library contains one module. ");
  1044.     }
  1045.     else {
  1046.         printf ("Library contains %ld modules. ",directory->total);
  1047.     }
  1048.     if (directory->alloc == 1) {
  1049.         printf ("Directory size is one module.\n");
  1050.     }
  1051.     else {
  1052.         printf ("Directory size is %ld modules.\n",directory->alloc);
  1053.     }
  1054.     if (directory->is_link) {
  1055.         printf ("The library \"%s\" is a link to \"%s\"!\n",
  1056.                 lib_name, directory->real_name);
  1057.     }
  1058.     if (directory->version == OLD_VERSION) {
  1059.         printf ("WARNING: That's an old library-version!\n");
  1060.     }
  1061.     printf ("\n  Module name           Size   Position\n");
  1062.     printf ("  --------------------- ------ --------\n");
  1063.     for (temp = directory->dirlist; temp != NULL; temp = temp->next) {
  1064.         printf ("  %-21s %6ld %8ld\n", temp->dirent.mname,
  1065.             temp->dirent.size, temp->dirent.where);
  1066.     }
  1067.     printf("\n");
  1068.   }
  1069.   else {
  1070.     for (temp = directory->dirlist; temp != NULL; temp = temp->next) {
  1071.         puts(temp->dirent.mname);
  1072.     }
  1073.   }
  1074.   
  1075. }
  1076.  
  1077. /* search a module in the flib and copy it to a new file */
  1078. static int ex_module(directory, mname, flib, verbose)
  1079.   struct dir *directory;
  1080.   char *mname;
  1081.   FILE *flib;
  1082.   int verbose;
  1083. {
  1084.   struct dirlist *temp;
  1085.   FILE *module;
  1086.   int i, j, count;
  1087.   unsigned short check;
  1088.  
  1089.   if (directory == NULL || flib == NULL) {
  1090.     fprintf(stderr,"*** Internal error!\n");
  1091.     return FALSE;
  1092.   }
  1093.  
  1094.   /* find the module */
  1095.   for (temp = directory->dirlist; temp != NULL
  1096.     && strcmp(temp->dirent.mname,mname) != 0; temp = temp->next);
  1097.  
  1098.   if (temp == NULL) {
  1099.     fprintf(stderr,"*** Can't find module \"%s\"!\n",mname);
  1100.     return FALSE;
  1101.   }
  1102.  
  1103.   if (verbose) {
  1104.     printf("Extracting module %s \t(%ld bytes).\n",mname, temp->dirent.size);
  1105.   }
  1106.  
  1107.   if (fseek(flib,temp->dirent.where,0) != 0) {
  1108.     perror("*** ");
  1109.     fprintf(stderr,"*** Error during fseek!\n");
  1110.     return FALSE;
  1111.   }
  1112.   if ((module = fopen(mname,OPEN_FOR_WRITING)) == NULL) {
  1113.     fprintf(stderr,"*** Can't create file \"%s\"!\n",mname);
  1114.     return FALSE;
  1115.   }
  1116.  
  1117.   count = temp->dirent.size / BUFSIZE;
  1118.   check = 0;
  1119.   for (i=0; i<count; i++) {
  1120.     if (fread(buffer,sizeof(char),BUFSIZE,flib)!=BUFSIZE) {
  1121.         fclose(module);
  1122.         fprintf(stderr,"*** Can't read from flib!\n");
  1123.         return FALSE;
  1124.     }
  1125.     for (j=0; j<BUFSIZE; j++) {
  1126.         check += (unsigned short)buffer[j];
  1127.     }
  1128.     if (fwrite(buffer,sizeof(char),BUFSIZE,module) != BUFSIZE) {
  1129.         fclose(module);
  1130.         fprintf(stderr,"*** Can't write to module %s!\n",mname);
  1131.         return FALSE;
  1132.     }
  1133.   }
  1134.   i = temp->dirent.size - count * BUFSIZE;    /* copy rest */
  1135.   if (i > 0) {
  1136.     if (fread(buffer,sizeof(char),i,flib) != i) {
  1137.         fclose(module);
  1138.         fprintf(stderr,"*** Can't read from flib!\n");
  1139.         return FALSE;
  1140.     }
  1141.     for (j=0; j<i; j++) {
  1142.         check += buffer[j];
  1143.     }
  1144.     if (fwrite(buffer,sizeof(char),i,module) != i) {
  1145.         fclose(module);
  1146.         fprintf(stderr,"*** Can't write to module %s!\n",mname);
  1147.         return FALSE;
  1148.     }
  1149.   }
  1150.  
  1151.   fclose(module);
  1152.   if (directory->version != OLD_VERSION && check != temp->dirent.checksum) {
  1153.     fprintf(stderr,"*** WARNING: Module \"%s\" extracted with wrong checksum!\n",
  1154.                 mname);
  1155.   }
  1156.  
  1157.   return TRUE;
  1158. }
  1159.  
  1160. /* create a complete (new) flib, copy only files into the flib */
  1161. static int create_new_flib(directory, name, verbose)
  1162.   struct dir *directory;
  1163.   char *name;
  1164.   int verbose;
  1165. {
  1166.   FILE *flib;
  1167.   struct dirlist *dirl;
  1168.   long size=0, where=0;
  1169.   unsigned short check;
  1170.  
  1171.   if ((flib = copy_directory(directory, name, verbose)) == NULL) {
  1172.     return FALSE;
  1173.   }
  1174.  
  1175.   /* module abspeichern */
  1176.   for (dirl = directory->dirlist; dirl != NULL; dirl = dirl->next) {
  1177.     if (verbose) {
  1178.         printf("Copying module \"%s\"\t... ",dirl->dirent.mname);
  1179.     }
  1180.     if (!copy_module(dirl->dirent.mname,flib,&size,&where,&check)) {
  1181.         fprintf(stderr,"\n*** Can't copy module \"%s\" to library!\n",
  1182.                 dirl->dirent.mname);
  1183.         return FALSE;
  1184.     }
  1185.     if (verbose) {
  1186.         printf("ok. \t(%ld bytes at %ld)\n",size,where);
  1187.     }
  1188.     dirl->dirent.size     = size;
  1189.     dirl->dirent.where    = where;
  1190.     dirl->dirent.checksum = check;
  1191.   }
  1192.   update_dir(directory, flib, verbose);
  1193.  
  1194.   return TRUE;
  1195. }
  1196.  
  1197.  
  1198. /* create a new flib and prepare the directory part */
  1199. static FILE *copy_directory(directory, name, verbose)
  1200.   struct dir *directory;
  1201.   char *name;
  1202.   int verbose;
  1203. {
  1204.   FILE *flib;
  1205.   long magic = (directory->version == NEW_VERSION) ? LIBMAGIC : OLD_LIBMAGIC;
  1206.   struct dirlist *dirl;
  1207.   union direntry dir;
  1208.  
  1209.   if ((flib = fopen(name,OPEN_FOR_WRITING)) == NULL) {
  1210.     fprintf(stderr,"*** Can't open destination library!\n");
  1211.     return NULL;
  1212.   }
  1213.   if (!fwritelong(magic,flib) || !fwritelong(directory->total,flib)) {
  1214.     fprintf(stderr,"*** Can't write to destination library!\n");
  1215.     return NULL;
  1216.   }
  1217.   /* directory anlegen */
  1218.   if (verbose) {
  1219.     printf("Creating internal flib directory\t... ");
  1220.   }
  1221.   for (dirl = directory->dirlist; dirl != NULL; dirl = dirl->next) {
  1222.     if (directory->version == NEW_VERSION) {
  1223.         dir.new = dirl->dirent;
  1224.     }
  1225.     else {
  1226.         strncpy(dir.old.mname,dirl->dirent.mname,FILENAMELEN);
  1227.         dir.old.size  = dirl->dirent.size;
  1228.         dir.old.where = dirl->dirent.where;
  1229.     }
  1230.     if (!fwritedir(&dir,directory->version,flib)) {
  1231.         fprintf(stderr,"*** Can't write to destination library!\n");
  1232.         return NULL;
  1233.     }
  1234.   }
  1235.   if (verbose) {
  1236.     printf("ok.\n");
  1237.   }
  1238.   return flib;
  1239. }
  1240.  
  1241. /* copy a module (file) to the actual position in flib */
  1242. static int copy_module(name, flib, size, where, check)
  1243.   char *name;
  1244.   FILE *flib;
  1245.   long *size, *where;
  1246.   unsigned short *check;
  1247. {
  1248.   FILE *module;
  1249.   int len, i;
  1250.  
  1251.   if ((module = fopen(name,OPEN_FOR_READING)) == NULL) {
  1252.     return FALSE;
  1253.   }
  1254.   *size = 0;
  1255.   *where = ftell(flib);
  1256.   *check = 0;
  1257.   while ((len = fread(buffer,sizeof(char),BUFSIZE,module)) == BUFSIZE) {
  1258.     if (fwrite(buffer,sizeof(char),BUFSIZE,flib) != BUFSIZE) {
  1259.         fclose(module);
  1260.         return FALSE;
  1261.     }
  1262.     *size += BUFSIZE;
  1263.     for (i=0; i<BUFSIZE; i++) {
  1264.         *check += (unsigned short)buffer[i];
  1265.     }
  1266.   }
  1267.   if (len > 0) {
  1268.     if (fwrite(buffer,sizeof(char),len,flib) != len) {
  1269.         fclose(module);
  1270.         return FALSE;
  1271.     }
  1272.     *size += len;
  1273.     for (i=0; i<len; i++) {
  1274.         *check += (unsigned short)buffer[i];
  1275.     }
  1276.   }
  1277.   fclose(module);
  1278.  
  1279.   return TRUE;
  1280. }
  1281.  
  1282. /* copy the modules (from flib) with "where != 0" to flib (tmplib) */
  1283. static FILE *copy_old_flib(directory, flib, name, verbose)
  1284.   struct dir *directory;
  1285.   FILE *flib;
  1286.   char *name;
  1287.   int verbose;
  1288. {
  1289.   FILE *tmplib;
  1290.   struct dirlist *dirl;
  1291.   long where;
  1292.   int i, j;
  1293.   long len ,count;
  1294.   unsigned short check;
  1295.  
  1296.   if ((tmplib = copy_directory(directory, TMPFLIB, verbose)) == NULL) {
  1297.     return NULL;
  1298.   }
  1299.  
  1300.   /* module copy */
  1301.   for (dirl = directory->dirlist; dirl != NULL;    dirl = dirl->next) {
  1302.     if (dirl->dirent.where != 0L) {
  1303.         if (verbose) {
  1304.             printf("Copying module \"%s\"\t... ",dirl->dirent.mname);
  1305.         }
  1306.         if (fseek(flib,dirl->dirent.where,0) != 0) {
  1307.             perror("*** ");
  1308.             fprintf(stderr,"*** Error during fseek!\n");
  1309.             return NULL;
  1310.         }
  1311.         where = ftell(tmplib);
  1312.         count = dirl->dirent.size / BUFSIZE;
  1313.         check = 0;
  1314.         for (i=0; i<count; i++) {
  1315.             if (fread(buffer,sizeof(char),BUFSIZE,flib)!=BUFSIZE) {
  1316.                 fclose(tmplib);
  1317.                 fprintf(stderr,"*** Can't read from flib!\n");
  1318.                 return NULL;
  1319.             }
  1320.             for (j=0; j<BUFSIZE; j++) {
  1321.                 check += (unsigned short)buffer[j];
  1322.             }
  1323.             if (fwrite(buffer,sizeof(char),BUFSIZE,tmplib) != BUFSIZE) {
  1324.                 fclose(tmplib);
  1325.                 fprintf(stderr,"*** Can't write to temporary flib!\n");
  1326.                 return NULL;
  1327.             }
  1328.         }
  1329.         len = dirl->dirent.size - count * BUFSIZE;
  1330.         if (len > 0) {
  1331.             if (fread(buffer,sizeof(char),(int)len,flib) != len) {
  1332.                 fclose(tmplib);
  1333.                 fprintf(stderr,"*** Can't read from flib!\n");
  1334.                 return NULL;
  1335.             }
  1336.             for (j=0; j<len; j++) {
  1337.                 check += (unsigned short)buffer[j];
  1338.             }
  1339.             if (fwrite(buffer,sizeof(char),(int)len,tmplib) != len) {
  1340.                 fclose(tmplib);
  1341.                 fprintf(stderr,"*** Can't write to temporary flib!\n");
  1342.                 return NULL;
  1343.             }
  1344.         }
  1345.         dirl->dirent.where = where;
  1346.         dirl->dirent.checksum = check;
  1347.         if (verbose) {
  1348.             printf("ok.\n");
  1349.         }
  1350.     }
  1351.   }
  1352.   return tmplib;
  1353. }
  1354.  
  1355. /* copy the modules (files) with "where == 0" to flib (tmplib) */
  1356. static int append_modules_to_flib(directory, flib, verbose)
  1357.   struct dir *directory;
  1358.   FILE *flib;
  1359.   int verbose;
  1360. {
  1361.   struct dirlist *dirl;
  1362.   long size, where;
  1363.   unsigned short check;
  1364.  
  1365.   /* module abspeichern */
  1366.   if (fseek(flib,0L,2) != 0) {        /* end of file */
  1367.     perror("*** ");
  1368.     fprintf(stderr,"*** Error during fseek!\n");
  1369.     return 0;
  1370.   }
  1371.   for (dirl = directory->dirlist; dirl != NULL; dirl = dirl->next) {
  1372.     if (dirl->dirent.where == 0L) {
  1373.         if (verbose) {
  1374.             printf("Copying module \"%s\"\t... ",dirl->dirent.mname);
  1375.         }
  1376.         if (!copy_module(dirl->dirent.mname,flib,&size,&where,&check)) {
  1377.             fprintf(stderr,"\n*** Can't copy module \"%s\" to library!\n");
  1378.             return FALSE;
  1379.         }
  1380.         if (verbose) {
  1381.             printf("ok. \t(%ld bytes at %ld)\n",size,where);
  1382.         }
  1383.         dirl->dirent.size     = size;
  1384.         dirl->dirent.where    = where;
  1385.         dirl->dirent.checksum = check;
  1386.     }
  1387.   }
  1388.   return update_dir(directory, flib, verbose);
  1389. }
  1390.  
  1391. /* find a module and delete it from the directory list */
  1392. static int del_module_from_dir(directory, name, verbose)
  1393.   struct dir *directory;
  1394.   char *name;
  1395.   int verbose;
  1396. {
  1397.   struct dirlist *temp, *parent;
  1398.  
  1399.   if (directory == NULL) {
  1400.     fprintf(stderr,"*** Internal error!\n");
  1401.     return FALSE;
  1402.   }
  1403.  
  1404.   /* find the module */
  1405.   for (temp = directory->dirlist, parent = NULL; temp != NULL
  1406.     && strcmp(temp->dirent.mname,name) != 0;
  1407.     parent = temp, temp = temp->next);
  1408.  
  1409.   if (temp == NULL) {
  1410.     fprintf(stderr,"*** Can't find module \"%s\"!\n",name);
  1411.     return FALSE;
  1412.   }
  1413.   /* delete module from directory-list */
  1414.   if (parent == NULL) {
  1415.     directory->dirlist = temp->next;
  1416.   }
  1417.   else {
  1418.     parent->next = temp->next;
  1419.   }
  1420.   free(temp);
  1421.   directory->alloc = --directory->total;
  1422.  
  1423.   return TRUE;
  1424. }
  1425.  
  1426. /* save directory to file */
  1427. static int update_dir(directory, flib, verbose)
  1428.   struct dir *directory;
  1429.   FILE *flib;
  1430.   int verbose;
  1431. {
  1432.   struct dirlist *dirl;
  1433.   union direntry dir;
  1434.  
  1435.   /* directory size-where */
  1436.   if (verbose) {
  1437.     printf("Updating internal flib directory\t... ");
  1438.   }
  1439.   if (fseek(flib,8L,0) != 0) {
  1440.     perror("*** ");
  1441.     fprintf(stderr,"*** Can't fseek?!\n");
  1442.     return FALSE;
  1443.   }
  1444.   for (dirl = directory->dirlist; dirl != NULL; dirl = dirl->next) {
  1445.     if (directory->version == NEW_VERSION) {
  1446.         dir.new = dirl->dirent;
  1447.     }
  1448.     else {
  1449.         strncpy(dir.old.mname,dirl->dirent.mname,FILENAMELEN);
  1450.         dir.old.size  = dirl->dirent.size;
  1451.         dir.old.where = dirl->dirent.where;
  1452.     }
  1453.     if (!fwritedir(&dir,directory->version,flib)) {
  1454.         fprintf(stderr,"*** Can't write to destination library!\n");
  1455.         return FALSE;
  1456.     }
  1457.   }
  1458.   if (verbose) {
  1459.     printf("ok.\n");
  1460.   }
  1461.   return TRUE;
  1462. }
  1463.  
  1464.  
  1465. /* change module-names in directory                */
  1466. /* if dirl empty then change all names in directory        */
  1467. static int rename_entries(directory,dirl,verbose)
  1468.   struct dir     *directory;
  1469.   struct dirlist *dirl;
  1470.   int         verbose;
  1471. {
  1472.   struct dirlist *entry, *found;
  1473.   char str[256];
  1474.   int allowed_length = (directory->version == NEW_VERSION)
  1475.                 ? NEWFILENAMELEN
  1476.                 : FILENAMELEN;
  1477.  
  1478.  
  1479.   if (dirl == NULL) {        /* no modules -> change all names */
  1480.     for (entry = directory->dirlist; entry != NULL; entry = entry->next) {
  1481.         do {
  1482.             printf("Old name: %s, change it to: ",entry->dirent.mname);
  1483.             if (gets(str) == NULL) {
  1484.                 fprintf(stderr,"\nUnexpected end of \"stdin\"!?\n");
  1485.                 return FALSE;
  1486.             }
  1487.             if (strlen(str) > allowed_length) {
  1488.                 fprintf(stderr,"New name too long!\n");
  1489.             }
  1490.         } while (strlen(str) > allowed_length);
  1491.         if (str[0] != '\0') {
  1492.             if (verbose) {
  1493.                 printf("%s ---> %s\n",entry->dirent.mname,str);
  1494.             }
  1495.             strcpy(entry->dirent.mname,str);
  1496.         }
  1497.     }
  1498.   }
  1499.   else {            /* change only the names of the given modules */
  1500.     for (entry = dirl; entry != NULL; entry = entry->next) {
  1501.         if ((found = exist_entry(NULL,directory->dirlist,entry)) != NULL) {
  1502.             do {
  1503.                 printf("Old name: %s, change it to: ",
  1504.                         found->dirent.mname);
  1505.                 if (gets(str) == NULL) {
  1506.                     fprintf(stderr,"\nUnexpected end of \"stdin\"!?\n");
  1507.                     return FALSE;
  1508.                 }
  1509.                 if (strlen(str) > allowed_length) {
  1510.                     fprintf(stderr,"New name too long!\n");
  1511.                 }
  1512.             } while (strlen(str) > allowed_length);
  1513.             if (str[0] != '\0') {
  1514.                 if (verbose) {
  1515.                     printf("%s ---> %s\n",found->dirent.mname,str);
  1516.                 }
  1517.                 strcpy(found->dirent.mname,str);
  1518.             }
  1519.         }
  1520.     }
  1521.   }
  1522.   return TRUE;
  1523. }
  1524.  
  1525.  
  1526. /* test all checksums of the fontlibrary            */
  1527. static void test_flib(flib, directory, verbose)
  1528.   FILE *flib;
  1529.   struct dir *directory;
  1530.   int verbose;
  1531. {
  1532.   int i, j;
  1533.   struct dirlist *dirl;
  1534.   unsigned short check;
  1535.   long count, len;
  1536.  
  1537.   for (dirl = directory->dirlist; dirl != NULL;    dirl = dirl->next) {
  1538.     if (dirl->dirent.where != 0L) {
  1539.         if (verbose) {
  1540.             printf("Checking module \"%s\"\t... ",dirl->dirent.mname);
  1541.         }
  1542.         if (fseek(flib,dirl->dirent.where,0) != 0) {
  1543.             perror("*** ");
  1544.             fprintf(stderr,"*** Error during fseek!\n");
  1545.             return;
  1546.         }
  1547.         count = dirl->dirent.size / (long)BUFSIZE;
  1548.         check = 0;
  1549.         for (i=0; i<count; i++) {
  1550.             if (fread(buffer,sizeof(char),BUFSIZE,flib)!=BUFSIZE) {
  1551.                 fprintf(stderr,"*** Can't read from flib!\n");
  1552.                 return;
  1553.             }
  1554.             for (j=0; j<BUFSIZE; j++) {
  1555.                 check += (unsigned short)buffer[j];
  1556.             }
  1557.         }
  1558.         len = dirl->dirent.size - count * (long)BUFSIZE;
  1559.         if (len > 0) {
  1560.             if (fread(buffer,sizeof(char),(int)len,flib) != len) {
  1561.                 fprintf(stderr,"*** Can't read from flib!\n");
  1562.                 return;
  1563.             }
  1564.             for (j=0; j<len; j++) {
  1565.                 check += (unsigned short)buffer[j];
  1566.             }
  1567.         }
  1568.         if (dirl->dirent.checksum == check) {
  1569.             if (verbose) {
  1570.                 printf("ok.\n");
  1571.             }
  1572.         }
  1573.         else {
  1574.             if (verbose) {
  1575.                 printf("ERROR (expected %u, found %u)\n",
  1576.                     dirl->dirent.checksum, check);
  1577.             }
  1578.             else {
  1579.                 fprintf(stderr,
  1580.                       "ERROR: module \"%s\" (expected %u, found %u)\n",
  1581.                   dirl->dirent.mname, dirl->dirent.checksum, check);
  1582.             }
  1583.         }
  1584.     }
  1585.   }
  1586. }
  1587.  
  1588.  
  1589. /* read the directory structure                    */
  1590. static int freaddir(dir,version,f)
  1591.   union direntry *dir;
  1592.   int version;
  1593.   FILE *f;
  1594. {
  1595.   if (version == OLD_VERSION) {
  1596.     if (fread(dir->old.mname,FILENAMELEN,1,f) != 1) {
  1597.         return FALSE;
  1598.     }
  1599.     dir->new.mname[FILENAMELEN] = '\0';
  1600.     if (!freadlong(&(dir->old.size),f)) {
  1601.         return FALSE;
  1602.     }
  1603.     if (!freadlong(&(dir->old.where),f)) {
  1604.         return FALSE;
  1605.     }
  1606.   }
  1607.   else {
  1608.     if (fread(dir->new.mname,1,NEWFILENAMELEN,f) != NEWFILENAMELEN) {
  1609.         return FALSE;
  1610.     }
  1611.     if (!freadshort(&(dir->new.checksum),f)) {
  1612.         return FALSE;
  1613.     }
  1614.     if (!freadlong(&(dir->new.size),f)) {
  1615.         return FALSE;
  1616.     }
  1617.     if (!freadlong(&(dir->new.where),f)) {
  1618.         return FALSE;
  1619.     }    
  1620.   }
  1621.   return TRUE;
  1622. }
  1623.  
  1624.  
  1625. /* read a four byte number <hihi lohi hilo lolo> */
  1626. static int freadlong(buf,f)
  1627.   long *buf;
  1628.   FILE *f;
  1629. {
  1630.   unsigned char b[4];
  1631.  
  1632.   if (fread((char *)b,1,4,f) != 4) {
  1633.     return FALSE;
  1634.   }
  1635.   *buf = (long)(((unsigned long)b[0]) << 24) | (((unsigned long)b[1]) << 16) | 
  1636.             (((unsigned long)b[2]) << 8) | ((unsigned long)b[3]);
  1637.  
  1638.   return TRUE;
  1639. }
  1640.  
  1641. /* read a two byte number <hi lo> */
  1642. static int freadshort(buf,f)
  1643.   unsigned short *buf;
  1644.   FILE *f;
  1645. {
  1646.   unsigned char b[2];
  1647.  
  1648.   if (fread((char *)b,1,2,f) != 2) {
  1649.     return FALSE;
  1650.   }
  1651.   *buf = (unsigned short) (((unsigned short)b[0]) << 8) | ((unsigned short)b[1]);
  1652.  
  1653.   return TRUE;
  1654. }
  1655.  
  1656.  
  1657. /* write the directory structure                */
  1658. static int fwritedir(dir,version,f)
  1659.   union direntry *dir;
  1660.   int version;
  1661.   FILE *f;
  1662. {
  1663.   if (version == OLD_VERSION) {
  1664.     if (fwrite(dir->new.mname,NEWFILENAMELEN,1,f) != 1) {
  1665.         return FALSE;
  1666.     }
  1667.     if (!fwritelong(dir->new.size,f)) {
  1668.         return FALSE;
  1669.     }
  1670.     if (!fwritelong(dir->new.where,f)) {
  1671.         return FALSE;
  1672.     }
  1673.   }
  1674.   else {
  1675.     if (fwrite(dir->new.mname,NEWFILENAMELEN,1,f) != 1) {
  1676.         return FALSE;
  1677.     }
  1678.     if (!fwriteshort(dir->new.checksum,f)) {
  1679.         return FALSE;
  1680.     }
  1681.     if (!fwritelong(dir->new.size,f)) {
  1682.         return FALSE;
  1683.     }
  1684.     if (!fwritelong(dir->new.where,f)) {
  1685.         return FALSE;
  1686.     }    
  1687.   }
  1688.   return TRUE;
  1689. }
  1690.  
  1691. /* write a four byte number <hihi lohi hilo lolo> */
  1692. static int fwritelong(buf,f)
  1693.   long buf;
  1694.   FILE *f;
  1695. {
  1696.   unsigned char b[4];
  1697.  
  1698.   b[0] = (unsigned char)(((unsigned long)buf & 0xFF000000L) >> 24);
  1699.   b[1] = (unsigned char)(((unsigned long)buf & 0x00FF0000L) >> 16);
  1700.   b[2] = (unsigned char)(((unsigned long)buf & 0x0000FF00L) >> 8);
  1701.   b[3] = (unsigned char) ((unsigned long)buf & 0x000000FFL);
  1702.   if (fwrite((char *)b,1,4,f) != 4) {
  1703.     return FALSE;
  1704.   }
  1705.   return TRUE;
  1706. }
  1707.  
  1708. /* write a two byte number <hi lo> */
  1709. #ifdef ANSI
  1710. static int fwriteshort(unsigned short buf, FILE *f)
  1711. #else
  1712. static int fwriteshort(buf,f)
  1713.   unsigned short buf;
  1714.   FILE *f;
  1715. #endif /* ANSI */
  1716. {
  1717.   unsigned char b[2];
  1718.  
  1719.   b[0] = (unsigned char)(((unsigned long)buf & 0x0000FF00L) >> 8);
  1720.   b[1] = (unsigned char) ((unsigned long)buf & 0x000000FFL);
  1721.   if (fwrite((char *)b,1,2,f) != 2) {
  1722.     return FALSE;
  1723.   }
  1724.   return TRUE;
  1725. }
  1726.  
  1727.