home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 8 / FreshFishVol8-CD1.bin / tools / pitools / pitool.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-30  |  25.7 KB  |  1,034 lines
  1. /*
  2.  *    Process Product-Info files.
  3.  *    Written by Fred Fish.
  4.  *    All portions not covered by GNU GPL are public domain.
  5.  *
  6.  *    usage:  pitool [options] file1 file2 file3 ...
  7.  *    Options:
  8.  *
  9.  *    -b    Find Product-Info files and emit information extracted
  10.  *        from each file using the format specified by the -F option.
  11.  *        By default, the information is appended to the file
  12.  *        "files.bbs" in the directory in which the product info
  13.  *        file is found.  See the -f option to use another destination.
  14.  *
  15.  *    -D    Enable some special MS-DOS support, such as contructing the
  16.  *        "stored in" name from the basename of the product info file,
  17.  *        with a few explicit possible extensions added, using a
  18.  *        different default format for the files.bbs file, and
  19.  *        using a different default name (FILES.BBS).
  20.  *
  21.  *    -F <s>    Use <s> as a format specifier for writing entries
  22.  *        with -b option.  EX: "%-30.30B %8.8V %4.4KK %-40.40S\n"
  23.  *        Format specs are:
  24.  *
  25.  *        %%    Literal '%' character.
  26.  *        %a    Contents of ".author" field.
  27.  *        %B    Basename of "stored-in" path.
  28.  *        %D    Dirname of "stored-in" path.
  29.  *        %d    Contents of ".description" field.
  30.  *        %F    Contents of ".fullname" (or ".name") field.
  31.  *        %K    Size of the "stored-in" file/directory, in Kb.
  32.  *        %N    Contents of ".name" field.
  33.  *        %P    Full "stored-in" path.
  34.  *        %s    Size of the "stored-in" file in bytes.
  35.  *        %S    Contents of the ".short" field, 40 chars max.
  36.  *        %T    Timestamp of the file or dir, as DD-MMM-YY.
  37.  *        %V    Version number of the product.
  38.  *        
  39.  *        Other characters are passed through literally, as with
  40.  *        printf.  Note that %D & %B are defined such that
  41.  *        %P=%D%B without having to know what the separator was.
  42.  *
  43.  *    -f <s>    Use <s> as the name of the file to use to write entries
  44.  *        to as a result of using the -b option.  If <s> is "-",
  45.  *        the entries are written to stdout rather than to a file
  46.  *        in each directory containing product info files.
  47.  *
  48.  *    -h    Print help message.
  49.  *
  50.  *    -n    Find Product-Info files and print names to stdout.
  51.  *
  52.  *    -s    Gather product info files and add ".stored-in" fields.
  53.  *
  54.  *    -t    Test Product Info files, report possible problems.
  55.  *
  56.  *    -v    Verbose flag, print name of each Product Info file to
  57.  *        stdout.
  58.  *
  59.  *    Generally, "file1", "file2", etc can be replaced with "-" to
  60.  *    indicate that pitool should operate on a list of files provided
  61.  *    on stdin rather than walking a file tree rooted in the path given
  62.  *    by "file1", "file2", etc.
  63.  *
  64.  */
  65.  
  66. #include <stdio.h>
  67. #include <sys/types.h>
  68. #include <sys/stat.h>
  69. #include <time.h>
  70. #include <ctype.h>
  71. #include "ftw.h"
  72.  
  73. #define STREQ(a,b) ((*(a) == *(b)) && !strcmp ((a),(b)))
  74.  
  75. extern int strlen (const char *);
  76. extern char *strrchr (const char *, char);
  77. extern char *strchr (const char *, char);
  78. extern char *strdup ();
  79.  
  80. #define AMIGA_PRINT_FORMAT "%-30.30B %8.8V %4.4KK %-40.40S\n"
  81. #define DOS_PRINT_FORMAT "%-18.18B%8s %8.8T %-40.40S\r\n"
  82. static char *print_format;
  83.  
  84. #define AMIGA_BBS_FILE_NAME "files.bbs"
  85. #define DOS_BBS_FILE_NAME "FILES.BBS"
  86. static char *bbs_file_name;
  87.  
  88. static int verbose = 0;
  89. static int dosflag = 0;
  90.  
  91. struct pif {
  92.   const char *pi_fname;    /* Name of file containing the product info */
  93.   int pi_line;        /* Current line number being read */
  94.   FILE *pi_fp;        /* "FILE *" pointer to the open file */
  95.   int pi_size;
  96.   char *pi_address;
  97.   char *pi_aminet_dir;
  98.   char *pi_author;
  99.   char *pi_construction;
  100.   char *pi_comment;
  101.   char *pi_contents;
  102.   char *pi_date;
  103.   char *pi_described_by;
  104.   char *pi_description;
  105.   char *pi_distribution;
  106.   char *pi_docs;
  107.   char *pi_email;
  108.   char *pi_exectype;
  109.   char *pi_fax;
  110.   char *pi_fullname;
  111.   char *pi_installsize;
  112.   char *pi_keywords;
  113.   char *pi_locale;
  114.   char *pi_name;    /* Contents of the ".name" field */
  115.   char *pi_phone;
  116.   char *pi_price;
  117.   char *pi_reference;
  118.   char *pi_requirements;
  119.   char *pi_restrictions;
  120.   char *pi_run;
  121.   char *pi_short;
  122.   char *pi_source;
  123.   char *pi_stored_in;
  124.   char *pi_submittal;
  125.   char *pi_tested;
  126.   char *pi_type;
  127.   char *pi_version;
  128. };
  129.  
  130. /* This list of common DOS extensions is used to find the "stored in" name
  131.    for the DOS convention for product info files (where files can only have
  132.    one extension and are length limited). */
  133.  
  134. static char *dosextens[] =
  135. {
  136.   ".LHA",    /* Lha archive */
  137.   ".ZIP",    /* Zip archive */
  138.   ".GZ",    /* Gzip compressed file */
  139.   ".TAR",    /* Tar archive */
  140.   ".TAZ",    /* Gzip compressed tar archive */
  141.   ".JPG",    /* Jpeg image */
  142.   ".GIF",    /* Gif image */
  143.   ".IFF",    /* Amiga IFF format image */
  144.   ".ANM",    /* Amiga animation */
  145.   NULL
  146. };
  147.  
  148. /* Note, we can't use isspace() here, because it counts
  149.    international characters as whitespace.  So just look
  150.    for the characters we are actually concerned about */
  151.  
  152. #define WHITESPACE(a) (((a) == ' ') || ((a) == '\t') || ((a) == '\n'))
  153.  
  154. void
  155. stripwhite (struct pif *pip, char *fieldp)
  156. {
  157.   char *endp;
  158.  
  159.   for (endp = fieldp; *endp != '\000'; endp++) {;}
  160.   endp--;
  161.  
  162.   if (WHITESPACE (*endp))
  163.     {
  164. #if 0    /* Currently there are too many Product Info files where this
  165.        is true, to make this a useful message.  Enable it once
  166.        we have processed all of them to eliminate the whitespace. */
  167.       fprintf (stderr, "%s:%d: extraneous whitespace at end of line\n",
  168.            pip -> pi_fname, pip -> pi_line);
  169. #endif
  170.     }
  171.   while ((endp >= fieldp) && (WHITESPACE (*endp)))
  172.     {
  173.       *endp-- = '\000';
  174.     }
  175. }
  176.  
  177. int
  178. filesize (const char *fname)
  179. {
  180.   struct stat statbuf;
  181.  
  182.   if (stat (fname, &statbuf) == 0)
  183.     {
  184.       return (statbuf.st_size);
  185.     }
  186.   else
  187.     {
  188.       return (0);
  189.     }
  190. }
  191.  
  192. char *
  193. timestamp (const char *fname)
  194. {
  195.   struct stat statbuf;
  196.   struct tm *fdate;
  197.   static char datebuf[64];
  198.   static char *months[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  199.                 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  200.  
  201.   if (stat (fname, &statbuf) != 0)
  202.     {
  203.       return ("??-???-??");
  204.     }
  205.   else
  206.     {
  207.       fdate = localtime (&statbuf.st_mtime);
  208.       if (dosflag)
  209.     {
  210.       sprintf (datebuf, "%02d-%02d-%02d", fdate -> tm_mon + 1,
  211.            fdate -> tm_mday, fdate -> tm_year);
  212.     }
  213.       else
  214.     {
  215.       sprintf (datebuf, "%02d-%3s-%2d", fdate -> tm_mday, 
  216.            months[fdate -> tm_mon], fdate -> tm_year);
  217.     }
  218.       return (datebuf);
  219.     }
  220. }
  221.  
  222. /* Get the basename of a path */
  223.  
  224. const char *
  225. basename (const char *sp)
  226. {
  227.   const char *bname;
  228.  
  229.   /* Look first for typical Unix or AmigaDOS separator, and
  230.      leave bname pointing at the separator. */
  231.  
  232.   bname = strrchr (sp, '/');
  233.  
  234.   /* Look for special AmigaDOS separator */
  235.  
  236. #ifdef __amigados__
  237.   if (bname == NULL)
  238.     {
  239.       bname = strrchr (sp, ':');
  240.     }
  241. #endif
  242.  
  243.   /* If any separator found, skip over it, otherwise the
  244.      basename is just the entire string. */
  245.  
  246.   if (bname == NULL)
  247.     {
  248.       bname = sp;
  249.     }
  250.   else
  251.     {
  252.       bname++;
  253.     }
  254.  
  255.   return (bname);
  256. }
  257.  
  258. /*
  259.  *  Note that dirname is defined such that it *includes* the
  260.  *  separator.  This way you don't need to know whether it 
  261.  *  was a '/' or ':' to reconstruct the full path.  I.E.
  262.  *  %P=%D%B  not %D/%B if '/' or %D%B if ':'
  263.  */
  264.  
  265. const char *
  266. dirname (const char *sp)
  267. {
  268.   char *endp;
  269.   static char buf[256];
  270.  
  271.   strcpy (buf, sp);
  272.  
  273.   /* Look first for typical Unix or AmigaDOS separator */
  274.  
  275.   endp = strrchr (buf, '/');
  276.  
  277.   /* Look for special AmigaDOS separator */
  278.  
  279. #ifdef __amigados__
  280.   if (endp == NULL)
  281.     {
  282.       endp = strrchr (buf, ':');
  283.     }
  284. #endif
  285.  
  286.   /* If there was a separator, set up to zap the next
  287.      character, otherwise the dirname is just the empty
  288.      string. */
  289.  
  290.   if (endp == NULL)
  291.     {
  292.       endp = buf;
  293.     }
  294.   else
  295.     {
  296.       endp++;
  297.     }
  298.   *endp = '\000';
  299.   return ((const char *) buf);
  300. }
  301.  
  302. /*
  303.  *    Given a name of a file that is potentially a product info file,
  304.  *    generate the name of the directory or file that the associated
  305.  *    product is stored in.  By convention, the "stored in" name is
  306.  *    terminated with a '/' if it is a directory.
  307.  *
  308.  *    Normally, the "stored in" name can be generated simply from 
  309.  *    examination of the name of the product info file, such as deriving
  310.  *    "foo/bar/bell.lha" from "foo/bar/bell.lha.pi", or deriving
  311.  *    "foo/bar/bell/" from "foo/bar/bell/Product-Info".
  312.  *
  313.  *    However, because of the braindead naming conventions of MS-DOS,
  314.  *    as a special case for DOS support, the convention of naming the
  315.  *    product info file that goes with another file using the basename
  316.  *    of the file with '.PI' appended, is supported, as long as there
  317.  *    is no ambiguity.  I.E., given "FOO/BAR/BELL.LHA", the associated
  318.  *    product info file is "FOO/BAR/BELL.PI".  In order to discover the
  319.  *    correct "stored in" name, it is necessary to actually test for
  320.  *    the existance of files with specific name patterns and select
  321.  *    the first one that matches.  The algorithm is to use the basename
  322.  *    of the product info file, with each of the following extensions
  323.  *    tested in sequence {LHA, TAR, GZ}.  This testing is only done if
  324.  *    the "-D" option is used.
  325.  *
  326.  *    Returns NULL if the name is not a product info file.
  327.  */
  328.  
  329. char *
  330. stored_in (const char *name)
  331. {
  332.   int length;
  333.   char *namep;
  334.   char *rtnval = NULL;
  335.   char **extp;
  336.   static char stored_in_buf[256];
  337.  
  338.   strcpy (stored_in_buf, name);
  339.   length = strlen (stored_in_buf);
  340.   if ((tolower (stored_in_buf[length - 1]) == 'i') &&
  341.       (tolower (stored_in_buf[length - 2]) == 'p') &&
  342.       (stored_in_buf[length - 3] == '.'))
  343.     {
  344.       if (!dosflag)
  345.     {
  346.       stored_in_buf[length - 3] = '\000';
  347.       rtnval = stored_in_buf;
  348.     }
  349.       else
  350.     {
  351.       for (extp = dosextens; *extp != NULL; extp++)
  352.         {
  353.           strcpy (&stored_in_buf[length - 3], *extp);
  354.           if (filesize (stored_in_buf) != 0)
  355.         {
  356.           rtnval = stored_in_buf;
  357.           break;
  358.         }
  359.         }
  360.     }
  361.     }
  362.   else
  363.     {
  364.       namep = strrchr (stored_in_buf, '/');
  365.       if ((namep != NULL) && (STREQ (namep + 1, "Product-Info")))
  366.     {
  367.       *++namep = '\000';
  368.       rtnval = stored_in_buf;
  369.     }
  370.     }
  371.   if (rtnval != NULL)
  372.     {
  373. #ifdef __amigados__
  374.       /* Convert "/path1/path2/file" to "path1:path2/file" */
  375.       if ((*rtnval == '/') &&
  376.       ((namep = strchr (rtnval + 1, '/')) != NULL))
  377.     {
  378.       rtnval++;
  379.       *namep = ':';
  380.     }
  381. #endif
  382.     }
  383.   return (rtnval);
  384. }
  385.  
  386. int
  387. find_pifiles (const char *name, struct stat *statbuf, int flags)
  388. {
  389.   if (stored_in (name) != NULL)
  390.     {
  391.       printf ("%s\n", name);
  392.     }
  393.   return (0);
  394. }
  395.  
  396. void
  397. copy_out (const char *filename)
  398. {
  399.   int ch;
  400.   FILE *fin;
  401.   char buf[256];
  402.   char *endp;
  403.  
  404.   fin = fopen (filename, "r");
  405.   if (fin != NULL)
  406.     {
  407.       while (fgets (buf, 256, fin) != NULL)
  408.     {
  409.       for (endp = buf; *endp != '\000'; endp++) {;}
  410.       endp--;
  411.       while ((endp >= buf) && (WHITESPACE (*endp)))
  412.         {
  413.           *endp-- = '\000';
  414.         }
  415.       puts (buf);
  416.     }
  417.       fclose (fin);
  418.     }
  419. }
  420.  
  421. int
  422. add_stored_in (const char *name, struct stat *statbuf, int flags)
  423. {
  424.   char *sname;
  425.  
  426.   sname = stored_in (name);
  427.   if (sname != NULL)
  428.     {
  429.       copy_out (name);
  430.       printf (".stored-in\n%s\n", sname);
  431.     }
  432.   return (0);
  433. }
  434.  
  435. void
  436. free_pif (struct pif *pip)
  437. {
  438.   if (pip -> pi_fp != NULL)        fclose (pip -> pi_fp);
  439.   if (pip -> pi_stored_in != NULL)    free (pip -> pi_stored_in);
  440.   if (pip -> pi_address != NULL)    free (pip -> pi_address);
  441.   if (pip -> pi_aminet_dir != NULL)    free (pip -> pi_aminet_dir);
  442.   if (pip -> pi_author != NULL)        free (pip -> pi_author);
  443.   if (pip -> pi_construction != NULL)    free (pip -> pi_construction);
  444.   if (pip -> pi_comment != NULL)    free (pip -> pi_comment);
  445.   if (pip -> pi_contents != NULL)    free (pip -> pi_contents);
  446.   if (pip -> pi_date != NULL)        free (pip -> pi_date);
  447.   if (pip -> pi_described_by != NULL)    free (pip -> pi_described_by);
  448.   if (pip -> pi_description != NULL)    free (pip -> pi_description);
  449.   if (pip -> pi_distribution != NULL)    free (pip -> pi_distribution);
  450.   if (pip -> pi_docs != NULL)        free (pip -> pi_docs);
  451.   if (pip -> pi_email != NULL)        free (pip -> pi_email);
  452.   if (pip -> pi_exectype != NULL)    free (pip -> pi_exectype);
  453.   if (pip -> pi_fax != NULL)        free (pip -> pi_fax);
  454.   if (pip -> pi_fullname != NULL)    free (pip -> pi_fullname);
  455.   if (pip -> pi_installsize != NULL)    free (pip -> pi_installsize);
  456.   if (pip -> pi_keywords != NULL)    free (pip -> pi_keywords);
  457.   if (pip -> pi_locale != NULL)        free (pip -> pi_locale);
  458.   if (pip -> pi_name != NULL)        free (pip -> pi_name);
  459.   if (pip -> pi_phone != NULL)        free (pip -> pi_phone);
  460.   if (pip -> pi_price != NULL)        free (pip -> pi_price);
  461.   if (pip -> pi_reference != NULL)    free (pip -> pi_reference);
  462.   if (pip -> pi_requirements != NULL)    free (pip -> pi_requirements);
  463.   if (pip -> pi_restrictions != NULL)    free (pip -> pi_restrictions);
  464.   if (pip -> pi_run != NULL)        free (pip -> pi_run);
  465.   if (pip -> pi_short != NULL)        free (pip -> pi_short);
  466.   if (pip -> pi_source != NULL)        free (pip -> pi_source);
  467.   if (pip -> pi_submittal != NULL)    free (pip -> pi_submittal);
  468.   if (pip -> pi_tested != NULL)        free (pip -> pi_tested);
  469.   if (pip -> pi_type != NULL)        free (pip -> pi_type);
  470.   if (pip -> pi_version != NULL)    free (pip -> pi_version);
  471.  
  472.   free (pip);
  473. }
  474.  
  475. struct pif *
  476. open_pif (const char *name)
  477. {
  478.   struct pif *pip;
  479.   extern char *malloc ();
  480.   char *stor;
  481.  
  482.   pip = (struct pif *) malloc (sizeof (struct pif));
  483.   if (pip == NULL)
  484.     {
  485.       fprintf (stderr, "pitool: out of virtual memory\n");
  486.       exit (1);
  487.     }
  488.   memset (pip, 0, sizeof (struct pif));
  489.   pip -> pi_fname = name;
  490.   pip -> pi_line = 0;
  491.   pip -> pi_fp = fopen (pip -> pi_fname, "r");
  492.   stor = stored_in (pip -> pi_fname);
  493.   if (stor != NULL)
  494.     {
  495.       pip -> pi_stored_in = strdup (stor);
  496.     }
  497.   if (pip -> pi_fp == NULL)
  498.     {
  499.       perror (pip -> pi_fname);
  500.       free_pif (pip);
  501.       pip = NULL;
  502.     }
  503.   else if (verbose)
  504.     {
  505.       printf ("%s\n", pip -> pi_fname);
  506.     }
  507.   return (pip);
  508. }
  509.  
  510. /* Find next field marker and strip off any whitespace from end of the
  511.    line. */
  512.  
  513. char *
  514. next_field (struct pif *pip)
  515. {
  516.   static char readbuf[256];
  517.   char *bufp;
  518.   
  519.   while (fgets (readbuf, sizeof (readbuf), pip -> pi_fp) != NULL)
  520.     {
  521.       pip -> pi_line++;
  522.       if (readbuf[0] == '.')
  523.     {
  524.       for (bufp = readbuf; *bufp != '\000'; bufp++) {;}
  525.       bufp--;
  526.       while ((bufp >= readbuf) && WHITESPACE (*bufp))
  527.         {
  528.           *bufp-- = '\000';
  529.         }
  530.       return (readbuf);
  531.     }
  532.     }
  533.   return (NULL);
  534. }
  535.  
  536. char *
  537. read_field (struct pif *pip)
  538. {
  539.   static char readbuf[16 * 1024];
  540.   char *sp = readbuf;
  541.   int ch = '\n';    /* Detect '.' if first char read */
  542.   int prevch = 0;
  543.   
  544.   for (;;)
  545.     {
  546.       prevch = ch;
  547.       ch = getc (pip -> pi_fp);
  548.       if (ch == '\n')
  549.     {
  550.       pip -> pi_line++;
  551.     }
  552.       if (ch == '.')
  553.     {
  554.       if (prevch == '\n')
  555.         {
  556.           ungetc (ch, pip -> pi_fp);
  557.           break;
  558.         }
  559.     }
  560.       else if (ch == EOF)
  561.     {
  562.       if (prevch != '\n')
  563.         {
  564.           fprintf (stderr, "%s:%d: does not end with newline\n",
  565.                pip -> pi_fname, pip -> pi_line);
  566.           *sp++ = '\n';
  567.         }
  568.       break;
  569.     }
  570.       *sp++ = ch;
  571.     }
  572.   if (sp > readbuf)
  573.     {
  574.       sp--;
  575.     }
  576.   *sp = '\000';
  577.   stripwhite (pip, readbuf);
  578.   return (readbuf);
  579. }
  580.  
  581. struct pif *
  582. read_pif (const char *name)
  583. {
  584.   struct pif *pip;
  585.   char *fieldname;
  586.   char *rawfield;
  587.   char *temp;
  588.  
  589.   pip = open_pif (name);
  590.   if (pip != NULL)
  591.     {
  592.       while ((fieldname = next_field (pip)) != NULL)
  593.     {
  594.       rawfield = read_field (pip);
  595.       if (STREQ (fieldname + 1, "address"))
  596.         { pip -> pi_address = strdup (rawfield); continue; }
  597.       if (STREQ (fieldname + 1, "aminet-dir"))
  598.         { pip -> pi_aminet_dir = strdup (rawfield); continue; }
  599.       if (STREQ (fieldname + 1, "author"))
  600.         { pip -> pi_author = strdup (rawfield); continue; }
  601.       if (STREQ (fieldname + 1, "construction"))
  602.         { pip -> pi_construction = strdup (rawfield); continue; }
  603.       if (STREQ (fieldname + 1, "comment"))
  604.         { pip -> pi_comment = strdup (rawfield); continue; }
  605.       if (STREQ (fieldname + 1, "contents"))
  606.         { pip -> pi_contents = strdup (rawfield); continue; }
  607.       if (STREQ (fieldname + 1, "date"))
  608.         { pip -> pi_date = strdup (rawfield); continue; }
  609.       if (STREQ (fieldname + 1, "described-by"))
  610.         { pip -> pi_described_by = strdup (rawfield); continue; }
  611.       if (STREQ (fieldname + 1, "description"))
  612.         { pip -> pi_description = strdup (rawfield); continue; }
  613.       if (STREQ (fieldname + 1, "distribution"))
  614.         { pip -> pi_distribution = strdup (rawfield); continue; }
  615.       if (STREQ (fieldname + 1, "docs"))
  616.         { pip -> pi_docs = strdup (rawfield); continue; }
  617.       if (STREQ (fieldname + 1, "email"))
  618.         { pip -> pi_email = strdup (rawfield); continue; }
  619.       if (STREQ (fieldname + 1, "exectype"))
  620.         { pip -> pi_exectype = strdup (rawfield); continue; }
  621.       if (STREQ (fieldname + 1, "fax"))
  622.         { pip -> pi_fax = strdup (rawfield); continue; }
  623.       if (STREQ (fieldname + 1, "fullname"))
  624.         { pip -> pi_fullname = strdup (rawfield); continue; }
  625.       if (STREQ (fieldname + 1, "installsize"))
  626.         { pip -> pi_installsize = strdup (rawfield); continue; }
  627.       if (STREQ (fieldname + 1, "keywords"))
  628.         { pip -> pi_keywords = strdup (rawfield); continue; }
  629.       if (STREQ (fieldname + 1, "locale"))
  630.         { pip -> pi_locale = strdup (rawfield); continue; }
  631.       if (STREQ (fieldname + 1, "name"))
  632.         {
  633.           pip -> pi_name = strdup (rawfield);
  634.           if (strchr (rawfield, ' ') || strchr (rawfield, '\t'))
  635.         {
  636.           fprintf (stderr,
  637.                "%s:%d: '.name' field contains whitespace; use '.fullname' instead\n",
  638.                pip -> pi_fname, pip -> pi_line);
  639.         }
  640.           continue;
  641.         }
  642.       if (STREQ (fieldname + 1, "phone"))
  643.         { pip -> pi_phone = strdup (rawfield); continue; }
  644.       if (STREQ (fieldname + 1, "price"))
  645.         { pip -> pi_price = strdup (rawfield); continue; }
  646.       if (STREQ (fieldname + 1, "reference"))
  647.         { pip -> pi_reference = strdup (rawfield); continue; }
  648.       if (STREQ (fieldname + 1, "requirements"))
  649.         { pip -> pi_requirements = strdup (rawfield); continue; }
  650.       if (STREQ (fieldname + 1, "restrictions"))
  651.         { pip -> pi_restrictions = strdup (rawfield); continue; }
  652.       if (STREQ (fieldname + 1, "run"))
  653.         { pip -> pi_run = strdup (rawfield); continue; }
  654.       if (STREQ (fieldname + 1, "short"))
  655.         {
  656.           pip -> pi_short = strdup (rawfield);
  657.           if (strlen (rawfield) > 40)
  658.         {
  659.           fprintf (stderr,
  660.                "%s:%d: '.short' field > 40 characters\n",
  661.                pip -> pi_fname, pip -> pi_line);
  662.         }
  663.           if ((temp = strchr (rawfield, '\n')) != NULL)
  664.         {
  665.           *temp = '\000';
  666.           fprintf (stderr,
  667.                "%s:%d: '.short' field contains newline\n",
  668.                pip -> pi_fname, pip -> pi_line);
  669.         }
  670.           continue;
  671.         }
  672.       if (STREQ (fieldname + 1, "source"))
  673.         { pip -> pi_source = strdup (rawfield); continue; }
  674.       if (STREQ (fieldname + 1, "submittal"))
  675.         { pip -> pi_submittal = strdup (rawfield); continue; }
  676.       if (STREQ (fieldname + 1, "tested"))
  677.         { pip -> pi_tested = strdup (rawfield); continue; }
  678.       if (STREQ (fieldname + 1, "type"))
  679.         { pip -> pi_type = strdup (rawfield); continue; }
  680.       if (STREQ (fieldname + 1, "version"))
  681.         { pip -> pi_version = strdup (rawfield); continue; }
  682.       fprintf (stderr, "%s:%d: unrecognized field '%s'\n", 
  683.            pip -> pi_fname, pip -> pi_line, fieldname);
  684.     }
  685.       fclose (pip -> pi_fp);
  686.       pip -> pi_fp = NULL;
  687.     }
  688.   if (pip -> pi_name == NULL)
  689.     {
  690.       fprintf (stderr, "%s:%d: missing '.name' field\n", pip -> pi_fname,
  691.            pip -> pi_line);
  692.     }
  693.   if (pip -> pi_short == NULL)
  694.     {
  695.       fprintf (stderr, "%s:%d: missing '.short' field\n", pip -> pi_fname,
  696.            pip -> pi_line);
  697.     }
  698.   return (pip);
  699. }
  700.  
  701. void
  702. fprintf_pif (FILE *fp, struct pif *pip)
  703. {
  704.   char pformat[256];
  705.   char *pformatp = pformat;
  706.   char *formatp = print_format;
  707.   int argc = 0;
  708.   int needspec = 0;
  709.   const char *argv[10];        /* FIXME:  check for overflow */
  710.   char *B_arg;
  711.   char B_argbuf[256];
  712.   static char sizebuf[16];
  713.   static char sizebufKb[16];
  714.  
  715.   while (*formatp != '\000')
  716.     {
  717.       if (needspec)
  718.     {
  719.       switch (*formatp)
  720.         {
  721.         case 'a':        /* Contents of ".author" field. */
  722.           argv[argc++] = pip -> pi_author;
  723.           *pformatp++ = 's';
  724.           formatp++;
  725.           needspec = 0;
  726.           break;
  727.         case 'B':        /* Basename of "stored-in" path */
  728.           B_arg = basename (pip -> pi_stored_in);
  729.           if (*B_arg == '\000')
  730.         {
  731.           strcpy (B_argbuf, pip -> pi_stored_in);
  732.           B_argbuf[strlen (B_argbuf) - 1] = '\000';
  733.           B_arg = basename (B_argbuf);
  734.         }
  735.           argv[argc++] = B_arg;
  736.           *pformatp++ = 's';
  737.           formatp++;
  738.           needspec = 0;
  739.           break;
  740.         case 'D':        /* Dirname of "stored-in" path */
  741.           argv[argc++] = dirname (pip -> pi_stored_in);
  742.           *pformatp++ = 's';
  743.           formatp++;
  744.           needspec = 0;
  745.           break;
  746.         case 'd':        /* contents of ".description" field */
  747.           argv[argc++] = pip -> pi_description;
  748.           *pformatp++ = 's';
  749.           formatp++;
  750.           needspec = 0;
  751.           break;
  752.         case 'F':        /* Contents of ".fullname" or ".name" field. */
  753.           argv[argc++] = pip -> pi_fullname ? pip -> pi_fullname : pip -> pi_name;
  754.           *pformatp++ = 's';
  755.           formatp++;
  756.           needspec = 0;
  757.           break;
  758.         case 'K':        /* "Stored-in" filesize in Kb */
  759.           sprintf (sizebufKb, "%d", filesize (pip -> pi_stored_in) / 1024);
  760.           argv[argc++] = sizebufKb;
  761.           *pformatp++ = 's';
  762.           formatp++;
  763.           needspec = 0;
  764.           break;
  765.         case 'N':        /* Contents of ".name" field. */
  766.           argv[argc++] = pip -> pi_name;
  767.           *pformatp++ = 's';
  768.           formatp++;
  769.           needspec = 0;
  770.           break;
  771.         case 'P':        /* Full "stored-in" path */
  772.           argv[argc++] = pip -> pi_stored_in;
  773.           *pformatp++ = 's';
  774.           formatp++;
  775.           needspec = 0;
  776.           break;
  777.         case 's':        /* "Stored-in" filesize in bytes */
  778.           sprintf (sizebuf, "%d", filesize (pip -> pi_stored_in));
  779.           argv[argc++] = sizebuf;
  780.           *pformatp++ = 's';
  781.           formatp++;
  782.           needspec = 0;
  783.           break;
  784.         case 'S':        /* The ".short" field */
  785.           argv[argc++] = pip -> pi_short ? pip -> pi_short : "<no description avail>";
  786.           *pformatp++ = 's';
  787.           *formatp++;
  788.           needspec = 0;
  789.           break;
  790.         case 'T':
  791.           argv[argc++] = timestamp (pip -> pi_stored_in);
  792.           *pformatp++ = 's';
  793.           formatp++;
  794.           needspec = 0;
  795.           break;
  796.         case 'V':        /* Version */
  797.           argv[argc++] = pip -> pi_version ? pip -> pi_version : "?.?";
  798.           *pformatp++ = 's';
  799.           formatp++;
  800.           needspec = 0;
  801.           break;
  802.         case '%':
  803.           if (*(formatp - 1) != '%')
  804.         {
  805.           fprintf (stderr, "bad -F format string, missing spec\n");
  806.           exit (1);
  807.         }
  808.           /* A '%' can quote the following '%' */
  809.           *pformatp++ = *formatp++;
  810.           needspec = 0;
  811.           break;
  812.         default:
  813.           /* Stuff to print verbatum */
  814.           *pformatp++ = *formatp++;
  815.           break;
  816.         }
  817.     }
  818.       else if (*formatp == '%')
  819.     {
  820.       /* We are not looking for a spec because of a previous '%' */
  821.       needspec++;
  822.       *pformatp++ = *formatp++;
  823.     }
  824.       else if (*formatp == '\\')
  825.     {
  826.       /* Simple '\' evaluation, only single chars now.  FIXME */
  827.       formatp++;
  828.       switch (*formatp)
  829.         {
  830.         case '\\':
  831.           *pformatp++ = '\\'; /* quoted it */
  832.           break;
  833.         case 't':
  834.           *pformatp++ = '\t';
  835.           break;
  836.         case 'n':
  837.           *pformatp++ = '\n';
  838.           break;
  839.         case 'b':
  840.           *pformatp++ = '\b';
  841.           break;
  842.         case 'r':
  843.           *pformatp++ = '\r';
  844.           break;
  845.         case 'f':
  846.           *pformatp++ = '\f';
  847.           break;
  848.         default:
  849.           *pformatp++ = *formatp;
  850.           break;
  851.         }
  852.       formatp++;
  853.     }
  854.       else
  855.     {
  856.       /* stuff that needs no interpretation */
  857.       *pformatp++ = *formatp++;
  858.     }
  859.     }
  860.   *pformatp++ = '\000';
  861.   fprintf (fp, pformat,
  862.        argv[0], argv[1], argv[2], argv[3], argv[4],
  863.        argv[5], argv[6], argv[7], argv[8], argv[9]);
  864. }
  865.  
  866. int
  867. add_files_bbs (const char *name, struct stat *statbuf, int flags)
  868. {
  869.   struct pif *pip;
  870.   char bbsfile[256];
  871.   char *scan;
  872.   FILE *bbsfp;
  873.  
  874.   if (stored_in (name) != NULL)
  875.     {
  876.       pip = read_pif (name);
  877.       if (pip != NULL)
  878.     {
  879.       if (STREQ (bbs_file_name, "-"))
  880.         {
  881.           fprintf_pif (stdout, pip);
  882.         }
  883.       else
  884.         {
  885.           strcpy (bbsfile, name);
  886.           scan = strrchr (bbsfile, '/');
  887.           if (scan != NULL)
  888.         {
  889.           scan++;
  890.           strcpy (scan, bbs_file_name);
  891.           bbsfp = fopen (bbsfile, "a");
  892.           if (bbsfp != NULL)
  893.             {
  894.               fprintf_pif (bbsfp, pip);
  895.               fclose (bbsfp);
  896.             }
  897.         }
  898.         }
  899.       free_pif (pip);
  900.     }
  901.     }
  902.   return (0);
  903. }
  904.  
  905. int
  906. test_pifiles (const char *name, struct stat *statbuf, int flags)
  907. {
  908.   struct pif *pip;
  909.   char bbsfile[256];
  910.   char *scan;
  911.   FILE *bbsfp;
  912.  
  913.   if (stored_in (name) != NULL)
  914.     {
  915.       pip = read_pif (name);
  916.       if (pip != NULL)
  917.     {
  918.       free_pif (pip);
  919.     }
  920.     }
  921.   return (0);
  922. }
  923.  
  924. void
  925. filter_stdin (int (*filter_through) (const char *name, struct stat *statbuf, int flags))
  926. {
  927.   char buf [256];
  928.  
  929.   while (gets (buf) != NULL)
  930.     {
  931.       /* Note that currently only first arg is used. */
  932.       (*filter_through) ((const char *) buf, NULL, 0);
  933.     }
  934. }
  935.  
  936. int
  937. main (argc, argv)
  938. int argc;
  939. char *argv[];
  940. {
  941.   int ch;
  942.   int action;
  943.   int errflg = 0;
  944.   extern int optind;
  945.   extern char *optarg;
  946.  
  947.   while ((ch = getopt (argc, argv, "DF:f:bfhnstv")) != EOF)
  948.     {
  949.       switch (ch)
  950.     {
  951.     case 'D':
  952.       dosflag++;
  953.       break;
  954.     case 'F':
  955.       print_format = optarg;
  956.       break;
  957.     case 'f':
  958.       bbs_file_name = optarg;
  959.       break;
  960.     case 'h':
  961.       break;
  962.     case 'v':
  963.       verbose++;
  964.       break;
  965.     case '?':
  966.       errflg++;
  967.       break;
  968.     default:
  969.       action = ch;
  970.       break;
  971.     }
  972.       if (errflg)
  973.     {
  974.       fprintf (stderr, "unknown arg, use -h for help\n");
  975.       exit (1);
  976.     }
  977.     }
  978.   if (bbs_file_name == NULL)
  979.     {
  980.       bbs_file_name = dosflag ? DOS_BBS_FILE_NAME : AMIGA_BBS_FILE_NAME;
  981.     }
  982.   if (print_format == NULL)
  983.     {
  984.       print_format = dosflag ? DOS_PRINT_FORMAT : AMIGA_PRINT_FORMAT;
  985.     }
  986.   for ( ; optind < argc; optind++)
  987.     {
  988.       if (STREQ (argv[optind], "-"))
  989.     {
  990.       switch (action)
  991.         {
  992.         case 'b':
  993.           filter_stdin (add_files_bbs);
  994.           break;
  995.         case 'n':
  996.           filter_stdin (find_pifiles);
  997.           break;
  998.         case 's':
  999.           filter_stdin (add_stored_in);
  1000.           break;
  1001.         case 't':
  1002.           filter_stdin (test_pifiles);
  1003.           break;
  1004.         default:
  1005.           fprintf (stderr, "unknown action '%c'\n", action);
  1006.           exit (1);
  1007.         }
  1008.     }
  1009.       else
  1010.     {
  1011.       switch (action)
  1012.         {
  1013.         case 'b':
  1014.           ftw ((const char *) argv[optind], add_files_bbs, 30);
  1015.           break;
  1016.         case 'n':
  1017.           ftw ((const char *) argv[optind], find_pifiles, 30);
  1018.           break;
  1019.         case 's':
  1020.           ftw ((const char *) argv[optind], add_stored_in, 30);
  1021.           break;
  1022.         case 't':
  1023.           ftw ((const char *) argv[optind], test_pifiles, 30);
  1024.           break;
  1025.         default:
  1026.           fprintf (stderr, "unknown action '%c'\n", action);
  1027.           exit (1);
  1028.         }
  1029.     }
  1030.     }
  1031.   exit (0);
  1032.   return (0);
  1033. }
  1034.