home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / util / unix / macutil2.sha / macutil / hexbin / hecx.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-05  |  5.3 KB  |  257 lines
  1. #include "hexbin.h"
  2. #ifdef HECX
  3. #include "globals.h"
  4. #include "crc.h"
  5. #include "readline.h"
  6. #include "../util/masks.h"
  7. #include "../util/util.h"
  8. #include "../fileio/machdr.h"
  9. #include "../fileio/wrfile.h"
  10. #include "buffer.h"
  11. #include "printhdr.h"
  12.  
  13. extern void exit();
  14.  
  15. static void do_o_forks();
  16. static long make_file();
  17. static void comp_c_crc();
  18. static void comp_e_crc();
  19. static int comp_to_bin();
  20. static int hex_to_bin();
  21. static int hexit();
  22.  
  23. static int compressed;
  24.  
  25. /* old format -- process .hex and .hcx files */
  26. void hecx(macname, filename)
  27. char *macname, *filename;
  28. {
  29.     int n;
  30.  
  31.     for(n = 0; n < INFOBYTES; n++) {
  32.     info[n] = 0;
  33.     }
  34.     compressed = 0;
  35.     /* set up name for output files */
  36.     if(macname[0] == '\0') {
  37.     /* strip directories */
  38.     macname = search_last(filename, '/');
  39.     if(macname == NULL) {
  40.         macname = filename;
  41.     } else {
  42.         macname++;
  43.     }
  44.  
  45.     /* strip extension */
  46.     n = strlen(macname);
  47.     if(n > 4) {
  48.         n -= 4;
  49.         if(!strncmp(macname + n, ".hex", 4) ||
  50.            !strncmp(macname + n, ".hcx", 4)) {
  51.         macname[n] = '\0';
  52.         }
  53.     }
  54.     }
  55.     n = strlen(macname);
  56.     if(n > F_NAMELEN) {
  57.     n = F_NAMELEN;
  58.     }
  59.     (void)strncpy(mh.m_name, macname, n);
  60.     mh.m_name[n] = '\0';
  61.  
  62.     /* "#TYPEAUTH$flag"  line already read */
  63.     n = strlen(line);
  64.     if(n >= 6 && line[0] == '#' && line[n-5] == '$') {
  65.     if(n >= 10) {
  66.         (void)strncpy(mh.m_type, &line[1], 4);
  67.     }
  68.     if(n >= 14) {
  69.         (void)strncpy(mh.m_author, &line[5], 4);
  70.     }
  71.     (void)sscanf(&line[n-4], "%4hx", &mh.m_flags);
  72.     }
  73.     transname(mh.m_name, trname, n);
  74.     define_name(trname);
  75.     do_o_forks();
  76.     if(listmode) {
  77.     if(!compressed) {
  78.         (void)fprintf(stderr, "This file is in \"hex\" format.\n");
  79.     } else {
  80.         (void)fprintf(stderr, "This file is in \"hcx\" format.\n");
  81.     }
  82.     }
  83.     print_header0(0);
  84.     print_header1(0, 0);
  85.     info[I_NAMEOFF] = n;
  86.     (void)strncpy(info + I_NAMEOFF + 1, mh.m_name, n);
  87.     (void)strncpy(info + I_TYPEOFF, mh.m_type, 4);
  88.     (void)strncpy(info + I_AUTHOFF, mh.m_author, 4);
  89.     put2(info + I_FLAGOFF, (unsigned long)mh.m_flags);
  90.     put4(info + I_DLENOFF, (unsigned long)mh.m_datalen);
  91.     put4(info + I_RLENOFF, (unsigned long)mh.m_rsrclen);
  92.     put4(info + I_CTIMOFF, (unsigned long)mh.m_createtime);
  93.     put4(info + I_MTIMOFF, (unsigned long)mh.m_modifytime);
  94.     print_header2(0);
  95.     end_put();
  96. }
  97.  
  98. static void do_o_forks()
  99. {
  100.     int forks = 0, found_crc = 0;
  101.     unsigned long calc_crc, file_crc;
  102.  
  103.     crc = 0;    /* calculate a crc for both forks */
  104.  
  105.     set_put(0);
  106.     set_put(1);
  107.     while(!found_crc && readline()) {
  108.     if(line[0] == 0) {
  109.         continue;
  110.     }
  111.     if(forks == 0 && strncmp(line, "***COMPRESSED", 13) == 0) {
  112.         compressed++;
  113.         continue;
  114.     }
  115.     if(strncmp(line, "***DATA", 7) == 0) {
  116.         set_put(1);
  117.         mh.m_datalen = make_file(compressed);
  118.         forks++;
  119.         continue;
  120.     }
  121.     if(strncmp(line, "***RESOURCE", 11) == 0) {
  122.         set_put(0);
  123.         mh.m_rsrclen = make_file(compressed);
  124.         forks++;
  125.         continue;
  126.     }
  127.     if(compressed && strncmp(line, "***CRC:", 7) == 0) {
  128.         found_crc++;
  129.         calc_crc = crc;
  130.         (void)sscanf(&line[7], "%lx", &file_crc);
  131.         break;
  132.     }
  133.     if(!compressed && strncmp(line, "***CHECKSUM:", 12) == 0) {
  134.         found_crc++;
  135.         calc_crc = crc & BYTEMASK;
  136.         (void)sscanf(&line[12], "%lx", &file_crc);
  137.         file_crc &= BYTEMASK;
  138.         break;
  139.     }
  140.     }
  141.  
  142.     if(found_crc) {
  143.     verify_crc(calc_crc, file_crc);
  144.     } else {
  145.     (void)fprintf(stderr, "missing CRC\n");
  146. #ifdef SCAN
  147.     do_error("hexbin: missing CRC");
  148. #endif /* SCAN */
  149.     exit(1);
  150.     }
  151. }
  152.  
  153. static long make_file(compressed)
  154. int compressed;
  155. {
  156.     register long nbytes = 0L;
  157.  
  158.     while(readline()) {
  159.     if(line[0] == 0) {
  160.         continue;
  161.     }
  162.     if(strncmp(line, "***END", 6) == 0) {
  163.         break;
  164.     }
  165.     if(compressed) {
  166.         nbytes += comp_to_bin();
  167.     } else {
  168.         nbytes += hex_to_bin();
  169.     }
  170.     }
  171.     return nbytes;
  172. }
  173.  
  174. static void comp_c_crc(c)
  175. unsigned char c;
  176. {
  177.     crc = (crc + c) & WORDMASK;
  178.     crc = ((crc << 3) & WORDMASK) | (crc >> 13);
  179. }
  180.  
  181. static void comp_e_crc(c)
  182. unsigned char c;
  183. {
  184.     crc += c;
  185. }
  186.  
  187. #define SIXB(c) (((c)-0x20) & 0x3f)
  188.  
  189. static int comp_to_bin()
  190. {
  191.     char obuf[BUFSIZ];
  192.     register char *ip = line;
  193.     register char *op = obuf;
  194.     register int n, outcount;
  195.     int numread, incount;
  196.  
  197.     numread = strlen(line);
  198.     outcount = (SIXB(ip[0]) << 2) | (SIXB(ip[1]) >> 4);
  199.     incount = ((outcount / 3) + 1) * 4;
  200.     for(n = numread; n < incount; n++) {  /* restore lost spaces */
  201.     line[n] = ' ';
  202.     }
  203.  
  204.     n = 0;
  205.     while(n <= outcount) {
  206.     *op++ = SIXB(ip[0]) << 2 | SIXB(ip[1]) >> 4;
  207.     *op++ = SIXB(ip[1]) << 4 | SIXB(ip[2]) >> 2;
  208.     *op++ = SIXB(ip[2]) << 6 | SIXB(ip[3]);
  209.     ip += 4;
  210.     n += 3;
  211.     }
  212.  
  213.     for(n = 1; n <= outcount; n++) {
  214.     comp_c_crc((unsigned)obuf[n]);
  215.     put_byte(obuf[n]);
  216.     }
  217.     return outcount;
  218. }
  219.  
  220. static int hex_to_bin()
  221. {
  222.     register char *ip = line;
  223.     register int n, outcount;
  224.     int c;
  225.  
  226.     n = strlen(line);
  227.     outcount = n / 2;
  228.     for(n = 0; n < outcount; n++) {
  229.     c = hexit((int)*ip++);
  230.     comp_e_crc((unsigned)(c = (c << 4) | hexit((int)*ip++)));
  231.     put_byte((char)c);
  232.     }
  233.     return outcount;
  234. }
  235.  
  236. static int hexit(c)
  237. int c;
  238. {
  239.     if('0' <= c && c <= '9') {
  240.     return c - '0';
  241.     }
  242.     if('A' <= c && c <= 'F') {
  243.     return c - 'A' + 10;
  244.     }
  245.  
  246.     (void)fprintf(stderr, "illegal hex digit: %c", c);
  247. #ifdef SCAN
  248.     do_error("hexbin: illegal hex digit");
  249. #endif /* SCAN */
  250.     exit(1);
  251.     /* NOTREACHED */
  252. }
  253. #else /* HECX */
  254. int hecx; /* keep lint and some compilers happy */
  255. #endif /* HECX */
  256.  
  257.