contrib/vis/vis.c

   1 /*      $NetBSD: vis.c,v 1.25 2015/05/24 19:42:39 christos Exp $        */
   2
   3 /*-
   4  * Copyright (c) 1989, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #ifndef lint
  34 __COPYRIGHT("@(#) Copyright (c) 1989, 1993\
  35  The Regents of the University of California.  All rights reserved.");
  36 #endif /* not lint */
  37
  38 #ifndef lint
  39 #if 0
  40 static char sccsid[] = "@(#)vis.c       8.1 (Berkeley) 6/6/93";
  41 #endif
  42 __RCSID("$NetBSD: vis.c,v 1.25 2015/05/24 19:42:39 christos Exp $");
  43 #endif /* not lint */
  44
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <errno.h>
  50 #include <wchar.h>
  51 #include <limits.h>
  52 #include <unistd.h>
  53 #include <err.h>
  54 #include <vis.h>
  55
  56 #include "extern.h"
  57
  58 static int eflags, fold, foldwidth = 80, none, markeol;
  59 #ifdef DEBUG
  60 int debug;
  61 #endif
  62 static const char *extra = "";
  63
  64 static void process(FILE *);
  65
  66 int
  67 main(int argc, char *argv[])
  68 {
  69         FILE *fp;
  70         int ch;
  71         int rval;
  72
  73         while ((ch = getopt(argc, argv, "bcde:F:fhlMmNnoSstw")) != -1)
  74                 switch((char)ch) {
  75                 case 'b':
  76                         eflags |= VIS_NOSLASH;
  77                         break;
  78                 case 'c':
  79                         eflags |= VIS_CSTYLE;
  80                         break;
  81 #ifdef DEBUG
  82                 case 'd':
  83                         debug++;
  84                         break;
  85 #endif
  86                 case 'e':
  87                         extra = optarg;
  88                         break;
  89                 case 'F':
  90                         if ((foldwidth = atoi(optarg)) < 5) {
  91                                 errx(1, "can't fold lines to less than 5 cols");
  92                                 /* NOTREACHED */
  93                         }
  94                         markeol++;
  95                         break;
  96                 case 'f':
  97                         fold++;         /* fold output lines to 80 cols */
  98                         break;          /* using hidden newline */
  99                 case 'h':
 100                         eflags |= VIS_HTTPSTYLE;
 101                         break;
 102                 case 'l':
 103                         markeol++;      /* mark end of line with \$ */
 104                         break;
 105                 case 'M':
 106                         eflags |= VIS_META;
 107                         break;
 108                 case 'm':
 109                         eflags |= VIS_MIMESTYLE;
 110                         if (foldwidth == 80)
 111                                 foldwidth = 76;
 112                         break;
 113                 case 'N':
 114                         eflags |= VIS_NOLOCALE;
 115                         break;
 116                 case 'n':
 117                         none++;
 118                         break;
 119                 case 'o':
 120                         eflags |= VIS_OCTAL;
 121                         break;
 122                 case 'S':
 123                         eflags |= VIS_SHELL;
 124                         break;
 125                 case 's':
 126                         eflags |= VIS_SAFE;
 127                         break;
 128                 case 't':
 129                         eflags |= VIS_TAB;
 130                         break;
 131                 case 'w':
 132                         eflags |= VIS_WHITE;
 133                         break;
 134                 case '?':
 135                 default:
 136                         (void)fprintf(stderr,
 137                             "Usage: %s [-bcfhlMmNnoSstw] [-e extra]"
 138                             " [-F foldwidth] [file ...]\n", getprogname());
 139                         return 1;
 140                 }
 141
 142         if ((eflags & (VIS_HTTPSTYLE|VIS_MIMESTYLE)) ==
 143             (VIS_HTTPSTYLE|VIS_MIMESTYLE))
 144                 errx(1, "Can't specify -m and -h at the same time");
 145
 146         argc -= optind;
 147         argv += optind;
 148
 149         rval = 0;
 150
 151         if (*argv)
 152                 while (*argv) {
 153                         if ((fp = fopen(*argv, "r")) != NULL) {
 154                                 process(fp);
 155                                 (void)fclose(fp);
 156                         } else {
 157                                 warn("%s", *argv);
 158                                 rval = 1;
 159                         }
 160                         argv++;
 161                 }
 162         else
 163                 process(stdin);
 164         return rval;
 165 }
 166
 167 static void
 168 process(FILE *fp)
 169 {
 170         static int col = 0;
 171         static char nul[] = "\0";
 172         char *cp = nul + 1;     /* so *(cp-1) starts out != '\n' */
 173         wint_t c, c1, rachar;
 174         char mbibuff[2 * MB_LEN_MAX + 1]; /* max space for 2 wchars */
 175         char buff[4 * MB_LEN_MAX + 1]; /* max encoding length for one char */
 176         int mbilen, cerr = 0, raerr = 0;
 177
 178         /*
 179          * The input stream is considered to be multibyte characters.
 180          * The input loop will read this data inputing one character,
 181          * possibly multiple bytes, at a time and converting each to
 182          * a wide character wchar_t.
 183          *
 184          * The vis(3) functions, however, require single either bytes
 185          * or a multibyte string as their arguments.  So we convert
 186          * our input wchar_t and the following look-ahead wchar_t to
 187          * a multibyte string for processing by vis(3).
 188          */
 189
 190         /* Read one multibyte character, store as wchar_t */
 191         c = getwc(fp);
 192         if (c == WEOF && errno == EILSEQ) {
 193                 /* Error in multibyte data.  Read one byte. */
 194                 c = (wint_t)getc(fp);
 195                 cerr = 1;
 196         }
 197         while (c != WEOF) {
 198                 /* Clear multibyte input buffer. */
 199                 memset(mbibuff, 0, sizeof(mbibuff));
 200                 /* Read-ahead next multibyte character. */
 201                 if (!cerr)
 202                         rachar = getwc(fp);
 203                 if (cerr || (rachar == WEOF && errno == EILSEQ)) {
 204                         /* Error in multibyte data.  Read one byte. */
 205                         rachar = (wint_t)getc(fp);
 206                         raerr = 1;
 207                 }
 208                 if (none) {
 209                         /* Handle -n flag. */
 210                         cp = buff;
 211                         *cp++ = c;
 212                         if (c == '\\')
 213                                 *cp++ = '\\';
 214                         *cp = '\0';
 215                 } else if (markeol && c == '\n') {
 216                         /* Handle -l flag. */
 217                         cp = buff;
 218                         if ((eflags & VIS_NOSLASH) == 0)
 219                                 *cp++ = '\\';
 220                         *cp++ = '$';
 221                         *cp++ = '\n';
 222                         *cp = '\0';
 223                 } else {
 224                         /*
 225                          * Convert character using vis(3) library.
 226                          * At this point we will process one character.
 227                          * But we must pass the vis(3) library this
 228                          * character plus the next one because the next
 229                          * one is used as a look-ahead to decide how to
 230                          * encode this one under certain circumstances.
 231                          *
 232                          * Since our characters may be multibyte, e.g.,
 233                          * in the UTF-8 locale, we cannot use vis() and
 234                          * svis() which require byte input, so we must
 235                          * create a multibyte string and use strvisx().
 236                          */
 237                         /* Treat EOF as a NUL char. */
 238                         c1 = rachar;
 239                         if (c1 == WEOF)
 240                                 c1 = L'\0';
 241                         /*
 242                          * If we hit a multibyte conversion error above,
 243                          * insert byte directly into string buff because
 244                          * wctomb() will fail.  Else convert wchar_t to
 245                          * multibyte using wctomb().
 246                          */
 247                         if (cerr) {
 248                                 *mbibuff = (char)c;
 249                                 mbilen = 1;
 250                         } else
 251                                 mbilen = wctomb(mbibuff, c);
 252                         /* Same for look-ahead character. */
 253                         if (raerr)
 254                                 mbibuff[mbilen] = (char)c1;
 255                         else
 256                                 wctomb(mbibuff + mbilen, c1);
 257                         /* Perform encoding on just first character. */
 258                         (void) strsenvisx(buff, 4 * MB_LEN_MAX, mbibuff,
 259                             1, eflags, extra, &cerr);
 260                 }
 261
 262                 cp = buff;
 263                 if (fold) {
 264 #ifdef DEBUG
 265                         if (debug)
 266                                 (void)printf("<%02d,", col);
 267 #endif
 268                         col = foldit(cp, col, foldwidth, eflags);
 269 #ifdef DEBUG
 270                         if (debug)
 271                                 (void)printf("%02d>", col);
 272 #endif
 273                 }
 274                 do {
 275                         (void)putchar(*cp);
 276                 } while (*++cp);
 277                 c = rachar;
 278                 cerr = raerr;
 279         }
 280         /*
 281          * terminate partial line with a hidden newline
 282          */
 283         if (fold && *(cp - 1) != '\n')
 284                 (void)printf(eflags & VIS_MIMESTYLE ? "=\n" : "\\\n");
 285 }