home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fonts 1 / freshfonts1.bin / programs / amiga / pastex / pastex14-beta-6 / lsfont / lsfont.c next >
C/C++ Source or Header  |  1994-03-16  |  11KB  |  530 lines
  1.  
  2. /*
  3.  *  lsfont.c
  4.  *
  5.  *  Author: Georg Heßmann (Hessmann@Informatik.Uni-Hamburg.De)
  6.  *
  7.  *  Copyright: source/program is FD (freely distributable) © Georg Heßmann 1993
  8.  *             It's part of the PasTeX distribution.
  9.  *
  10.  *  Why do I need this program?
  11.  *
  12.  *    If you work with PasTeX and you don't have enough disk space,
  13.  *    you might want only the pk-files you really need on the disk.
  14.  *
  15.  *    Here helps this program, together with the MARK option of
  16.  *    ShowDVI and DVIprint. Start ShowDVI and DVIprint always
  17.  *    with the MARK option (put it into ENVARC:SHOWDVI and 
  18.  *    ENVARC:DVIPRINT) and the drivers will mark every font they
  19.  *    used with an use-count and a date-stamp.
  20.  *
  21.  *    After some time, if you want get rid of old, seldom used fonts,
  22.  *    start "lsfont TeX:pk TO ram:fontlist" and look into the generated
  23.  *    list. The first number is the use count. So often is the font
  24.  *    used from a driver (started with MARK).
  25.  *
  26.  *    If you want delete some fonts of the list, do 
  27.  *    "lsfont TeX:pk TO ram:fontlist DELETE" and edit the file (delete all
  28.  *    fonts out of the file which you *don't* want delete from your
  29.  *    harddisk). After that, you can "execute ram:fontlist" delete the
  30.  *    old fonts.
  31.  *
  32.  *    Other idea to use the list:
  33.  *    Do copy the fonts first on some floppy-disks and delete them after
  34.  *    that from the hard-disk. Now, if you put your backup floppies into
  35.  *    TeX:config/FontVols, the drivers will find them on your floppies.
  36.  *    
  37.  *
  38.  *  Version history:
  39.  *
  40.  *  0.1  18.Jul.93  First try.
  41.  *  1.0  16.Mar.94  Release it with PasTeX 1.4 -- BETA 1 --
  42.  *
  43.  */
  44.  
  45.  
  46. #define VERSION "1.0"
  47.  
  48. static const char version[] = "$VER: lsfont " VERSION " (16.03.94)";
  49.  
  50.  
  51. /*
  52.  * Program is 2.04 or higher only!!
  53.  *
  54.  */
  55.  
  56. long __oslibversion = 37;
  57.  
  58.  
  59.  
  60. #include "lsfont.h"
  61.  
  62.  
  63. /*
  64.  * Template for ReadArgs()
  65.  */
  66.  
  67. #define TEMPLATE    "NAME/M,TO/K,DELETE/S"
  68.  
  69.  
  70. /*
  71.  * Used Libraries
  72.  */
  73.  
  74. extern struct Library * DOSBase;
  75. extern struct Library * UtilityBase;
  76.  
  77.  
  78. /*
  79.  * File list structure
  80.  *
  81.  */
  82.  
  83. struct FLst {
  84.   long               flst_Used;
  85.   BPTR               flst_Lock;
  86.   struct DateStamp   flst_DateStamp;
  87.   struct FLst      * flst_Next;
  88. };
  89.  
  90.  
  91. /*
  92.  * Global Vars
  93.  *
  94.  */
  95.  
  96. static char          NameBuf[1024];
  97. static struct FLst * FileLstRoot = NULL;
  98. static int           SizeFileLst = 0;
  99. static FILE        * OutputFile;
  100. static int           OutDelete;
  101.  
  102.  
  103.  
  104. /*
  105.  * Disable SAS/C CTRL-C functions
  106.  *
  107.  */
  108.  
  109. int CXBRK(void) { return(0); }
  110. int _CXBRK(void) { return(0); }
  111. void chkabort(void) { return; }
  112.  
  113.  
  114.  
  115. /*
  116.  * Usefull macro to check Ctrl-C
  117.  */
  118.  
  119. #define IsCtrlC        (SetSignal(0L,SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
  120.  
  121.  
  122.  
  123.  
  124. /*
  125.  * Prototypes of the help functions
  126.  */
  127.  
  128. static int  DoArg        (char * name);
  129. static int  DoDir        (BPTR lck);
  130. static int  DoFile       (BPTR lck, struct FileInfoBlock * fib);
  131. static int  CompareFiles (const void * A, const void * B);
  132. static int  SortFileLst  (void);
  133. static void FreeFileLst  (void);
  134. static int  CheckCtrlC   (int);
  135.  
  136.  
  137.  
  138.  
  139. /*
  140.  * Main function. 
  141.  */
  142.  
  143. int main(int argc, char * argv[])
  144. {
  145.   long rc = RETURN_OK;
  146.   long options[3];
  147.   struct RDArgs * args;
  148.  
  149.   memset(options, 0, sizeof(options));
  150.  
  151.   args = ReadArgs(TEMPLATE, options, NULL);
  152.   if (args) {
  153.     char ** dirs = (char **)options[0];
  154.     char * NoArg[2];
  155.     
  156.     OutDelete = options[2];
  157.     
  158.     if (options[1]) {
  159.       OutputFile = fopen((char *)options[1], "w");
  160.       if (!OutputFile) {
  161.         PrintFault(IoErr(), (char *)options[1]);
  162.         rc = RETURN_ERROR;
  163.       }
  164.     }
  165.     else {
  166.       OutputFile = stdout;
  167.     }
  168.  
  169.     if (rc == RETURN_OK && !dirs) {
  170.       // wenn keine Argumente angegeben, dann Name des akt. Dirs. verwenden
  171.       char * namebuf = malloc(500);
  172.       if (!namebuf) {
  173.         PrintFault(ERROR_NO_FREE_STORE, NULL);
  174.         rc = RETURN_ERROR;
  175.       }
  176.       else {
  177.         BPTR lock = Lock("", ACCESS_READ);
  178.         if (!lock) {
  179.           PrintFault(IoErr(), "\"\"");
  180.           rc = RETURN_ERROR;
  181.         }
  182.         else {
  183.           if (!NameFromLock(lock, namebuf, 499)) {
  184.             PrintFault(IoErr(), "\"\"");
  185.             rc = RETURN_ERROR;
  186.           }
  187.           else {
  188.             NoArg[0] = namebuf;        // Name des aktuellen Directories
  189.             NoArg[1] = NULL;
  190.             dirs = NoArg;
  191.           }
  192.           UnLock(lock);
  193.         }
  194.       }
  195.     }
  196.  
  197.     if (rc == RETURN_OK) {
  198.       char * PatBuf = NULL;
  199.       char * ptr;
  200.   
  201.       for (; rc == RETURN_OK && (ptr = *dirs); dirs++) {
  202.         int isWild;
  203.  
  204.         if (PatBuf == NULL) PatBuf = malloc(1024);
  205.         if (PatBuf == NULL) {
  206.           PrintFault(ERROR_NO_FREE_STORE, NULL);
  207.           rc = RETURN_ERROR;
  208.           break;
  209.         }
  210.         isWild = ParsePatternNoCase(ptr, PatBuf, 1023);
  211.         
  212.         if (isWild < 0) {
  213.           PrintFault(IoErr(), NULL);
  214.           rc = RETURN_ERROR;
  215.           break;
  216.         }
  217.         else {
  218.           if (isWild == 0) {
  219.             // Kein Pattern
  220.             rc = DoArg(ptr);
  221.             if (rc != RETURN_OK) break;
  222.           }
  223.           else {
  224.             // Pattern
  225.             char __aligned buf[sizeof(struct AnchorPath)+200];
  226.             struct AnchorPath * ap = (struct AnchorPath *)buf;
  227.  
  228.             memset(ap, 0, sizeof(struct AnchorPath));
  229.             ap->ap_Strlen = 200;
  230.  
  231.             if (MatchFirst(PatBuf, ap) == 0) {
  232.               rc = DoArg(ap->ap_Buf);
  233.               while (rc == RETURN_OK && MatchNext(ap) == 0) {
  234.                 rc = DoArg(ap->ap_Buf);
  235.                 if (rc != RETURN_OK) MatchEnd(ap);
  236.               }
  237.               if (rc != RETURN_OK) break;
  238.             }
  239.             else {
  240.               PrintFault(IoErr(), NULL);
  241.               rc = RETURN_FAIL;
  242.             }
  243.           }
  244.         }
  245.  
  246.       }
  247.       
  248.       if (rc == RETURN_OK) {
  249.         rc = SortFileLst();
  250.       }
  251.  
  252.       FreeFileLst();
  253.       FreeArgs(args);
  254.     }
  255.   }
  256.   else {
  257.     PrintFault(IoErr(), NULL);
  258.     rc = RETURN_ERROR;
  259.   }
  260.   
  261.   return rc;
  262. }
  263.  
  264.  
  265.  
  266. /*
  267.  * DoArg()
  268.  *
  269.  * Nimm einen Namen (Dir oder File) und teste ihn.
  270.  *
  271.  */
  272.  
  273. static int DoArg(char * name)
  274. {
  275.   long ret;
  276.   __aligned struct FileInfoBlock fib;
  277.   BPTR lck;
  278.   
  279.   lck = Lock(name, ACCESS_READ);
  280.   if (lck) {
  281.     if (Examine(lck, &fib)) {
  282.       if (fib.fib_DirEntryType > 0) {
  283.         ret = DoDir(lck);
  284.       }
  285.       else {
  286.         ret = DoFile(lck, &fib);
  287.       }
  288.     }
  289.     else {
  290.       PrintFault(IoErr(), name);
  291.       ret = RETURN_ERROR;
  292.     }
  293.     UnLock(lck);
  294.   }
  295.   else {
  296.     PrintFault(IoErr(), name);
  297.     ret = RETURN_ERROR;
  298.   }
  299.   
  300.   return ret;    
  301. }
  302.  
  303.  
  304. /*
  305.  * DoDir()
  306.  * 
  307.  * Durchsuche ein ganzes Directory.
  308.  *
  309.  */
  310.  
  311. static int DoDir(BPTR lck)
  312. {
  313.   int ret = RETURN_OK;
  314.   BPTR newlck = DupLock(lck);
  315.   int err;
  316.   __aligned struct FileInfoBlock newfib;
  317.  
  318.   if (newlck) {
  319.     if (Examine(newlck, &newfib)) {
  320.       while (ret == RETURN_OK && ExNext(newlck, &newfib)) {
  321.         BPTR olddir = CurrentDir(newlck);
  322.         BPTR new = Lock(newfib.fib_FileName, ACCESS_READ);
  323.         if (new) {
  324.           if (newfib.fib_DirEntryType > 0) {
  325.             ret = DoDir(new);
  326.           }
  327.           else {
  328.             ret = DoFile(new, &newfib);
  329.           }
  330.           UnLock(new);
  331.         }
  332.         else {
  333.           PrintFault(IoErr(), newfib.fib_FileName);
  334.           ret = RETURN_ERROR;
  335.         }
  336.         CurrentDir(olddir);
  337.         ret = CheckCtrlC(ret);
  338.       }
  339.  
  340.       if (ret == RETURN_OK) {
  341.         err = IoErr();
  342.         if (err != ERROR_NO_MORE_ENTRIES) {
  343.           PrintFault(err, NULL);
  344.           ret = RETURN_ERROR;
  345.         }
  346.       }
  347.     }
  348.     UnLock(newlck);
  349.   }
  350.  
  351.  
  352.   return ret;
  353. }
  354.  
  355.  
  356. /*
  357.  * DoFile()
  358.  * 
  359.  * Ein File abtesten.
  360.  *
  361.  */
  362.  
  363. static int DoFile(BPTR lck, struct FileInfoBlock * fib)
  364. {
  365.   int ret = RETURN_OK;
  366.   long num = 0;
  367.   struct FLst * flst;
  368.   
  369.   flst = malloc(sizeof(struct FLst));
  370.   if (!flst) {
  371.     PrintFault(ERROR_NO_FREE_STORE, NULL);
  372.     return RETURN_ERROR;
  373.   }
  374.   
  375.   if (!strncmp(fib->fib_Comment, "FontUsed: ", 10)) {
  376.     if (sscanf(fib->fib_Comment+10, "%d (%d %d %d)", 
  377.         &num, &flst->flst_DateStamp.ds_Days, &flst->flst_DateStamp.ds_Minute, 
  378.     &flst->flst_DateStamp.ds_Tick) != 4) {
  379.       num = 0;
  380.     }
  381.   }
  382.   
  383.   if (num == 0) {
  384.     // nehme als Zeit das Datum des Files
  385.     flst->flst_DateStamp = fib->fib_Date;
  386.   }
  387.   
  388.   flst->flst_Used = num;
  389.   flst-