home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 085.lha / Lit / lit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-11-20  |  8.7 KB  |  376 lines
  1. #include <stdio.h>
  2. #include <exec/types.h>
  3.  
  4. /*
  5. * Lit Text Utility -  Filter a file to stdout showing all characters in
  6. * an unambiguous format. See Lit Text Utility Manual for specification.
  7. *
  8. * Version 2.0 - 11/16/86, Unpublished (C) 1986 Donald J Irving
  9. *
  10. * Author:    Donald J. Irving
  11. *            9812 Gardenwood Way
  12. *            Sacramento, CA 96827
  13. *            (916) 366-3225
  14. *            CIS:   73547,1335
  15. *            PLINK: ops158
  16. *
  17. * Lit  may be freely distributed for personal use.
  18. * Lit may not be sold or placed on a disk offered for sale without written
  19. * permission from the author. Written permission will normally be granted
  20. * at no charge for inclusion on so called "public domain disks" which are
  21. * sold for nominal medium and handling fees. Lit may be modified for 
  22. * personal use, and trivial modifications such as changing defaults or
  23. * specifying include files may be made for distribution, but lit is not to
  24. * be modified substantially for distribution without written consent of the
  25. * author. The lit.c source, lit manual file , and this copyright notice must 
  26. * be included on all distributions.
  27. * 
  28. * Here is the overall algorithm, minus some of the details:
  29. *
  30. *    if unable to interpret command line arguments
  31. *        print an error message and a Usage line;
  32. *    else
  33. *        set options and open files;
  34. *        if line specified to start on is not the first line
  35. *            throw out input file lines until the line specified;
  36. *        while read next char from input file
  37. *            if the char is printable
  38. *                print it;
  39. *            else
  40. *                represent it in a special format;
  41. *            if the char is a line feed
  42. *                output a linefeed;
  43. *                if there was a number of lines to print specified
  44. *                and ++line count equals that number
  45. *                    return;
  46. * 
  47. * Functions not returning values are not typed. Functions returning values
  48. * are explicitly typed.
  49. *  
  50. */
  51.  
  52. /* The four possible settings for representation mode. */
  53. #define BSLASH        1        /* use backslash rep else numeric */
  54. #define CONTROL        2        /* use control char reps else numeric */
  55. #define ALLREPS        3        /* use backslash else control else numeric */
  56. #define NUMERIC        4        /* use numeric value reps only */
  57.  
  58. /* The three possible settings for  numeric number base */
  59. #define OCT               1        /* use octal representations as in \033 */
  60. #define HEX            2        /* use hex representations as in \1B */
  61. #define DEC            3        /* use decimal representations as in \027 */
  62.  
  63. /* The most likely setting for how many lines to print */
  64. #define ALL_LINES    32767    /* print all the lines in the file */
  65.  
  66. /*
  67. * Here are the default option settings. If you don't like them, please
  68. * change them here. The comments on the define lines show the the default
  69. * settings chosen by the author and upon which the manual is based. Please
  70. * leave the comments as they are.
  71. */
  72.                                                     /* original        */
  73. #define DEFAULT_START        1                        /* 1            */
  74. #define DEFAULT_PRINT        ALL_LINES                /* ALL_LINES    */
  75. #define DEFAULT_OUTMODE     BSLASH                    /* BSLASH        */
  76. #define DEFAULT_BASE        OCT                        /* OCT            */
  77.  
  78. /* Non-printing characters which require special handling in the code */
  79. #define DEL        '\177'
  80.  
  81. struct opt {
  82.     short start;
  83.     short print;
  84.     short outmode;
  85.     short base;
  86. };
  87.  
  88. typedef struct opt opt_t;
  89.  
  90. main(argc, argv)  
  91. int argc;  
  92. char *argv[];  
  93. {
  94.     FILE *ifp = NULL;
  95.     register short c;
  96.     static opt_t opt = {
  97.         DEFAULT_START,
  98.         DEFAULT_PRINT,
  99.         DEFAULT_OUTMODE,
  100.         DEFAULT_BASE
  101.     };
  102.  
  103.     if (! process_args(argc, argv, &ifp, &opt))
  104.         printf("Usage: lit [<filename>] [-s<n>] [-p<n>] [-[bcan][ohd]]\n");
  105.     else {
  106.         if (opt.start != 1  && ! find_start_line(ifp, opt.start))
  107.             return;
  108.         while ((c = getc(ifp)) != EOF) {
  109.             if (! print_char(c, opt.outmode))
  110.                 represent_char(c, opt.outmode, opt.base);
  111.             if (c == '\n') {
  112.                 putchar('\n');
  113.                 if (opt.print != ALL_LINES &&  last_line(opt.print))
  114.                     break;
  115.             }
  116.         }
  117.         if (c != '\n')
  118.             putchar('\n');
  119.     }
  120. }
  121.  
  122.  
  123. /*
  124. * process_args -- Process all the command line arguments. Each argument is
  125. * expected to be either a minus sign option or an input file name. If an
  126. * input file is already open, a subsequent input file name argument is an
  127. * error.
  128. */
  129.  
  130. BOOL process_args(argc, argv, ifp, opt)
  131. int argc;
  132. char *argv[];
  133. FILE **ifp;
  134. opt_t *opt;
  135. {
  136.     register short i;
  137.  
  138.     for (i = 1; i < argc; i++) {
  139.         if (*argv[i] == '-') {
  140.             if (! process_opt(argv[i]+1, opt))
  141.                 return (FALSE);
  142.         }
  143.         else if (*ifp != NULL) {
  144.             printf("Invalid argument  %s, Input file already specified\n", 
  145.             argv[i]);
  146.             return (FALSE);
  147.         }
  148.         else if ((*ifp = fopen(argv[i], "r")) == NULL) {
  149.             printf("Unable to open input file %s\n", argv[i]);
  150.             return (FALSE);
  151.         }
  152.     }
  153.  
  154.     if (*ifp == NULL)
  155.         *ifp = stdin;
  156.     return (TRUE);
  157. }
  158.  
  159.  
  160. /*
  161. * process_opt -- Process a minus-sign command line argument. The options
  162. * s<linenum> and p<numlines> must stand alone with their own minus signs; 
  163. * The options b,c,a,n,o,h,d may be stacked after a single minus sign.
  164. */
  165.  
  166. BOOL process_opt(arg, opt)
  167. char *arg;
  168. opt_t *opt;
  169. {
  170.     switch (*arg) {
  171.     case 's':
  172.         opt->start = atoi(arg+1);            /* set starting linenum */
  173.         break;
  174.     case 'p':
  175.         opt->print = atoi(arg+1);            /* set linenums to print */
  176.         break;
  177.     default:
  178.         for (; *arg; arg++) {
  179.             switch (*arg) {
  180.             case 'b':
  181.                 opt->outmode = BSLASH;        /* use backslash rep else */
  182.                 break;                        /* numeric rep              */
  183.             case 'c':
  184.                 opt->outmode = CONTROL;        /* use control char rep   */
  185.                 break;                        /* else numeric rep       */
  186.             case 'a':
  187.                 opt->outmode = ALLREPS;        /* use backslash else     */
  188.                 break;                        /* control else numeric   */
  189.             case 'n':
  190.                 opt->outmode = NUMERIC;        /* use numeric rep only   */
  191.                 break;
  192.             case 'o':
  193.                 opt->base = OCT;        /* numeric rep base is octal */
  194.                 break;
  195.             case 'h':
  196.                 opt->base = HEX;        /* numeric rep base is hex */
  197.                 break;
  198.             case 'd':
  199.                 opt->base = DEC;        /* numeric rep base is decimal */
  200.                 break;
  201.             default:
  202.                 printf("Unknown option: %c\n", *arg);
  203.                 return (FALSE);
  204.             }
  205.         }
  206.     }
  207.     return (TRUE);
  208. }
  209.  
  210.  
  211. /*
  212. * find_start_line -- Find the first line to start printing on, throwing
  213. * out all the lines along the way.
  214. */
  215.  
  216. BOOL find_start_line(ifp, start)
  217. FILE *ifp;
  218. short start;
  219. {
  220.     register short c, lineno = 1;
  221.  
  222.     while (lineno < start) {
  223.         while ((c = getc(ifp)) != EOF  &&  c != '\n')
  224.             ;
  225.         if (c == EOF)
  226.             return (FALSE);
  227.         lineno++;
  228.     }
  229.     return (TRUE);
  230. }
  231.  
  232.  
  233. /*
  234. * last_line -- Return true if the line just printed was the last line
  235. * to print.
  236. */
  237.  
  238. BOOL last_line(print)
  239. short print;
  240. {
  241.     static short printed = 0;
  242.  
  243.     if (++printed == print)
  244.         return (TRUE);
  245.     return (FALSE);
  246. }
  247.  
  248.  
  249. /*
  250. * print_char -- Print a printable character. If it's a \, or if
  251. * it's a ^ and control codes are enabled, then preface it with a \.
  252. */
  253.  
  254. BOOL print_char(c, outmode) 
  255. short c, outmode;
  256. {
  257.     if (c < ' ' || c > '~')
  258.         return (FALSE);
  259.  
  260.     if (c == '\\'
  261.     || (c == '^' && (outmode == CONTROL || outmode == ALLREPS)))
  262.         putchar('\\');
  263.  
  264.     putchar(c);
  265.     return (TRUE);
  266. }
  267.  
  268.  
  269. /*
  270. * represent_char -- Represent a non-printable character using whichever
  271. * representation format is appropriate for the outmode selected. The
  272. * rep_xxx functions called try to represent the char in a particular
  273. * format, and return false if the the character is not applicable.
  274. */
  275.  
  276. represent_char(c, outmode, base)
  277. short c, outmode, base;
  278. {
  279.     switch (outmode) {
  280.     case BSLASH:
  281.         if (rep_bslash(c))
  282.             return;
  283.         break;
  284.     case CONTROL:
  285.         if (rep_control(c))
  286.             return;
  287.         break;
  288.     case ALLREPS:
  289.         if (rep_bslash(c) || rep_control(c))
  290.             return;
  291.         break;
  292.     case NUMERIC:
  293.         break;
  294.     }
  295.     rep_numeric(c, base);
  296. }
  297.  
  298.  
  299. /*
  300. * rep_bslash - Represent a non-printable char if possible using its
  301. * C Language backslash construct, else return false. '\0' is not included.
  302. */
  303.  
  304. BOOL rep_bslash(c)
  305. short c;
  306. {
  307.     switch (c) {
  308.     case '\n':    putchar('\\');    putchar('n');        break;
  309.     case '\t':    putchar('\\');    putchar('t');        break;
  310.     case '\b':    putchar('\\');    putchar('b');        break;
  311.     case '\r':    putchar('\\');    putchar('r');        break;
  312.     case '\f':    putchar('\\');    putchar('f');        break;
  313.     default  : 
  314.         return (FALSE);
  315.     }
  316.     return (TRUE);
  317. }
  318.  
  319.  
  320. /*
  321. * rep_control -- represent a non-printable char if possible using its
  322. * control character representation, else return false. All non-printing
  323. * ascii chars are representable as control chars (with DEL arbitrarily
  324. * assigned the representation ^?). Characters rejected are those outside
  325. * the range of ascii (ie, left most bit on).
  326. */
  327.  
  328. BOOL rep_control(c)
  329. short c;
  330. {
  331.     if (c < '\0' || c > '\177')
  332.         return (FALSE);
  333.  
  334.     putchar('^');
  335.  
  336.     switch (c) {
  337.     case DEL:
  338.         putchar('?');
  339.         break;
  340.     default:
  341.         putchar(c | 0x40);
  342.         break;
  343.     }
  344.     return (TRUE);
  345. }
  346.  
  347.  
  348. /*
  349. * rep_numeric - Unconditionally represent a character as a numeric value
  350. * using the number base specified.
  351. */
  352.  
  353. rep_numeric(c, base)
  354. short c, base;
  355. {
  356.     char buf[4];
  357.  
  358.     switch (base) {
  359.     case OCT:
  360.         printf("\\%03o", c);
  361.         break;
  362.     case HEX:
  363.         sprintf(buf, "\\%02x\0", c);    /* make it upper case, %X    */
  364.         if (buf[1] >= 'a')                /* doesn't seem to work on    */
  365.             buf[1] &= 0x5F;                /* my compiler.                */
  366.         if (buf[2] >= 'a')
  367.             buf[2] &= 0x5F;
  368.         printf("%s", buf);
  369.         break;
  370.     case DEC:
  371.         printf("\\%03d", c);
  372.         break;
  373.     }
  374. }
  375.  
  376.