home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit70 / ckltxt.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  5KB  |  182 lines
  1. #include <system_io_constants.h>
  2. #define CV char_varying
  3.  
  4. extern void s$error (short *status, CV(32) *caller, CV(256) *msg);
  5.  
  6. extern void s$attach_port (CV(32) *port_name, CV(256)* path,
  7.     short *hold, short *port_id, short *status);
  8.  
  9. extern void s$open (short *port_id, short *organization,
  10.     short *max_rec_len, short *io_type, short *locking_type,
  11.     short *access_mode, CV(32) *index_name, short *status);
  12.  
  13. extern void s$detach_port (short *port_id, short *status);
  14.  
  15. extern void s$close (short *port_id, short *status);
  16.  
  17. extern void s$seq_read (short *port_id, short *buff_size,
  18.     short *rec_len, void *buffer, short *status);
  19.  
  20. extern void s$seq_write (short *port_id, short *rec_length,
  21.     void *buffer, short *status);
  22.  
  23. extern void s$parse_command (CV(32) *caller, short *status, ... );
  24.  
  25. static CV(32) caller = "ckltxt";
  26. static CV(40) in_def = "binary_file:pathname.pm,required";
  27. static CV(40) out_def = "text_file:pathname,required";
  28. static CV(3)  end_def = "end";
  29. static CV(32) in_port_name = "in_port";
  30. static CV(32) out_port_name = "out_port";
  31. static CV(32) index_name = "";
  32. static char   digits[16] = "0123456789ABCDEF";
  33.  
  34. void ckltxt (void)
  35. {
  36.   short status;
  37.   short buff_len;
  38.   short rec_len;
  39.   char  buff[4096];
  40.   char  txt_buff[80];
  41.   int   buff_ndx;
  42.   int   txt_ndx;
  43.   CV(256) in_path;
  44.   CV(256) out_path;
  45.   short   in_port;
  46.   short   out_port;
  47.   short   flag;
  48.   short   io_type;
  49.   short   lock_type;
  50.   short   access;
  51.   short   org;
  52.   unsigned byte;
  53.   int      null_cnt;
  54.   char    null_buff[4];
  55.  
  56.   s$parse_command (&caller, &status,
  57.                    &in_def, &in_path,
  58.                    &out_def, &out_path,
  59.                    &end_def);
  60.  
  61.   if (status)
  62.     return;
  63.  
  64.   flag = 0;
  65.   s$attach_port (&in_port_name, &in_path, &flag, &in_port, &status);
  66.   if (status)
  67.   {
  68.     s$error (&status, &caller, &in_path);
  69.     return;
  70.   }
  71.  
  72.   org = FIXED_FILE;
  73.   buff_len = sizeof buff;
  74.   io_type = INPUT_TYPE;
  75.   lock_type = READ_LOCK;
  76.   access = SEQUENTIAL_MODE;
  77.   s$open (&in_port, &org, &buff_len, &io_type, &lock_type, &access,
  78.           &index_name, &status);
  79.   if (status)
  80.   {
  81.     s$error (&status, &caller, &in_path);
  82.     return;
  83.   }
  84.  
  85.   flag = 0;
  86.   s$attach_port (&out_port_name, &out_path, &flag, &out_port, &status);
  87.   if (status)
  88.   {
  89.     s$error (&status, &caller, &out_path);
  90.     return;
  91.   }
  92.  
  93.   org = STREAM_FILE;
  94.   buff_len = sizeof buff;
  95.   io_type = OUTPUT_TYPE;
  96.   lock_type = WRITE_LOCK;
  97.   access = SEQUENTIAL_MODE;
  98.   s$open (&out_port, &org, &buff_len, &io_type, &lock_type, &access,
  99.           &index_name, &status);
  100.   if (status)
  101.   {
  102.     s$error (&status, &caller, &out_path);
  103.     return;
  104.   }
  105.  
  106.   while (1)
  107.   {
  108.     s$seq_read (&in_port, &buff_len, &rec_len, &buff, &status);
  109.     if (status)
  110.       break;
  111.  
  112.     null_cnt = 0;
  113.  
  114.     /* process one record in the source file */
  115.     for (buff_ndx = 0; buff_ndx < sizeof buff; buff_ndx = buff_ndx + 32)
  116.     {
  117.       flag = 0; /* have not seen non-null byte yet */
  118.       for (txt_ndx = 0; txt_ndx < 64; txt_ndx = txt_ndx + 2)
  119.       {
  120.         byte = buff[buff_ndx + (txt_ndx / 2)];
  121.         if (byte != 0)
  122.           flag = 1; /* found a non-null byte in record */
  123.         txt_buff[txt_ndx] = digits[byte / 16];
  124.         txt_buff[txt_ndx+1] = digits[byte % 16];
  125.       }
  126.  
  127.       if (flag == 0)
  128.       {
  129.         null_cnt = null_cnt + 1;
  130.       }
  131.  
  132.       if ((null_cnt > 0) && ((buff_ndx + 32 == sizeof buff) || (flag == 1)))
  133.       {
  134.         null_buff[0] = 'Z';
  135.         byte = null_cnt;
  136.         null_buff[1] = digits[byte / 16];
  137.         null_buff[2] = digits[byte % 16];
  138.         rec_len = 3;
  139.         s$seq_write (&out_port, &rec_len, &null_buff, &status);
  140.         if (status)
  141.         {
  142.           s$error (&status, &caller, &out_path);
  143.  
  144.           s$close (&in_port, &status);
  145.           s$detach_port (&in_port, &status);
  146.  
  147.           s$close (&out_port, &status);
  148.           s$detach_port (&out_port, &status);
  149.  
  150.           return;
  151.         }
  152.         null_cnt = 0;
  153.       }
  154.  
  155.       if (flag == 1)
  156.       {
  157.         rec_len = 64;
  158.         s$seq_write (&out_port, &rec_len, &txt_buff, &status);
  159.         if (status)
  160.         {
  161.           s$error (&status, &caller, &out_path);
  162.  
  163.           s$close (&in_port, &status);
  164.           s$detach_port (&in_port, &status);
  165.  
  166.           s$close (&out_port, &status);
  167.           s$detach_port (&out_port, &status);
  168.  
  169.           return;
  170.         } /* if status != 0 */
  171.       } /* if flag is 1 */
  172.     } /* for buff_ndx ... */
  173.   } /* while (1) */
  174.  
  175.   s$close (&in_port, &status);
  176.   s$detach_port (&in_port, &status);
  177.  
  178.   s$close (&out_port, &status);
  179.   s$detach_port (&out_port, &status);
  180.  
  181. }
  182.