home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 228_01 / msweep.c < prev    next >
Text File  |  1987-07-31  |  15KB  |  831 lines
  1. /*
  2. HEADER:         CUGXXX;
  3. TITLE:          MS-DOS file utility;
  4. DATE:           6-2-85;
  5. DESCRIPTION:    MS-DOS file utility based on CP/M NSWEEP;
  6. KEYWORDS:       File organizer, file utility;
  7. FILENAME:       MSWEEP.C;
  8. WARNINGS:       None;
  9. AUTHORS:        Ferdinand Knerlich;
  10. COMPILER:       DeSmet C;
  11. REFERENCES:     US-DISK 1308;
  12. ENDREF
  13. */
  14. /* mswp  ver. 1.00  release prototype     6-2-85
  15.  
  16.      ms-dos file manipulation utility
  17.      based on the cp/m nsweep program
  18.  
  19.      written by ferdinand knerlich, 6-2-85
  20.  
  21. */
  22.  
  23.  
  24. #define SP 32
  25. #define CR 13
  26. #define DC3 19
  27. #define EOF -1
  28. #define ERR -1
  29. #define unsn unsigned
  30.  
  31. struct {
  32.   char dta_reserved[21];
  33.   char dta_attribute;
  34.   short int dta_time;
  35.   short int dta_date;
  36.   long int dta_file_size;
  37.   char dta_name[13];
  38.   } DTA;
  39.  
  40. struct d_entry{
  41.   char      e_attribute;
  42.   short int  e_time;
  43.   short int  e_date;
  44.   long int  e_file_size;
  45.   char      e_name[13];
  46.   char e_tag;
  47.   int e_num;
  48.   } entry[500];
  49.  
  50. int entries;
  51. int num;
  52. int fil1,fd1,fd2;
  53. char e_buf[40];
  54. char f_buf[40];
  55. char dest_buf[40];
  56.  
  57. char files[] = "*.*";
  58. char drv[5] = " :";
  59. char ddrv[5] = " ";
  60. int long_format = 0;
  61. int time_sort = 0;
  62. int reverse_order = 0;
  63. int single_column = 0;
  64.  
  65. int showhide = 0;
  66. char volume[13];
  67.  
  68. unsn avail,total,sectors,bytes;
  69.  
  70. main(argc, argv)
  71.   short int argc; char *argv[];
  72.  
  73. {
  74.   char devarg[85];
  75.   char fname[20];
  76.   int c,d,tag,prpt;
  77.   int xit,j,lncnt,def_drv;
  78.   long int tag_tot,totu,tota;
  79.   char fc,nc,cur_dsk;
  80.  
  81.   char tag,prpt;
  82.   char ver;
  83.  
  84.   /* set the Data Transfer Address to the local block */
  85. #asm
  86.   mov     dx, offset DTA_
  87.   mov     ah, 01AH      ; set disk transfer address
  88.   int     21H
  89. #
  90.  
  91.   scr_clr();
  92.   scr_rowcol(0,0);
  93.  
  94.   printf("\n* msweep file utility *  ver 1.00  6-2-85  ferdinand knerlich\n");
  95.   printf("            [press '?' key for help : 'X' key to eXit]");
  96.  
  97.   entries = xit = num = 0;
  98.  
  99.   ver = 0;
  100.  
  101.   def_drv = (drv[0] = cur_drv()) - 'A';
  102.  
  103.  
  104.   strcat(devarg,files);
  105.  
  106.   if (argc > 1)
  107.   {
  108.     drv[0] = toupper(argv[1][0]);
  109.   }
  110.  
  111.  
  112.   tag_tot = 0;
  113.  
  114.   login(drv[0]);
  115.  
  116.   while(!(xit))
  117.   {
  118.  
  119.     if(entries > 0) display_e(num);
  120.     else printf("\nno files\n");
  121.  
  122.     fc = tolower(ci()); if (!fc) nc = tolower(ci());
  123.  
  124.     switch(fc) {
  125.  
  126.       case SP: case CR : /* forward */
  127.  
  128.         if (num > entries-2) {
  129.           num = 0;
  130.           co('\n'); }
  131.         else num++;
  132.  
  133.         break;
  134.       case 'a': /* retag */
  135.         for( j=0; j<=entries;j++)
  136.         {
  137.           if(entry[j].e_tag == 1)
  138.           {   entry[j].e_tag = 2;
  139.               tag_tot += entry[j].e_file_size;
  140.               fmtebuf(j);
  141.               printf("\n %14s %6D retagged",
  142.               e_buf,
  143.               tag_tot);
  144.           }
  145.         }
  146.         break;
  147.  
  148.       case 'b': /* back one */
  149.  
  150.         if (num < 1) {
  151.           num = entries-1;
  152.           co('\n'); }
  153.         else num--;
  154.  
  155.         break;
  156.  
  157.       case 'c': /* copy */
  158.  
  159.         printf("to drive ? ");
  160.         do
  161.           (c=toupper(getchar()));
  162.         while (!(c >= 'A' && c <= 'Z' ));
  163.  
  164.         ddrv[0] = c; ddrv[1] = ':'; ddrv[2] = '\0';
  165.  
  166.         fmtebuf(num);
  167.  
  168.         cope(num);
  169.  
  170.         break;
  171.  
  172.       case 'd': /* delete */
  173.         printf(" really (y/n) ? ");
  174.         c=toupper(getchar());
  175.  
  176.         if(c=='Y')
  177.         {
  178.           fmtebuf(num);
  179.           del(e_buf,num);
  180.         }
  181.         break;
  182.  
  183.       case 'e': /* erase t/u */
  184.  
  185.         tag = 0;
  186.         printf("\ntagged or untagged (t/u) ? ");
  187.           tag = toupper(getchar());
  188.  
  189.         if (tag)
  190.         {
  191.           printf("\nprompt (y/n) ? ");
  192.             prpt = toupper(getchar());
  193.             if (prpt != 'N') prpt = 'Y';
  194.  
  195.           for( j=0; j<=(entries-1);j++)
  196.           {
  197.             if(entry[j].e_tag == 2 &&  tag=='T')
  198.             {
  199.             tag_tot -= entry[j].e_file_size;
  200.             entry[j].e_tag = 1;
  201.  
  202.             fmtebuf(j);
  203.             if (prpt == 'Y')
  204.             {
  205.               printf("\ndelete %14s (y/n) ? ",e_buf);
  206.               c=toupper(getchar());
  207.  
  208.               if(c=='Y')
  209.               {
  210.               printf("\ndeleting %14s",e_buf);
  211.               del(e_buf,j);
  212.               j--;
  213.               }
  214.             }
  215.             else {
  216.                    printf("\ndeleting %14s",e_buf);
  217.                    del(e_buf,j);
  218.                    j--;
  219.                  }
  220.             }
  221.             else if(entry[j].e_tag != 2 &&  tag=='U')
  222.             {
  223.             fmtebuf(j);
  224.             if (prpt == 'Y')
  225.             {
  226.               printf("\ndelete %14s (y/n) ? ",e_buf);
  227.               c=toupper(getchar());
  228.  
  229.               if(c=='Y')
  230.               {
  231.                 printf("\ndeleting %14s",e_buf);
  232.                 del(e_buf,j);
  233.                 j--;
  234.               }
  235.             }
  236.             else {
  237.                    printf("\ndeleting %14s",e_buf);
  238.                    del(e_buf,j);
  239.                    j--;
  240.                  }
  241.  
  242.              }
  243.  
  244.           }
  245.         }
  246.  
  247.         break;
  248.  
  249.       case 'f': /* find */
  250.  
  251.         break;
  252.       case 'g': /* chg attributes */
  253.  
  254.         break;
  255.  
  256.       case 'l': /* log new dir */
  257.         printf(" drive ? ");
  258.         do
  259.           (c=toupper(getchar()));
  260.         while (!(c >= 'A' && c <= 'Z' ));
  261.  
  262.         drv[0] = c ;
  263.  
  264.         login(drv[0]);
  265.  
  266.         tag_tot = 0;
  267.         break;
  268.  
  269.       case 'm': /* mass file copy */
  270.  
  271.         printf("to drive ? ");
  272.         do
  273.           (c=toupper(getchar()));
  274.         while (!(c >= 'A' && c <= 'Z' ));
  275.  
  276.         ddrv[0] = c; ddrv[1] = ':'; ddrv[2] = '\0';
  277.  
  278.         tag = 0;
  279.         printf("\ntagged or untagged (t/u) ? ");
  280.           tag = toupper(getchar());
  281.  
  282.         if (tag)
  283.         {
  284.           printf("\nprompt (y/n) ? ");
  285.             prpt = toupper(getchar());
  286.             if (prpt != 'N') prpt = 'Y';
  287.  
  288.           for( j=0; j<=(entries-1) ;j++)
  289.           {
  290.             if(entry[j].e_tag == 2 &&  tag=='T')
  291.             {
  292.             tag_tot -= entry[j].e_file_size;
  293.             entry[j].e_tag = 1;
  294.  
  295.             fmtebuf(j);
  296.             if (prpt == 'Y')
  297.             {
  298.               printf("\ncopy %14s (y/n) ? ",e_buf);
  299.               c=toupper(getchar());
  300.  
  301.               if(c=='Y') cope(j);
  302.             }
  303.             else cope(j);
  304.             }
  305.             else if(entry[j].e_tag != 2 &&  tag=='U')
  306.             {
  307.             fmtebuf(j);
  308.             if (prpt == 'Y')
  309.             {
  310.               printf("\ncopy %14s (y/n) ? ",e_buf);
  311.               c=toupper(getchar());
  312.  
  313.               if(c=='Y') cope(j);
  314.             }
  315.             else cope(j);
  316.  
  317.              }
  318.  
  319.           }
  320.         }
  321.  
  322.         break;
  323.  
  324.       case 'r': /* rename */
  325.         if(get_f(fname))
  326.         {
  327.           fmtebuf(num);
  328.           if(rename(e_buf,fname) != -1)
  329.           {
  330.             printf(" rename successful !\n");
  331.             strcpy(entry[num].e_name,fname);
  332.  
  333.           }
  334.           else printf(" error, not renamed \n");
  335.         }
  336.  
  337.         break;
  338.       case 's': /* stats */
  339.  
  340.         cur_dsk = cur_drv();
  341.  
  342.         printf(" drive ? ");
  343.         do
  344.           (c=toupper(getchar()));
  345.         while (!(c >= 'A' && c <= 'Z' ));
  346.  
  347.  
  348.         chg_drv( (int)c - 'A');
  349.  
  350.         totu = tota = avail = total = sectors = bytes = 0;
  351.  
  352.         free_drv(0);
  353.  
  354.         totu = ((long)total - (long)avail) * (long)sectors * (long)bytes;
  355.         tota = (long)avail * (long)sectors * (long)bytes;
  356.  
  357.  
  358.         printf("\n\ndrive %c: has %8D used / %8D free \n",
  359.                c,
  360.                totu,
  361.                tota );
  362.  
  363.         chg_drv( (int)cur_dsk - 'A' );
  364.  
  365.         break;
  366.  
  367.       case 't': /* tag file */
  368.         if( (entry[num].e_tag==0) || (entry[num].e_tag==1) )
  369.         {
  370.           entry[num].e_tag = 2;
  371.           tag_tot += entry[num].e_file_size;
  372.           printf(" %6D ",tag_tot);
  373.         }
  374.         else if( entry[num].e_tag==2 )
  375.           printf(" %6D",tag_tot);
  376.  
  377.         if (num > entries-2)
  378.         {
  379.           num = 0;
  380.           co('\n');
  381.         }
  382.         else num++;
  383.  
  384.         break;
  385.  
  386.       case 'u': /* untag file */
  387.         if( entry[num].e_tag==2 )
  388.         {
  389.           entry[num].e_tag = 0;
  390.           tag_tot -= entry[num].e_file_size;
  391.           printf(" %6D ",tag_tot);
  392.         }
  393.         else if(( entry[num].e_tag==0 ) || ( entry[num].e_tag==1) )
  394.           printf(" %6D",tag_tot);
  395.  
  396.         if (num > entries-2)
  397.         {
  398.           num = 0;
  399.           co('\n');
  400.         }
  401.         else num++;
  402.  
  403.         break;
  404.  
  405.       case 'v': /* view file */
  406.  
  407.         fmtebuf(num);
  408.  
  409.         if (strlen(drv)>1)
  410.         { strcpy(f_buf,drv);
  411.           strcat(f_buf,e_buf);}
  412.         else strcpy(f_buf,e_buf);
  413.  
  414.         scr_clr();
  415.         scr_rowcol(0,0);
  416.  
  417.         if (!(fil1 = fopen(f_buf,"r")))
  418.         {
  419.           printf("\nopen error\n");
  420.           break;
  421.         }
  422.       printf("Press 'S' to freeze/unfreeze display and 'X' to quit view.\n");
  423.  
  424.         putchar('\n');putchar('\n');
  425.         while ((c=fgetc(fil1)) != EOF && d != 'x')
  426.         {
  427.           d=tolower(scr_csts());
  428.           if (d=='s') while(!scr_csts());
  429.           putchar(c);
  430.         }
  431.         d=' ';
  432.         putchar('\n');
  433.         fclose(fil1);
  434.         break;
  435.  
  436.       case 'w': /* wildcard tag */
  437.  
  438.         break;
  439.  
  440.       case 'q':case 'x': /* exit */
  441.         xit = 1;
  442.         break;
  443.  
  444.       case 'y': /* set verifY on */
  445.         ver = 1 - ver;
  446.         ver = set_ver(ver);
  447.         printf("\n\nverify is now: ");
  448.         (ver ? printf("on\n") : printf("off\n"));
  449.         break;
  450.  
  451.       case '?': /* display help file */
  452.  
  453. scr_clr();
  454. scr_rowcol(0,0);
  455.  
  456. printf("\n\n* msweep file utility *  ver 1.00  6-2-85  ferdinand knerlich\n");
  457. printf("\nms-dos file manipulation utility command summary\n");
  458. printf("\nA = retAg file     ");
  459. printf("\nB = Back one file  ");
  460. printf("\nC = Copy one file  ");
  461. printf("\nD = Delete one file  ");
  462. printf("\nE = Erase (t/u) files");
  463. printf("\nL = Login new drive");
  464. printf("\nM = Mass copy (t/u) files");
  465. printf("\nQ = Quit to dos");
  466. printf("\nR = Rename one file");
  467. printf("\nT = Tag one file (t)");
  468. printf("\nU = Untag one file (u)");
  469. printf("\nV = View one file ");
  470. printf("\nX = eXit to dos");
  471. printf("\nY = toggle verifY  ");
  472. printf("\nSPACE or RETURN = forward one file");
  473. printf("\n? = display this summary\n");
  474.  
  475.    }
  476.  }
  477.    chg_drv(def_drv);
  478.    exit(0);
  479. }
  480.  
  481. int find_first(ptr)
  482.   char *ptr; {
  483.  
  484. #asm
  485.   mov     dx,[bp+4]    ; ptr
  486.   mov     cx,  0FFH
  487.   mov     ah, 04EH
  488.   int     21H
  489.   mov     ax,0
  490.   jc    ff_over
  491.   inc     ax
  492. ff_over:
  493.   pop     bp
  494.   ret
  495. #
  496.   }
  497.  
  498. int find_next() {
  499.  
  500. #asm
  501.   mov     ah, 04FH      ; find next
  502.   int     21H
  503.   mov     ax,0
  504.   jc    fn_over
  505.   inc     ax
  506. fn_over:
  507.   pop     bp
  508.   ret
  509. #
  510.   }
  511.  
  512. int set_ver(on)
  513. int on;
  514. {
  515.  
  516. #asm
  517.  
  518.   mov     dl,0
  519.   mov     al,[bp+4]    ; set ax to on
  520.  
  521.   mov     ah,02EH      ; toggle verify
  522.   int     21H
  523.  
  524.   mov     ah,54H
  525.   int     21H
  526. #
  527. }
  528.  
  529.  
  530. int opposite(val)
  531.   int val; {
  532.  
  533.   if (reverse_order)
  534.     return -val;
  535.   return val;
  536.   }
  537.  
  538.  
  539. int comp(ptr1, ptr2)
  540.   struct d_entry *ptr1, *ptr2; {
  541.   long *time1, *time2;
  542.   int val;
  543.  
  544.   val = 0;
  545.   if (time_sort) {
  546.     time1 = &ptr1->e_time;
  547.     time2 = &ptr2->e_time;
  548.     if (*time1 > *time2) val = -1;
  549.     else if (*time1 < *time2) val = 1;
  550.     return opposite(val);
  551.     }
  552.   else {
  553.     return opposite(strcmp(ptr1->e_name, ptr2->e_name, 13));
  554.     }
  555.   }
  556.  
  557. fmtebuf(i)
  558. int i;
  559. {
  560.  
  561. *e_buf = '\0';
  562. strcat(e_buf, entry[i].e_name);
  563. strcat(e_buf, "                   ");
  564. e_buf[14] = '\0';
  565.  
  566. }
  567.  
  568. cur_drv()    /* GET THE CURRENT DRIVE SELECTED  "A","B", ETC... */
  569. {
  570. #asm
  571.     mov    ah,19h
  572.     int    21h
  573.     mov    ah,0
  574.     add    al,'A'
  575. #
  576. }
  577.  
  578. chg_drv(d)
  579. int d;
  580. {
  581. #asm
  582.  
  583.   mov  dl,byte [bp+4]
  584.   mov  ah,0EH
  585.   int  21H
  586. #
  587. }
  588.  
  589. free_drv(device)
  590.     int device; {
  591.  
  592. #asm
  593.     mov        dl, byte [bp+4]     ; device
  594.     mov        ah, 36H
  595.     int        21H
  596.     cmp        AX,0FFFFH
  597.     jne        over
  598.     mov        DX,0FFFFH            ; return -1 if bad device
  599.     pop        bp
  600.     ret
  601. over:
  602.     mov        word avail_,bx
  603.     mov        word total_,dx
  604.     mov        word sectors_,ax
  605.     mov        word bytes_,cx
  606. #
  607.     }
  608.  
  609.  
  610. int del(ptr,numb)
  611.   char *ptr;
  612.   int numb;
  613. {
  614. int i;
  615.  
  616. #asm
  617.   mov     dx,[bp+4]    ; ptr
  618.   mov     ah, 041H
  619.   int     21H
  620. #
  621.  
  622. if(numb+1 >= entries) num--;
  623. else{
  624.   for(i=numb+1;i<entries; i++)
  625.   {
  626.    entry[i-1].e_attribute    =  entry[i].e_attribute;
  627.    entry[i-1].e_time        =  entry[i].e_time;
  628.    entry[i-1].e_date        =  entry[i].e_date;
  629.    entry[i-1].e_file_size    =  entry[i].e_file_size;
  630.    strcpy(entry[i-1].e_name,entry[i].e_name);
  631.    entry[i-1].e_tag        =  entry[i].e_tag;
  632.    entry[i-1].e_num        =  entry[i].e_num-1;
  633.  
  634.   }
  635. }
  636.   entries--;
  637. }
  638.  
  639. get_f(name)
  640. char name[];
  641. {
  642.   int i,c_cnt,flg;
  643.   char c;
  644.  
  645.   flg = 1;
  646.   while(flg)
  647.   {
  648.     puts("filename ? :");
  649.     gets(name);
  650.  
  651.     for(i=0;(name[i]=(toupper(name[i]))) ;i++);
  652.  
  653.     if (name[0] == SP || name[0]==CR || name[0]=='\0') break;
  654.     c_cnt = strlen(name);
  655.     if(c_cnt>12) puts("\nfilename too long\n");
  656.     else if(c_cnt == 12 && name[8] != '.')
  657.        puts("\nfilename too long\n");
  658.     else  flg = 0;
  659.  
  660.   }
  661.   return(1);
  662. }
  663.  
  664. cope(numb)
  665. int numb;
  666. {
  667. unsn bytes_r;
  668. char *buf;
  669. unsn bufsiz;
  670.  
  671.   strcpy(dest_buf,ddrv);
  672.   strcat(dest_buf,e_buf);
  673.  
  674.   printf("\n  copying %14s to %14s ",
  675.       e_buf,
  676.       dest_buf);
  677.  
  678.   bufsiz = (unsn)_showsp() - (unsn)_memory() - 2000;
  679.   buf = 0;
  680.   while(!(buf = malloc(bufsiz) ))    bufsiz-=100;
  681.   if(!buf)    printf("\nno memory for a buffer\n");
  682.   else
  683.   {
  684.  
  685.    fd2=0;
  686.  
  687.    if( (fd1 = fopen(e_buf,"r")) >0 )
  688.    {
  689.      while(bytes_r = fread(buf,1,bufsiz,fd1))
  690.      {
  691.        if (!fd2)
  692.        { if( (fd2 = fopen(dest_buf,"w")) <1 )
  693.      {  printf("\ncan\'t create \"%s\"\n",dest_buf);
  694.         goto endc;
  695.      }
  696.        }
  697.        if ( fwrite(buf,1,bytes_r,fd2) != bytes_r)
  698.      printf("\ndestination disk full\n");
  699.      }
  700.    }
  701.    else printf("\ncan\'t open \"%s\"\n",e_buf);
  702.  
  703. endc:
  704.    free(buf);
  705.  
  706.    fclose(fd2);
  707.    fclose(fd1);
  708.    set_dt(dest_buf,entry[numb].e_date,entry[numb].e_time);
  709.   }
  710.  
  711. }
  712.  
  713. set_dt(ptr,dat,tim)
  714. char    *ptr;
  715. short int dat,tim;
  716. {
  717. #asm
  718.   mov  dx,[bp+4]
  719.   mov  al,2
  720.   mov  ah,3dh
  721.   int  21h
  722.   push ax
  723.  
  724.   mov  bx,ax         ; file handle
  725.   mov  dx,[bp+6]     ; dx=date
  726.   mov  cx,[bp+8]     ; cx=time
  727.   mov  al,01H         ; al=1 for set
  728.   mov  ah,57H         ; ah=57
  729.   int  21H
  730.  
  731.   pop  bx
  732.   mov  ah,3eh
  733.   int  21h
  734.  
  735. #
  736. }
  737.  
  738. login(drive)
  739. char drive;
  740. {
  741. int i;
  742. long int totu,tota;
  743.  
  744.  
  745.   entries = 0;
  746.   total = 0;
  747.  
  748.   totu = tota = avail = total = sectors = bytes = 0;
  749.  
  750.   chg_drv((int)drive - 'A');
  751.  
  752.   ld_es(files);
  753.   qsort(&entry, entries, 25, comp);
  754.  
  755.   for(i=1; i<= (entries ); i++)
  756.   {
  757.     entry[i-1].e_num = i;
  758.   }
  759.  
  760.   free_drv(0);
  761.  
  762.     totu = ((long)total - (long)avail) * (long)sectors * (long)bytes;
  763.     tota = (long)avail * (long)sectors * (long)bytes;
  764.  
  765.  
  766.   printf("\n\ndrive %c%c has %d files with %8D used / %8D free \n",
  767.                drv[0],drv[1],
  768.                i-1,
  769.                totu,
  770.                tota );
  771.  
  772.   num = 0;
  773.  
  774. }
  775.  
  776. ld_es(dev_arg)
  777. char dev_arg[];
  778. {
  779.  
  780.       if (!find_first(dev_arg)) return(-1);
  781.       do {
  782.        if(DTA.dta_attribute & 0x08)
  783.          strcpy(volume,&DTA.dta_name);
  784.        else if(showhide || !(DTA.dta_attribute & 0x02))
  785.        {
  786.          _move(22, &DTA.dta_attribute, &entry[entries]);
  787.          entry[entries++].e_tag = 0;
  788.        }
  789.     } while (find_next());
  790.  
  791. }
  792.  
  793. display_e(i)
  794. int i;
  795. {
  796. int hour;
  797. char access_attr,type_attr;
  798.  
  799. fmtebuf(i);
  800.  
  801. hour = (entry[i].e_time >> 11);
  802.  
  803. if (entry[i].e_attribute & 0x01)
  804.   access_attr = '-';
  805. else access_attr = 'w';
  806.  
  807. if (entry[i].e_attribute & 0x10)
  808.   type_attr = 'd';
  809. else if (entry[i].e_attribute & 0x02)
  810.   type_attr = 'h';
  811. else if (entry[i].e_attribute & 0x04)
  812.   type_attr = 's';
  813. else type_attr = '-';
  814.  
  815.  
  816. printf("\n%3d. %c%c%14s %c%c%c %2d:%02d %2d-%02d-%02d %8D %c ",
  817.     entry[i].e_num,
  818.     drv[0],drv[1],
  819.     e_buf,
  820.     type_attr, 'r', access_attr,
  821.     hour,
  822.     ((entry[i].e_time >> 5) & 0x003F),
  823.     (entry[i].e_date >> 5) & 0x000f,
  824.     (entry[i].e_date & 0x001f),
  825.     ((entry[i].e_date >> 9) + 1980),
  826.     entry[i].e_file_size,
  827.     (entry[i].e_tag ==2) ? '*' : ':');
  828.  
  829. }
  830.  
  831.