home *** CD-ROM | disk | FTP | other *** search
/ norge.freeshell.org (192.94.73.8) / 192.94.73.8.tar / 192.94.73.8 / pub / computers / cpm / alphatronic / TINY_C.ZIP / LIST.C < prev    next >
Text File  |  1999-03-05  |  4KB  |  161 lines
  1.  
  2.  
  3.  
  4. /*
  5.     This program accepts a list of filenames, which 
  6.     should represent ascii files on the disk, and
  7.     prints them out on the CP/M list device.
  8.     There is nothing particularly fascinating about
  9.     this program; it is included mainly as an example
  10.     of file I/O handling in C.
  11.  
  12.     Note the use of ARGC and ARGV in main; the names
  13.     themselves mean "arg count" and "arg vector", and
  14.     point out that upon entry to the "main" program,
  15.     your command line arguments are available for
  16.     processing. ARGC is equal to the number of arguments
  17.     given on the command line PLUS ONE, and ARGV tells you
  18.     the address of the beginning of each argument. Thus,
  19.     the expression
  20.             argv[1]
  21.     represents the address of the first character of the
  22.     first argument string;
  23.             argv[2]
  24.     would be the address of the second argument string,
  25.     etc. By convention, argv[0] is not used, since 0
  26.     arguments is a special case. On UNIX C, the original
  27.     C, argv[0] would point to the command itself
  28.     (i.e., the string 'foo' in
  29.         A> foo arg1 arg2 arg3 )
  30.     But, unfortunately, CP/M doesn't bother to save that
  31.     part of the command line, so the C COM file can never
  32.     see what its name really is.
  33.     Note that ARGV can NEVER equal zero; the case of zero
  34.     arguments causes ARGV to be equal to 1. Again, this
  35.     is to maintain compatibility with UNIX C.
  36.  
  37.     Alternatively (and, in fact, how it is done here), it
  38.     is possible to use the variable argv as a pointer, so
  39.     that the value of
  40.             *++argv
  41.     upon entry to main would point to the first
  42.     argument string; after incrementing argv again
  43.     it would point to the second argument string, etc.
  44.     Note how the increment operation specified by
  45.             argv++
  46.              or
  47.             ++argv
  48.     knows to add 2 to argv, since argv was declared as
  49.     a pointer to pointers, and pointers take 2 bytes!
  50.     Thus, should argv have been (incorrectly) declared
  51.             char *argv;
  52.     then the
  53.             argv++
  54.     operation would add only 1 to argv, instead of 2.
  55.  
  56.     Oh well, enough tutorial. Here's the program...
  57.  
  58. */
  59.  
  60.  
  61. #define BUFSIZ 8192
  62.  
  63. int lpos;
  64. int lines;
  65.  
  66. main(argc,argv)
  67. int argc;
  68. char **argv;
  69. {
  70.     outp(0,8); /* set 3P+S to 1200 baud */
  71.     while (--argc) {
  72.         printf("\nPrinting %s...\n",*++argv);
  73.         putlist(*argv);
  74.      }
  75. }
  76.  
  77. putlist(file)
  78. char *file;
  79. {
  80.     char buffer[BUFSIZ];
  81.     int fd,i,j;
  82.     int nsects;
  83.     lpos=1; /* keep track of print head position */
  84.     nsects = BUFSIZ/128;
  85.     bdos(5,0x0d);
  86.     for(i=0; i<8; i++) bdos(5,0x0a);
  87.     lines=1;
  88.     fd=open(file,0);
  89.     if ( fd == -1) return;
  90.     while ((j= read(fd,buffer,nsects))==nsects)
  91.         putchunk(buffer);
  92.     if (j) putchunk(buffer);
  93.     close(fd);
  94. }
  95.  
  96.  
  97. /*
  98.     This routine puts BUFSIZ characters (or until EOF)
  99.     out on the list device.
  100. */
  101.  
  102. putchunk(buffer)
  103. char *buffer;
  104. {
  105.     char c;
  106.     int i,j,k;
  107.     for (k=0; k<BUFSIZ; k++)
  108.     switch (c= *buffer++) {
  109.         case '\r':
  110.             bdos(5,'\r');
  111.             putchar('\r');
  112.             lpos = 0;
  113.             break;
  114.  
  115.         case '\t':
  116.             while(lpos%8) { lpos++;
  117.                     bdos(5,' ');
  118.                     putchar(' ');
  119.                     }
  120.             bdos(5,' '); putchar(' ');
  121.             lpos++;
  122.             break;
  123.  
  124.         case 0x1a:
  125.             return;
  126.  
  127.         case 0x0a:
  128.             lines++;
  129.             if(lines==6) {
  130.             printf("\nTear off page...\n");
  131.             wait(300); /* give him 30 seconds */
  132.              }
  133.             if(lines==60) {
  134.                 for(i=0; i<10; i++)
  135.                     bdos(5,0x0a);
  136.                 lines=1;
  137.                 for(i=0; i<5000; i++);
  138.              }
  139.         default:
  140.             bdos(5,c);
  141.             putchar(c);
  142.             lpos++;
  143.     }
  144. }
  145.  
  146.  
  147. /* routine to wait for a specified number of
  148.   tenths of a second and return the number of tenths
  149.   of a second it took the user to type something */
  150.  
  151. wait(n)
  152. int n;
  153. {
  154.     int i;
  155.     int j;
  156.     for (i=1; i<n+1; i++)
  157.         for (j=0; j<165; j++)
  158.         if (bdos(11)&1) return i;
  159.     return n;
  160. }
  161.