home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume11 / netdata / diskdump.c next >
Encoding:
C/C++ Source or Header  |  1987-10-03  |  4.5 KB  |  233 lines
  1. /* diskdump.c:    convert    text file to CMS disk dump format */
  2. /*        output is a stream of 80-byte card images */
  3.  
  4. /* Author:   Gary Mills    <mills@cc.uofm.cdn>          */
  5. /*            <mills@uofmcc.bitnet>          */
  6.  
  7. /* Compilation Switches:                  */
  8. /*    MVS:    Waterloo C v1.3    for MVS              */
  9. /*    default:  Amdahl UTS Unix System V          */
  10.  
  11. /* #define MVS       1 */
  12. #include <stdio.h>
  13. #ifdef    MVS
  14. #define    ATE(c)    (c)
  15. #else
  16. extern char atetab[128];    /* ASCII to EBCDIC translation table */
  17.  
  18. #define    ATE(c)    atetab[c]
  19. #endif
  20. #define    NUL    '\0'
  21. #define    SIZBUF    256
  22. #define    CMSV    struct cmsrec
  23. CMSV
  24.     {
  25.     char dd_id[1];    /* 0x02    */
  26.     char dd_cms[3];    /* "CMS" */
  27.     char dd_fmt[1];    /* record format */
  28.     char dd_data[50];    /* text    */
  29.     char dd_blk[2];    /* block count */
  30.     char dd_fn[8];    /* file    name */
  31.     char dd_ft[8];    /* file    type */
  32.     char dd_fm[3];    /* file    mode */
  33.     char dd_seq[4];    /* sequence */
  34.     };
  35.  
  36. static char    inbuf[SIZBUF];
  37. static CMSV    rec;
  38. static int    recn, blkn;
  39. static int    datax;
  40. static FILE    *ofile;
  41.  
  42. main(argc, argv) int argc; char    **argv;
  43.     {
  44.     int    n, num,    max;
  45.     char *inpt;
  46.     FILE *ifile;
  47.     char c;
  48.     char *fname, *ftype, *pgm;
  49.  
  50.     ifile = stdin;
  51.     ofile = stdout;
  52.     fname = "mailer";
  53.     ftype = "mail";
  54.     pgm    = *argv++;
  55.     --argc;
  56.     while ( argc )
  57.     {
  58.     if ( **argv == '-' )
  59.         {
  60.         c =    tolower( (*argv)[1] );
  61.         ++argv;
  62.         --argc;
  63.         if ( argc )
  64.         {
  65.         --argc;
  66.         if ( c == 'n' )
  67.             fname = *argv++;
  68.         else if    ( c == 't' )
  69.             ftype = *argv++;
  70.         else
  71.             {
  72.             ++argc;
  73.             break;
  74.             }
  75.         }
  76.         else
  77.         {
  78.         ++argc;
  79.         break;
  80.         }
  81.         }
  82.     else
  83.         {
  84.         if ( ( ifile = fopen(*argv,    "r") ) == NULL )
  85.         {
  86.         fprintf(stderr,    "%s: cannot open %s\n",    pgm, *argv);
  87.         return(1);
  88.         }
  89.         --argc;
  90.         break;
  91.         }
  92.     }
  93.     if ( argc )
  94.     {
  95.     fprintf(stderr,    "usage:    %s [-n name -t type file]\n", pgm);
  96.     return(1);
  97.     }
  98. #ifdef    MVS
  99.     ofile = fopen("SYSUT2 ( bin", "w");
  100. #endif
  101.     num    = max =    0;
  102.     iniout(fname, ftype);
  103.     while ( n =    igets(ifile) )
  104.     {
  105.     ++num;
  106.     while (    n > 1 && inbuf[n-1] == ' ' )
  107.         --n;
  108.     inbuf[n] = NUL;
  109.     if ( n > max )
  110.         max    = n;
  111.     inpt = inbuf;
  112.     oput(n/256);
  113.     oput(n&255);
  114.     while (    n = *inpt++ )
  115.         {
  116.         oput( ATE(n) );
  117.         }
  118.     }
  119.     finout(num,    max);
  120.     if ( ifile != stdin    )
  121.     fclose(ifile);
  122.     return 0;
  123.     }
  124.  
  125. /* get input line, expanding tabs and padding null lines */
  126. igets(fp) FILE *fp;
  127.     {
  128.     int    c, col;
  129.     col    = 0;
  130.     while ( ( c    = getc(fp) ) !=    EOF )
  131.     {
  132.     if ( c == '\t' )
  133.         do
  134.         inbuf[col++] = ' ';
  135.         while ( col    < SIZBUF-1 && col % 8 );
  136.     else if    ( c == '\n' )
  137.         {
  138.         if ( col ==    0 )
  139.         inbuf[col++] = ' ';
  140.         break;
  141.         }
  142.     else
  143.         {
  144.         inbuf[col++] = c;
  145.         }
  146.     if ( !(    col < SIZBUF-1 ) )
  147.         break;
  148.     }
  149.     inbuf[col] = NUL;
  150.     return col;
  151.     }
  152.  
  153. /* initialize output */
  154. iniout(sn, st) char *sn, *st;
  155.     {
  156.     recn = blkn    = 1;
  157.     datax = 0;
  158.     rec.dd_id[0] = 0x02;
  159.     mncopy(rec.dd_cms, "CMS", 3);
  160.     rec.dd_fmt[0] = ATE('V');
  161.     memset(rec.dd_data,    0, 50);
  162.     mhalf(rec.dd_blk, blkn);
  163.     memset(rec.dd_fn, ATE(' '),    19);
  164.     mncopy(rec.dd_seq, "0001", 4);
  165.     mncopy(rec.dd_fn, sn, 8);
  166.     mncopy(rec.dd_ft, st, 8);
  167.     mncopy(rec.dd_fm, "A1", 3);
  168.     }
  169.  
  170. /* finalize output */
  171. finout(n, m) int n, m;
  172.     {
  173.     oflush();
  174.     oflush();
  175.     rec.dd_fmt[0] = ATE('N');
  176.     mhalf(&rec.dd_data[0], n+1);    /* write pointer (number) */
  177.     mhalf(&rec.dd_data[2], 1);        /* read    pointer    (number) */
  178.     mncopy(&rec.dd_data[4], "A1", 2);    /* file    mode */
  179.     mhalf(&rec.dd_data[6], n);        /* item    count (number) */
  180.     rec.dd_data[10] = ATE('V');        /* variable flag */
  181.     mhalf(&rec.dd_data[14], m);        /* max item length */
  182.     mhalf(&rec.dd_data[16], blkn);    /* number of blocks */
  183.     mhalf(&rec.dd_data[26], blkn);    /* alternate number of blocks */
  184.     mhalf(&rec.dd_data[30], n);        /* alternate item count    */
  185.     oflush();
  186.     }
  187.  
  188. /* add a byte to output    */
  189. oput(c)    char c;
  190.     {
  191.     rec.dd_data[datax++] = c;
  192.     if ( datax >= 50 )
  193.     {
  194.     oflush();
  195.     datax =    0;
  196.     }
  197.     }
  198.  
  199. /* write and re-initialize record */
  200. oflush()
  201.     {
  202.     int    n, r;
  203.     for    ( n = 0; n < 80; ++n )
  204.     putc(rec.dd_id[n], ofile);
  205.     memset(rec.dd_data,    0, 50);
  206.     if ( recn %    16 == 0    )
  207.     ++blkn;
  208.     ++recn;
  209.     mhalf(rec.dd_blk, blkn);
  210.     r =    recn;
  211.     for    ( n = 3; n >= 0; --n )
  212.     {
  213.     rec.dd_seq[n] =    ATE(r %    10 + '0');
  214.     r = r /    10;
  215.     }
  216.     }
  217.  
  218. /* copy    string to memory in upper case,    not including NUL */
  219. mncopy(s1, s2, n) char *s1, *s2; int n;
  220.     {
  221.     while ( --n    >= 0 &&    *s2 )
  222.     *s1++ =    ATE( toupper(*s2++) );
  223.     }
  224.  
  225. /* copy    two-byte integer to memory */
  226. mhalf(s, n) char *s; int n;
  227.     {
  228.     s[0] = n/256;
  229.     s[1] = n&255;
  230.     }
  231.  
  232. /**/
  233.