home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / hamradio / 7plus202.zip / 7PL2SRC.LZH / UTILS.C < prev   
C/C++ Source or Header  |  1992-06-11  |  21KB  |  1,122 lines
  1. #include "7plus.h"
  2. #include "globals.h"
  3. #ifdef __unix__
  4.  #include <time.h>
  5.  #ifdef __M_XENIX__
  6.   struct utimbuf {
  7.    time_t actime;
  8.    time_t modtime;
  9.   };
  10.   extern time_t mktime (struct tm *utm);
  11.  #else
  12.   #include <utime.h>
  13.  #endif
  14.  #include <sys/stat.h>
  15. #endif
  16.  
  17. static char no[] = NO, yes[] = YES, always[] = ALWAYS;
  18.  
  19. /*
  20. *** get a line from file. don't care about type of line separator.
  21. ***
  22. ***
  23.  */
  24.  
  25. char *my_fgets (char *string, register n, FILE *rein)
  26. {
  27.   register in, i;
  28.  
  29.   if (feof (rein))
  30.     return (NULL);
  31.  
  32.   i = 0;
  33.   while ((in = fgetc (rein)) != EOF)
  34.   {
  35.     if (in == 0x0d)
  36.     {
  37.       if ((in = fgetc (rein)) != 0x0a)
  38.         if (in != EOF)
  39.           ungetc (in, rein);
  40.       in = 0x0a;
  41.     }
  42.     string[i++] = (char) in;
  43.     if (i == n || in == 0x0a)
  44.       break;
  45.   }
  46.   string[i] = EOS;
  47.   return (string);
  48. } 
  49.  
  50. /*
  51. ***
  52. *** Write a byte to file.
  53. ***
  54.  */
  55.  
  56. int my_putc (int outchar, FILE *out)
  57. {
  58.   register x;
  59.  
  60.   if ((x = putc ((char) outchar, out)) == EOF)
  61.   {
  62.     printf ("\007\nWrite error! Can't continue.\n");
  63.     exit (1);
  64.   }
  65.   return (x);
  66. }
  67.  
  68. /*
  69. *** Get crc and line number from code line.
  70. ***
  71. ***
  72.  */
  73.  
  74. void crc_n_lnum (uint *crc, int *linenumber, char *line)
  75. {
  76.   register ulong cs;
  77.  
  78.   cs = 0xb640L * decode[(byte)line[66]] +
  79.        0xd8L   * decode[(byte)line[65]] +
  80.                  decode[(byte)line[64]];
  81.  
  82.   *linenumber = (int) (cs >> 14);   /* upper 9 bits are the line number */
  83.   *crc = (uint) (cs & 0x3fffL);     /* lower 14 bits are the CRC */
  84. }
  85.  
  86. /*
  87. *** Get crc2 from code line.
  88. ***
  89. ***
  90.  */
  91.  
  92. void crc2 (uint *crc, char *line)
  93. {
  94.  
  95.   *crc = 0xd8 * decode[(byte)line[68]] +
  96.                 decode[(byte)line[67]];
  97. }
  98.  
  99. /*
  100. *** Whip up 2nd CRC
  101. ***
  102. ***
  103.  */
  104.  
  105. void add_crc2 (char *line)
  106. {
  107.   register uint crc;
  108.   register int i;
  109.  
  110.   /* Whip up 2nd CRC */
  111.   crc = 0;
  112.   for (i=66;i>-1;i--)
  113.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte) line[i]);
  114.   crc &= 0x7fff;
  115.  
  116.   i = 67;
  117.   line[i++] = code[crc % 0xd8];
  118.   line[i++] = code[crc / 0xd8];
  119.   line[i] = EOS;
  120. }
  121.  
  122. /*
  123. *** mini-crc for header. safe enough...
  124. ***
  125. ***
  126.  */
  127.  
  128. int mcrc (char *line, int flag)
  129. {
  130.   register int i, j;
  131.   register uint crc;
  132.   char test[3], *p;
  133.  
  134.   sprintf (test, "\xb0\xb1");
  135.  
  136.   if ((p = strstr (line, test)) == NULL)
  137.     return (0);
  138.  
  139.   j = (int) (p - line) + 4;
  140.  
  141.   for (i=crc=0; i<j; i++)
  142.     crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  143.   crc %= 216;
  144.   if (!flag)
  145.   {
  146.     if (crc == (uint) decode[(byte)line[j]])
  147.       return (1);
  148.     else
  149.       return (0);
  150.   }
  151.   else
  152.     line[j] = code[(byte)crc];
  153.  
  154.   return (crc);
  155. }
  156.  
  157. /*
  158. *** read info from indexfile
  159. ***
  160. ***
  161.  */
  162.  
  163. int read_index (FILE *ifile, struct m_index *index)
  164. {
  165.   int j;
  166.   ulong i, begin, end;
  167.  
  168.   #ifdef _CHSIZE_OK
  169.    fseek (ifile, -4L, SEEK_END);
  170.    fseek (ifile, read_ulong (ifile), SEEK_SET);
  171.   #endif
  172.  
  173.   /* clear index */
  174.   for (j = 0;j < 8160; j++)
  175.     index->lines_ok[j] = 0;
  176.  
  177.   my_fgets (index->full_name, 12, ifile);
  178.   if (strcmp(index->full_name, "7PLUS-index\x0a"))
  179.   {
  180.     printf ("\007No index info found.\n");
  181.     return (1);
  182.   }
  183.   my_fgets (index->filename, 13, ifile);
  184.   index->filename[(int)strlen(index->filename)-1] = EOS;
  185.   my_fgets (index->full_name, 257, ifile);
  186.   index->full_name[(int)strlen(index->full_name)-1] = EOS;
  187.   index->timestamp = read_ulong (ifile);
  188.   index->splitsize = read_uint  (ifile);
  189.   index->lines_left= (long) read_ulong (ifile);
  190.  
  191.   /* convert defect list into bitvektor */
  192.   while (1==1)
  193.   {
  194.     if ((begin = read_ulong (ifile)) == 0xffffffffUL)
  195.       break;
  196.     end = read_ulong (ifile);
  197.  
  198.     if ((end>>4) > (begin>>4))
  199.       for (i = begin;i < ((begin |15UL) + 1UL); i++)
  200.         index->lines_ok[(int)i>>4] |= (1U << (uint)(i&15UL));
  201.     else
  202.     {
  203.       for (i = begin;i < end; i++)
  204.         index->lines_ok[(int)i>>4] |= (1U << (uint)(i&15UL));
  205.       continue;
  206.     }
  207.  
  208.     for (i = (begin>>4) +1; i < (end>>4); i++)
  209.       index->lines_ok[(int)i] = 0xffffU;
  210.  
  211.     if (end&15)
  212.       for (i = end &0xfffffff0UL; i < end; i++)
  213.         index->lines_ok[(int)i>>4] |= (1U << (uint)(i&15UL));
  214.   }
  215.   index->length = read_ulong (ifile);
  216.  
  217.   #ifdef _CHSIZE_OK
  218.    fseek (ifile, 0UL, SEEK_SET);
  219.   #endif
  220.  
  221.   return (0);
  222. }
  223.  
  224. /*
  225. *** write info to indexfile
  226. ***
  227. ***
  228.  */
  229.  
  230. int write_index (FILE *ifile, struct m_index *index, int flag)
  231. {
  232.   int j, part, prevpart, lines;
  233.   ulong i, begin, end;
  234.  
  235.   part = prevpart = lines = 0;
  236.   begin = end = 0UL;
  237.  
  238.   if (!flag)
  239.   {
  240.     #ifdef _CHSIZE_OK
  241.      fseek (ifile, index->length, SEEK_SET);
  242.     #endif
  243.  
  244.     fprintf (ifile, "7PLUS-index\n");
  245.     fprintf (ifile, "%s\n", index->filename);
  246.     fprintf (ifile, "%s\n", index->full_name);
  247.     write_ulong (ifile, index->timestamp);
  248.     write_uint  (ifile, index->splitsize);
  249.     write_ulong (ifile, (ulong) index->lines_left);
  250.   }
  251.   /* convert bitvektor into defect list */
  252.   i = 0UL;
  253.   j = 0;
  254.   while (1==1)
  255.   {
  256.     while (j < 8160 && !(index->lines_ok[j] &(uint)(1 << (i & 15UL))))
  257.     {
  258.       if (!(i&15UL) && index->lines_ok[j] == 0U)
  259.       {
  260.         j++;
  261.         i = (ulong) j<<4;
  262.       }
  263.       else
  264.       {
  265.         i++;
  266.         j = (int) i>>4;
  267.       }
  268.     }
  269.  
  270.     if (j == 8160)
  271.       break;
  272.  
  273.     begin = i;
  274.  
  275.     do
  276.     {
  277.       if (!(i&15UL) && index->lines_ok[j] == 0xffffU)
  278.       {
  279.         j++;
  280.         i = (ulong) j<<4;
  281.       }
  282.       else
  283.       {
  284.         i++;
  285.         j = (int) i>>4;
  286.       }
  287.     }
  288.     while (j < 8160 && (index->lines_ok[j] &(uint)(1 << (i & 15UL))));
  289.  
  290.     end = i;
  291.  
  292.     if (!flag)
  293.     {
  294.       write_ulong (ifile, begin);
  295.       write_ulong (ifile, end);
  296.     }
  297.     else
  298.     {
  299.       for (i = begin; i < end; i++)
  300.       {
  301.         part = (int) i / index->splitsize +1;
  302.         if (part != prevpart)
  303.         {
  304.           if (prevpart)
  305.           {
  306.             if (!(lines % 18) && lines)
  307.               fprintf (ifile, delimit);
  308.             lines = 0;
  309.             fprintf (ifile, "FFF%s", delimit);
  310.           }
  311.           prevpart = part;
  312.           fprintf (ifile, "%02X%s", part, delimit);
  313.         }
  314.  
  315.         lines++; /* Number of missing or corrupted lines in this part. */
  316.         fprintf (ifile, "%03X", i % index->splitsize);
  317.         if (!(lines % 18) && lines)
  318.         {
  319.           fprintf (ifile, delimit);
  320.           lines = 0;
  321.         }
  322.         else
  323.           fprintf (ifile, " ");
  324.       }
  325.     }
  326.   }
  327.  
  328.   if (!flag)
  329.   {
  330.     write_ulong (ifile, 0xffffffffUL);
  331.     write_ulong (ifile, index->length);
  332.     #ifdef _CHSIZE_OK
  333.      chsize (fileno (ifile), ftell (ifile));
  334.     #endif
  335.   }
  336.   else
  337.   {
  338.     if (!(lines % 18) && lines)
  339.       fprintf (ifile, delimit);
  340.     fprintf (ifile, "FFF%s", delimit);
  341.   }
  342.   return (0);
  343. }
  344.  
  345. /*
  346. *** Reading/writing unsigned long(32bit)/int(16)
  347. ***
  348. ***
  349.  */
  350.  
  351. ulong read_ulong (FILE *in)
  352. {
  353.   return ((ulong)fgetc (in)       +
  354.          ((ulong)fgetc (in) <<8 ) +
  355.          ((ulong)fgetc (in) <<16) +
  356.          ((ulong)fgetc (in) <<24));
  357. }
  358.  
  359. uint read_uint (FILE *in)
  360. {
  361.   return ((uint)fgetc (in)       +
  362.          ((uint)fgetc (in) <<8 ));
  363. }
  364.  
  365. void write_ulong (FILE *out, ulong val)
  366. {
  367.   my_putc ((int) (val     &0xffUL), out);
  368.   my_putc ((int)((val>>8 )&0xffUL), out);
  369.   my_putc ((int)((val>>16)&0xffUL), out);
  370.   my_putc ((int)((val>>24)&0xffUL), out);
  371. }
  372.  
  373. void write_uint (FILE *out, uint val)
  374. {
  375.   my_putc ((int) (val    &0xffU), out);
  376.   my_putc ((int)((val>>8)&0xffU), out);
  377. }
  378.  
  379. /*
  380. *** read a file, search for s1, calculate CRC until s2 is found.
  381. *** flag == 1: compare calculated an read CRC.
  382. *** flag == 0: insert CRC into file.
  383.  */
  384.  
  385. int crc_file (char *file, char *s1, char *s2, int flag)
  386. {
  387.   char line[81], *p;
  388.   uint crc, cs;
  389.   int i, j, k;
  390.   FILE *in;
  391.  
  392.   crc = cs = 0;
  393.   p = NULLCP;
  394.  
  395.   if (!(in = fopen (file, OPEN_RANDOM_BINARY)))
  396.   {
  397.     printf (cant, file);
  398.     return (2);
  399.   }
  400.  
  401.   i = (int) strlen (s1);
  402.   k = (int) strlen (s2);
  403.  
  404.   j = 1;
  405.  
  406.   do
  407.   {
  408.     if (my_fgets (line, 80, in) == NULL)
  409.       break;
  410.  
  411.     j = strncmp (line, s1, i);
  412.   }
  413.   while (j);
  414.  
  415.   if (j)
  416.     p = s1;
  417.   else
  418.   {
  419.     p = s2;
  420.     do
  421.     {
  422.       for (i=0;i!=(int)strlen(line);i++)
  423.         crc = crctab[crc>>8] ^ (((crc&255)<<8) | (byte)line[i]);
  424.  
  425.       j = strncmp (line, s2, k);
  426.  
  427.       if (!j)
  428.         continue;
  429.  
  430.       if (my_fgets (line, 80, in) == NULL)
  431.         break;
  432.     }
  433.     while (j);
  434.   }
  435.  
  436.   if (j)
  437.   {
  438.     printf ("\n\007Can't calculate CRC\n");
  439.     printf ("String '%s' not found in '%s'.\nBreak.\n", p, file);
  440.     return (7);
  441.   }
  442.  
  443.   /* evaluate CRC */
  444.   if (flag)
  445.   {
  446.     my_fgets (line, 80, in);
  447.     fclose (in);
  448.     if (!line || strncmp ("CRC ", line, 4))
  449.     {
  450.       printf ("\n'%s': no CRC found.\n(File may be corrupted or from version \
  451. earlier than 7PLUS v1.5)\n", file);
  452.       return (17);
  453.     }
  454.     cs = get_hex (line+4);
  455.     if (cs == crc)
  456.       return (0);
  457.  
  458.     printf ("\007\n'%s' is corrupted. Break.\n", file);
  459.     return (7);
  460.   }
  461.  
  462.   /* insert CRC into file */
  463.   fseek (in, ftell (in), SEEK_SET);
  464.   fprintf (in, "CRC %04X", crc);
  465.   fclose (in);
  466.  
  467.   return (0);
  468. }
  469.  
  470. /*
  471. *** Copy a file.
  472. ***
  473. ***
  474.  */
  475.  
  476. int copy_file (char *to, char *from, ulong timestamp)
  477. {
  478.   FILE *_from, *_to;
  479.   int _char, stat;
  480.  
  481.   stat = 0;
  482.  
  483.   _from = fopen (from, OPEN_READ_BINARY);
  484.   _to   = fopen (to,   OPEN_WRITE_BINARY);
  485.  
  486.   while ((_char = getc (_from)) != EOF)
  487.     if ((stat = putc (_char, _to)) == EOF)
  488.       break;
  489.  
  490.   fclose (_from);
  491.  
  492.  #ifdef _UXTIMESTAMP
  493.   fclose (_to);
  494.   if (timestamp)
  495.     set_uxfiletime (to, timestamp);
  496.  #else
  497.   if (timestamp)
  498.     set_filetime (_to, timestamp);
  499.  
  500.   fclose (_to);
  501.  #endif
  502.  
  503.   if (stat == EOF)
  504.   {
  505.     printf ("\007\nFatal error. Can't write '%s'! Break.\n", to);
  506.     exit (1);
  507.   }
  508.   return (0);
  509. }
  510.  
  511. /*
  512. *** Replace one file with another
  513. ***
  514. ***
  515.  */
  516.  
  517. void replace (char *old, char *new, ulong timestamp)
  518. {
  519.   unlink (old);
  520.  
  521.   if (rename (new, old))
  522.   {
  523.     copy_file (old, new, timestamp);
  524.     unlink (new);
  525.   }
  526.   else
  527.   {
  528.     if (timestamp)
  529.     {
  530.      #ifdef _UXTIMESTAMP
  531.       set_uxfiletime (old, timestamp);
  532.      #else
  533.       FILE *_file;
  534.  
  535.       _file = fopen (old, OPEN_APPEND_BINARY);
  536.       set_filetime (_file, timestamp);
  537.       fclose (_file);
  538.      #endif
  539.     }
  540.   }
  541. }
  542.  
  543. /*
  544. *** Kill all files that aren't needed any more
  545. ***
  546. ***
  547.  */
  548.  
  549. void kill_em (char *name, char *inpath, char *one, char *two,
  550.               char *three, char *four, char *five)
  551. {
  552.   char *p, newname[MAXPATH];
  553.   int i, j, k, len;
  554.  
  555.   k = 0;
  556.  
  557.   for (i = 0; i < 5; i++)
  558.   {
  559.     if (!i)
  560.       printf ("\n");
  561.  
  562.     switch (i)
  563.     {
  564.       case 0:  p = one;
  565.                break;
  566.       case 1:  p = two;
  567.                break;
  568.       case 2:  p = three;
  569.                break;
  570.       case 3:  p = four;
  571.                break;
  572.       case 4:  p = five;
  573.  
  574.       default: p = NULLCP;
  575.     }
  576.     if (!p)
  577.      break;
  578.  
  579.     len = strlen(p);
  580.  
  581.     for (j = 1; j <256; j++)
  582.     {
  583.       if (len == 3)
  584.         sprintf (newname, "%s%s.%s", inpath, name, p);
  585.       else
  586.         sprintf (newname, "%s%s.%s%02x", inpath, name, p, j);
  587.  
  588.       if (unlink (newname))
  589.         break;
  590.  
  591.       k++;
  592.  
  593.       printf ("Deleting: %s\r", newname);
  594.       fflush (stdout);
  595.  
  596.       if (len == 3)
  597.         break;
  598.     }
  599.   }
  600.   if (k)
  601.     printf ("\n");
  602. }
  603.  
  604. /*
  605. ***
  606. ***
  607. ***
  608.  */
  609.  
  610. void kill_dest (FILE *in, FILE *out, char *name)
  611. {
  612.     if (out)
  613.       fclose (out);
  614.     if (in)
  615.       fclose (in);
  616.     if (*name)
  617.       unlink (name);
  618. }
  619.  
  620. /*
  621. ***
  622. ***  test if a file exists at all
  623. ***
  624.  */
  625.  
  626. int test_exist (char *filename)
  627. {
  628.   FILE *in = NULLFP;
  629.  
  630.   if ((in = fopen (filename, OPEN_READ_TEXT)) != NULLFP)
  631.   {
  632.     fclose (in);
  633.     return (0);
  634.   }
  635.   return (1);
  636. }
  637.  
  638.  
  639. /*
  640. ***  test if outputfile already exists. prompt for overwrite or
  641. ***  new name.
  642. ***
  643.  */
  644.  
  645. int test_file (FILE *in, char *destnam, int flag, int namsize)
  646. {
  647.    FILE *out;
  648.    int  i, ret;
  649.  
  650.    ret = 0;
  651.  
  652.    if (noquery)
  653.      return (ret);
  654.  
  655.    /* Loop as long as file can be opened. */
  656.    while ((out = fopen (destnam, OPEN_READ_BINARY)) != NULLFP)
  657.    {
  658.      ret = 1;
  659.      printf ("\007\nOutputfile '%s' already exists, overwrite? [y/n/a] ", destnam);
  660.      do
  661.      {
  662.        i = toupper (getch());
  663.  
  664.        if (i == 'N')
  665.        {
  666.          if (flag)
  667.          {
  668.            printf ("%s\n\nEnter new name (max %d chars)\n", no, namsize);
  669.            printf ("or simply press ENTER to break : ");
  670.            if (namsize == 12)
  671.              strlwr (destnam);
  672.            scanf ("%s", destnam);
  673.            destnam[namsize] = EOS;
  674.          }
  675.          else
  676.            *destnam = EOS;
  677.          if (!strlen (destnam))
  678.          {
  679.            if (!flag)
  680.              printf ("%s\n", no);
  681.            printf ("Break.\n");
  682.            if (in)
  683.              fclose (in);
  684.            exit (10);
  685.          }
  686.          i = 0xff; /* indicate, that new name has been specified */
  687.        }
  688.      }
  689.      while (i != 'Y' && i != 'A' && i != 0xff);
  690.  
  691.      if (i != 0xff)
  692.      {
  693.        if (i == 'A')
  694.        {
  695.          printf ("%s\n", always);
  696.          noquery = 1;
  697.        }
  698.        else
  699.          printf ("%s\n", yes);
  700.      }
  701.      printf ("\n");
  702.  
  703.      fclose (out);
  704.  
  705.      if (i != 0xff)
  706.        break;
  707.    }
  708.  
  709.    return (ret);
  710. }
  711.  
  712.  
  713. /*
  714. *** initialize decoding table
  715. ***
  716. ***
  717.  */
  718.  
  719. void init_decodetab (void)
  720. {
  721.   register i;
  722.   register byte j;
  723.  
  724.   for (i = 0; i < 256; i++)
  725.     decode[i] = 255;
  726.  
  727.   j = 0;
  728.   for (i = 0x21; i < 0x2a; i++)
  729.     decode[i] = j++;
  730.  
  731.   for (i = 0x2b; i < 0x7f; i++)
  732.     decode[i] = j++;
  733.  
  734.   for (i = 0x80; i < 0x91; i++)
  735.     decode[i] = j++;
  736.  
  737.   decode[0x92] = j++;
  738.  
  739.   for (i = 0x94; i < 0xfd; i++)
  740.     decode[i] = j++;
  741. }
  742.  
  743. /*
  744. *** initialize encoding table
  745. ***
  746. ***
  747.  */
  748.  
  749. void init_codetab (void)
  750. {
  751.   register byte i, j;
  752.  
  753.   j = 0;
  754.  
  755.   for (i = 0x21; i < 0x2a; i++, j++)
  756.     code[j] = i;
  757.  
  758.   for (i = 0x2b; i < 0x7f; i++, j++)
  759.     code[j] = i;
  760.  
  761.   for (i = 0x80; i < 0x91; i++, j++)
  762.     code[j] = i;
  763.  
  764.   code[j++] = 146;
  765.  
  766.   for (i = 0x94; i < 0xfd; i++, j++)
  767.     code[j] = i;
  768. }
  769.  
  770. /*
  771. *** Tnx to DC4OX.
  772. ***
  773. *** calculate CRC-table
  774. ***
  775.  */
  776.  
  777. void init_crctab (void)
  778. {
  779.   uint m, n, r, mask;
  780.  
  781.   static uint bitrmdrs[] = { 0x9188,0x48C4,0x2462,0x1231,
  782.                              0x8108,0x4084,0x2042,0x1021 };
  783.  
  784.   for (n = 0; n < 256; ++n)
  785.   {
  786.     for (mask = 0x0080, r = 0, m = 0; m < 8; ++m, mask >>= 1)
  787.       if (n & mask)
  788.         r = bitrmdrs[m] ^ r;
  789.     crctab[n] = r;
  790.   }
  791. }
  792.  
  793. /*
  794. *** Create a MSDOS/ATARI compatible filename.
  795. ***
  796. ***
  797.  */
  798.  
  799. void build_DOS_name (char *name)
  800. {
  801.   char tmp[MAXFNAME];
  802.   register i, j;
  803.  
  804.   i = j = 0;
  805.  
  806.   strcpy (tmp, name);
  807.   strlwr (tmp);
  808.  
  809.   if (*tmp)
  810.   {
  811.     do
  812.     {
  813.       tmp[i] &= 127;
  814.       if (strchr (" <>=,;:*?&[]()/.\\\"~+@", tmp[i]) == NULL)
  815.         name[j++] = tmp[i];
  816.     }
  817.     while (tmp[++i]);
  818.  
  819.     name[j] = EOS;
  820.   }
  821. }
  822.  
  823. #ifdef _UXTIMESTAMP
  824.  /*
  825.   * these functions have to convert a MS/DOS time to a UNIX time
  826.   * and vice versa.
  827.   * here comes the MS/DOS time structure
  828.   */
  829.  struct ftime
  830.  {
  831.    unsigned  ft_tsec  : 5;   /* 0..59 /2 (!) */
  832.    unsigned  ft_min   : 6;   /* 0..59 */
  833.    unsigned  ft_hour  : 5;   /* 0..23 */
  834.    unsigned  ft_day   : 5;   /* 1..31 */
  835.    unsigned  ft_month : 4;   /* 1..12 */
  836.    unsigned  ft_year  : 7; /* Year minus 1980 */
  837.  };
  838.  
  839.  /*
  840.   * Get UNIX file's timestamp and package it into a 32-bit word (MS_DOS-format)
  841.   */
  842.  ulong get_uxfiletime (char *filename)
  843.  {
  844.    time_t atime;
  845.    struct ftime fti;
  846.    ulong *retval = (ulong *) &fti;
  847.    struct tm *utm;
  848.    struct stat fst;
  849.  
  850.    *retval = 0UL;
  851.  
  852.    /* get UNIX file status */
  853.    if (stat (filename, &fst) == 0)
  854.    {
  855.       /* get time of last modification and convert it to MS/DOS time */
  856.      utm = gmtime (&fst.st_mtime);
  857.  
  858.      if (utm)
  859.      {
  860.        fti.ft_tsec  = utm->tm_sec / 2;
  861.        fti.ft_min   = utm->tm_min;
  862.        fti.ft_hour  = utm->tm_hour;
  863.        fti.ft_day   = utm->tm_mday;
  864.        fti.ft_month = utm->tm_mon + 1;
  865.        fti.ft_year  = utm->tm_year - 80;
  866.        return (*retval);
  867.      }
  868.    }
  869.  
  870.    /* error exit */
  871.    printf ("\007\nCan't get file's timestamp!\n");
  872.    return (*retval);
  873.  }
  874.  
  875.  /*
  876.   * Set UNIX file's timestamp
  877.   */
  878.  void set_uxfiletime (char *filename, ulong ftimestamp)
  879.  {
  880.    time_t atime;
  881.    struct utimbuf utim;
  882.    struct ftime *fti;
  883.    struct tm utm;
  884.  
  885.    /* convert MS/DOS ftimestamp to UNIX atime */
  886.    fti = (struct ftime *) &ftimestamp;
  887.    utm.tm_sec   = fti->ft_tsec * 2;
  888.    utm.tm_min   = fti->ft_min;
  889.    utm.tm_hour  = fti->ft_hour;
  890.    utm.tm_mday  = fti->ft_day;
  891.    utm.tm_mon   = fti->ft_month - 1;
  892.    utm.tm_year  = fti->ft_year + 80;
  893.    utm.tm_wday  = utm.tm_yday  =  utm.tm_isdst = 0;
  894.    atime = mktime (&utm);
  895.  
  896.    if (atime != -1)
  897.    {
  898.      /* set access time and modification time */
  899.      utim.actime = atime;
  900.      utim.modtime = atime;
  901.      if (utime (filename, &utim) >= 0)
  902.        return;
  903.    }
  904.  
  905.    /* error exit */
  906.    printf ("\007\nCan't set file's timestamp!");
  907.    return;
  908.  }
  909. #else /* not UNIX */
  910.  /*
  911.  *** Get file's timestamp and package it into a 32-bit word (MS_DOS-format)
  912.  ***
  913.  ***
  914.   */
  915.  ulong get_filetime (FILE *_file)
  916.  {
  917.  #ifdef _TIMESTAMP
  918.    ulong    ftimestamp;
  919.  
  920.    if (getftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  921.      printf ("\007\nCan't get file's timestamp!\n");
  922.  
  923.   #ifdef __TOS__
  924.    ftimestamp = swapl(ftimestamp);
  925.   #endif
  926.  
  927.    return (ftimestamp);
  928.  #else
  929.    /* This is the case with the AMIGA at this time */
  930.    printf ("\007\nWARNING: Function get_filetime() not yet implemented on this system!!\n");
  931.    return (0UL);
  932.  #endif _TIMESTAMP
  933.  }
  934.  
  935.  /*
  936.  *** Set file's timestamp
  937.  ***
  938.  ***
  939.   */
  940.  void set_filetime (FILE *_file, ulong ftimestamp)
  941.  {
  942.  #ifdef _TIMESTAMP
  943.  
  944.   #ifdef __TOS__
  945.    ftimestamp = swapl(timestamp);
  946.   #endif
  947.  
  948.    if (setftime (fileno(_file), (struct ftime *)&ftimestamp) == EOF)
  949.      printf ("\007\nCan't set file's timestamp!");
  950.  
  951.  #else
  952.    /* This is the case with the AMIGA at this time */
  953.    printf ("\007\nWARNING: Function set_filetime() not yet implemented on this system!!\n");
  954.  #endif _TIMESTAMP
  955.  }
  956. #endif
  957.  
  958. /*
  959. *** get_hex: some compilers have real big trouble when reading hex values from
  960. ***          a file with fscanf() that have leading zeros! e.g. 00A will be
  961. ***          read as two separate values (0 and A)! grr!!
  962. ***          get_hex skips all leading zeros to eliminate the problem.
  963. ***
  964.  */
  965.  
  966. uint get_hex (char *hex)
  967. {
  968.   register i = 0;
  969.   uint   ret = 0;
  970.  
  971.   while (hex[i] == '0')
  972.     i++;
  973.   sscanf(hex+i, "%x", &ret);
  974.   return (ret);
  975. }
  976.  
  977.  
  978. #ifdef _FNSPLIT
  979. /*
  980. ***       filenamesplit
  981. ***       (by DL1MEN, taken from SP-ST, modified for portability)
  982. ***
  983. ***       split filename up into drive, path, name and extension.
  984. ***
  985.  */
  986.  
  987. void fnsplit(char *pth, char *dr, char *pa, char *fn, char *ft)
  988. {
  989.   char drv[MAXDRIVE], pat[MAXDIR], fna[MAXFILE], fty[MAXEXT], tmp[MAXPATH];
  990.   char *p;
  991.  
  992.   strcpy(tmp,pth);
  993.  
  994.   if ((p = strchr(tmp,':')) != NULL)
  995.   {
  996.     *p++ = EOS;
  997.     strcpy(drv,tmp);
  998.   }
  999.   else
  1000.   {
  1001.     p = tmp;
  1002.     drv[0] = EOS;
  1003.   }
  1004.   if ((pth = strrchr(p, PATHCHAR)) != NULL)
  1005.   {
  1006.     *pth++ = EOS;
  1007.     strcpy(pat,p);
  1008.   }
  1009.   else
  1010.   {
  1011.     pth = p;
  1012.     pat[0] = EOS;
  1013.   }
  1014.   if ((p = strchr(pth,'.')) != NULL)
  1015.   {
  1016.     strcpy(fty,p);
  1017.     fty[MAXEXT-1] = EOS;
  1018.     *p = EOS;
  1019.   }
  1020.   else
  1021.     fty[0] = EOS;
  1022.  
  1023.   strcpy(fna,pth);
  1024.   fna[MAXFILE-1] = EOS;
  1025.  
  1026.   if (dr)
  1027.   {
  1028.     strcpy(dr,drv);
  1029.     if (drv[0])
  1030.       strcat(dr,":");
  1031.   }
  1032.   if (pa)
  1033.   {
  1034.     strcpy(pa,pat);
  1035.     if (pat[0])
  1036.       strcat(pa, PATHSEP);
  1037.   }
  1038.   if (fn)
  1039.     strcpy(fn,fna);
  1040.   if (ft)
  1041.    strcpy(ft,fty);
  1042. }
  1043. #endif /** _FNSPLIT **/
  1044.  
  1045. #ifdef _ICMP
  1046. /* The following functions are unfortunately not avialable on all compilers */
  1047.  
  1048. /*
  1049. *** strupr - convert string to upper case.
  1050. ***
  1051. ***
  1052.  */
  1053.  
  1054. char *strupr (char *string)
  1055. {
  1056.   char *strcnvt (char *string, int flag);
  1057.  
  1058.   return (strcnvt (string, 1));
  1059. }
  1060.  
  1061. /*
  1062. *** strlwr - convert string to lower case.
  1063. ***
  1064. ***
  1065.  */
  1066.  
  1067. char *strlwr (char *string)
  1068. {
  1069.   char *strcnvt (char *string, int flag);
  1070.  
  1071.   return (strcnvt (string, 0));
  1072. }
  1073.  
  1074. /*
  1075. *** strcnvt - convert string to upper (flag == 1) or lower (flag == 0) case.
  1076. ***
  1077. ***
  1078.  */
  1079.  
  1080. char *strcnvt (char *string, int flag)
  1081. {
  1082.   register i = 0;
  1083.  
  1084.   while (string[i])
  1085.   {  
  1086.     string[i] = (flag)?toupper (string[i]):tolower (string[i]);
  1087.     i++;
  1088.   }
  1089.  
  1090.   return (string);
  1091. }
  1092.  
  1093. /*
  1094. *** stricmp - same as strcmp(), but ignores case.
  1095. *** s1 and s2 are not modified.
  1096. ***
  1097.  */
  1098.  
  1099. int stricmp (const char *s1, const char *s2)
  1100. {
  1101.   return (strnicmp (s1, s2, (size_t) 80));
  1102. }
  1103.  
  1104. /*
  1105. *** strnicmp - same as strncmp(), but ignores case.
  1106. *** s1 and s2 are not modified.
  1107. ***
  1108.  */
  1109.  
  1110. int strnicmp (const char *s1, const char *s2, size_t n)
  1111. {
  1112.   char _s1[81], _s2[81];
  1113.  
  1114.   strncpy (_s1, s1, 80);
  1115.   strncpy (_s2, s2, 80);
  1116.   strupr (_s1);
  1117.   strupr (_s2);
  1118.  
  1119.   return (strncmp (_s1, _s2, n));
  1120. }
  1121. #endif /** _ICMP **/
  1122.