[misc] / space.c

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>

#include <fcntl.h>
#include <getopt.h>
#include <unistd.h>

enum {
  OK = 0,
  BADNESS = 1,
  TROUBLE = 32
};

static const char *ego = "<unset>";

static const char *bkp = 0;

static unsigned flags = 0;
#define F_MIDLINETABS 1u
#define F_INPLACE 2u
#define F_CHECK 4u
#define F_BOGUS 8u
#define F_UNTABIFY 16u
#define F_TABIFY 32u
#define F_VERBOSE 64u

static void usage(FILE *fp)
  { fprintf(fp, "Usage: %s [-cmtuv] [-i[BKP]] [FILE...]\n\n", ego); }

static char *augment(const char *name, const char *suffix)
{
  size_t n = strlen(name), nn = strlen(suffix);
  char *p = malloc(n + nn + 1);

  if (!p) {
    fprintf(stderr, "%s: Out of memory!\n", ego);
    return (0);
  }
  memcpy(p, name, n);
  memcpy(p + n, suffix, nn + 1);
  return (p);
}

static FILE *freshname(const char *name, char **newname, mode_t mode)
{
  char buf[16];
  int i;
  int fd;
  FILE *fp;
  char *n;

  for (i = 0; i < 32767; i++) {
    sprintf(buf, ".new%d", i);
    if ((n = augment(name, buf)) == 0)
      goto fail_0;
    if ((fd = open(n, O_WRONLY | O_CREAT | O_EXCL, mode)) < 0) {
      if (errno == EEXIST) {
	free(n);
	continue;
      }
      fprintf(stderr, "%s: Can't create new file for `%s': %s\n",
	      ego, name, strerror(errno));
      goto fail_1;
    }
    goto win;
  }
  fprintf(stderr, "%s: Can't find new file to update `%s'\n", ego, name);
  goto fail_1;

win:
  if (chmod(n, mode)) {
    fprintf(stderr, "%s: Can't set permissions on `%s': %s\n",
	    ego, n, strerror(errno));
    goto fail_2;
  }
  if ((fp = fdopen(fd, "w")) == 0) {
    fprintf(stderr, "%s: fdopen on `%s' failed: %s\n",
	    ego, n, strerror(errno));
    goto fail_2;
  }
  *newname = n;
  return (fp);

fail_2:
  close(fd);
fail_1:
  free(n);
fail_0:
  return (0);
}

typedef struct buf {
  char *b;
  size_t n;
  size_t sz;
} buf;
#define BUF_INIT { 0, 0, 0 }

static void reset(buf *b) { b->n = 0; }

static int put(buf *b, int ch)
{
  size_t w;

  if (b->n >= b->sz) {
    if (!b->sz) {
      w = 64;
      b->b = malloc(w);
    } else {
      w = b->sz * 2;
      b->b = realloc(b->b, w);
    }
    if (!b->b) {
      fprintf(stderr, "%s: Not enough memory for buffer!\n", ego);
      return (-1);
    }
    b->sz = w;
  }
  b->b[b->n++] = ch;
  return (0);
}

#define TABSTOP(n) (((n) + 8u) & ~7u)

static int space(const char *name)
{
  static buf b = BUF_INIT;
  FILE *fin, *fout = stdout;
  char *newname = 0, *oldname = 0;
  int rc = TROUBLE, status = OK;
  int last = '\n';
  unsigned nsp = 0, nwsp = 0, hpos = 0, ohpos = 0, nhpos = 0, nl = 1;
  unsigned i;
#define f_newline 1u
#define f_warnspacetab 2u
#define f_tabify 4u
#define f_warntabs 8u
#define f_warnspaces 16u
#define f_tab 32u
#define f_bad 64u
#define f_forced 128u
  unsigned f = f_newline | (flags & F_TABIFY ? f_tabify : 0);
  int ch;

  if (strcmp(name, "-") == 0) {
    if (flags & F_INPLACE) {
      fprintf(stderr, "%s: Can't modify stdin in-place.\n", ego);
      goto done_0;
    }
    fin = stdin;
  } else {
    if ((fin = fopen(name, "r")) == 0) {
      fprintf(stderr, "%s: Failed to open file `%s': %s.\n",
	      ego, name, strerror(errno));
      goto done_0;
    }
    else if (flags & F_INPLACE) {
      struct stat st;
      if (stat(name, &st)) {
	fprintf(stderr, "%s: Can't stat `%s': %s.\n",
		ego, name, strerror(errno));
	goto done_1;
      }
      if ((fout = freshname(name, &newname, st.st_mode)) == 0)
	goto done_1;
    }
  }
  if (flags & F_CHECK)
    fout = 0;

  for (;;) {
    ch = getc(fin);
    switch (ch) {
      case ' ':
	nsp++; nwsp++; hpos++;
	if (put(&b, ' ')) goto done_2;
	break;
      case '\t':
	if (flags & F_UNTABIFY) {
	  if ((flags & F_VERBOSE) && !(f & f_warntabs)) {
	    fprintf(stderr, "%s:%u: found tab\n", name, nl);
	    f |= f_warntabs;
	  }
	  status = BADNESS;
	} else if (((flags & F_MIDLINETABS) || (f & f_newline)) && nsp) {
	  if ((flags & F_VERBOSE) && !(f & f_warnspacetab)) {
	    fprintf(stderr, "%s:%u: space followed by tab\n", name, nl);
	    f |= f_warnspacetab;
	  }
	  status = BADNESS;
	  f |= f_tabify | f_forced;
	}
	f |= f_tab;
	nsp = 0; nwsp++; hpos = TABSTOP(hpos);
	if (put(&b, '\t')) goto done_2;
	break;
      case EOF:
	if (nwsp || !(f & f_newline)) {
	  if (flags & F_VERBOSE)
	    fprintf(stderr, "%s:%u: file ends in mid-line\n", name, nl);
	  status = BADNESS;
	  if (fout) putc('\n', fout);
	}
	goto end;
      case '\n':
      case '\v':
	if (nwsp) {
	  if (flags & F_VERBOSE)
	    fprintf(stderr, "%s:%u: trailing whitespace\n", name, nl);
	  status = BADNESS;
	}
	if (fout) putc('\n', fout);
	reset(&b);
	nsp = nwsp = hpos = ohpos = 0; nl++;
	f |= f_newline;
	f &= ~(f_tab | f_warnspacetab | f_warntabs | f_warnspaces);
	if (flags & F_TABIFY)
	  f |= f_tabify;
	else
	  f &= ~f_tabify;
	last = '\n';
	break;
      default:
	if (nwsp) {
	  if (flags & F_UNTABIFY) {
	    if (fout) for (; ohpos < hpos; ohpos++) putc(' ', fout);
	  } else if ((f & f_tabify) &&
		     ((hpos - ohpos >= (last == '.' || last == ':' ?
					  3 : 2)) ||
		      (f & (f_tab | f_newline)))) {
	    i = 0;
	    for (;;) {
	      nhpos = TABSTOP(ohpos);
	      if (nhpos > hpos) break;
	      if (fout) putc('\t', fout);
	      if ((flags & F_VERBOSE) && (flags & F_TABIFY) &&
		  i < b.n && b.b[i] != '\t' &&
		  !(f & (f_warnspaces | f_forced))) {
		fprintf(stderr, "%s:%u: spaces could be turned into tabs\n",
			name, nl);
		f |= f_warnspaces;
	      }
	      ohpos = nhpos;
	      i++;
	    }
	    if (fout)
	      for (; ohpos < hpos; ohpos++) putc(' ', fout);
	  } else if (fout)
	    for (i = 0; i < b.n; i++) putc(b.b[i], fout);
	}
	reset(&b);
	f &= ~(f_newline | f_tab | f_forced);
	if (!(flags & F_TABIFY) || !(flags & F_MIDLINETABS)) f &= ~f_tabify;
	nwsp = nsp = 0;
	hpos++; ohpos = hpos;
	if (fout) putc(ch, fout);
	if (ch != '"' && ch != '\'')
	  last = ch;
	break;
    }
  }
end:;

  if (ferror(fin)) {
    fprintf(stderr, "%s: Error reading `%s': %s\n",
	    ego, name, strerror(errno));
    goto done_2;
  }

  if (fout) {
    if (fflush(fout) || ferror(fout)) f |= f_bad;
    if (fout != stdout && fclose(fout)) f |= f_bad;
    fout = 0;
    if (f & f_bad) {
      fprintf(stderr, "%s: Error writing `%s': %s\n",
	      ego, newname, strerror(errno));
      goto done_2;
    }
  }

  if (flags & F_INPLACE) {
    if (bkp) {
      if ((oldname = augment(name, bkp)) == 0)
	goto done_2;
      if (rename(name, oldname)) {
	fprintf(stderr, "%s: Failed to back up `%s' as `%s': %s\n",
		ego, name, oldname, strerror(errno));
	goto done_2;
      }
    }
    if (rename(newname, name)) {
      if (oldname) rename(oldname, name);
      fprintf(stderr, "%s: Failed to install `%s' as `%s': %s\n",
	      ego, newname, name, strerror(errno));
      goto done_2;
    }
  }

  rc = status;

done_2:
  if (oldname) free(oldname);
  if (newname) {
    remove(newname);
    free(newname);
  }
done_1:
  if (fout && fout != stdout) fclose(fout);
  fclose(fin);
done_0:
  return (rc);
}

static int manysetp(unsigned f) { return (!!(f & (f - 1))); }

int main(int argc, char *argv[])
{
  int i;
  int rc = OK, st;

  if ((ego = strrchr(argv[0], '/')) == 0)
    ego = argv[0];
  else
    ego++;

  for (;;) {
    if ((i = getopt(argc, argv, "h" "cmtuv" "i::")) < 0)
      break;
    switch (i) {
      case 'h':
	printf("%s -- remove extraneous spaces from files\n\n", ego);
	usage(stdout);
	fputs("Options:\n\
  -h		Print this help text\n\
  -c		Check files for badness, but don't produce other output\n\
  -m		Fix spaces followed by tabs in mid-line\n\
  -t		Tabify file completely\n\
  -u		Untabify file completely\n\
  -i[BKP]	Modify files in place; leave FILEBKP as copy of old FILE\n\
", stdout);
	exit(0);
      case 'i':
	bkp = optarg;
	flags |= F_INPLACE;
	break;
      case 'm':
	flags |= F_MIDLINETABS;
	break;
      case 'c':
	flags |= F_CHECK;
	break;
      case 't':
	flags |= F_TABIFY;
	break;
      case 'u':
	flags |= F_UNTABIFY;
	break;
      case 'v':
	flags |= F_VERBOSE;
	break;
      default:
	flags |= F_BOGUS;
	break;
    }
  }
  if (flags & F_BOGUS) {
    usage(stderr);
    exit(TROUBLE);
  }
  if (manysetp(flags & (F_CHECK | F_INPLACE))) {
    fprintf(stderr, "%s: Options -c and -i are mutually exclusive.\n", ego);
    exit(TROUBLE);
  }
  if (manysetp(flags & (F_TABIFY | F_UNTABIFY))) {
    fprintf(stderr, "%s: Options -t and -u are mutually exclusive.\n", ego);
    exit(TROUBLE);
  }

  if (optind == argc) {
    if (isatty(0)) {
      fprintf(stderr, "%s: No options given and stdin is a terminal.\n",
	      ego);
      exit(TROUBLE);
    }
    rc = space("-");
  } else for (i = optind; i < argc; i++) {
    st = space(argv[i]);
    if (st > rc) rc = st;
  }
  if (rc == BADNESS && !(flags & F_CHECK))
    rc = OK;
  return (rc);
}
Commit	Line	Data
df33ee54 MW	1	#include <ctype.h>
	2	#include <errno.h>
	3	#include <stdio.h>
	4	#include <stdlib.h>
	5	#include <string.h>
	6
	7	#include <sys/types.h>
	8	#include <sys/stat.h>
	9
	10	#include <fcntl.h>
	11	#include <getopt.h>
	12	#include <unistd.h>
	13
	14	enum {
	15	OK = 0,
	16	BADNESS = 1,
	17	TROUBLE = 32
	18	};
	19
	20	static const char *ego = "<unset>";
	21
	22	static const char *bkp = 0;
	23
	24	static unsigned flags = 0;
	25	#define F_MIDLINETABS 1u
	26	#define F_INPLACE 2u
	27	#define F_CHECK 4u
	28	#define F_BOGUS 8u
	29	#define F_UNTABIFY 16u
	30	#define F_TABIFY 32u
	31	#define F_VERBOSE 64u
	32
	33	static void usage(FILE *fp)
	34	{ fprintf(fp, "Usage: %s [-cmtuv] [-i[BKP]] [FILE...]\n\n", ego); }
	35
	36	static char augment(const char name, const char *suffix)
	37	{
	38	size_t n = strlen(name), nn = strlen(suffix);
	39	char *p = malloc(n + nn + 1);
	40
	41	if (!p) {
	42	fprintf(stderr, "%s: Out of memory!\n", ego);
	43	return (0);
	44	}
	45	memcpy(p, name, n);
	46	memcpy(p + n, suffix, nn + 1);
	47	return (p);
	48	}
	49
	50	static FILE freshname(const char name, char **newname, mode_t mode)
	51	{
	52	char buf[16];
	53	int i;
	54	int fd;
	55	FILE *fp;
	56	char *n;
	57
	58	for (i = 0; i < 32767; i++) {
	59	sprintf(buf, ".new%d", i);
	60	if ((n = augment(name, buf)) == 0)
	61	goto fail_0;
	62	if ((fd = open(n, O_WRONLY \| O_CREAT \| O_EXCL, mode)) < 0) {
	63	if (errno == EEXIST) {
	64	free(n);
65	continue;
66	}
67	fprintf(stderr, "%s: Can't create new file for `%s': %s\n",
68	ego, name, strerror(errno));
69	goto fail_1;
70	}
71	goto win;
72	}
73	fprintf(stderr, "%s: Can't find new file to update `%s'\n", ego, name);
74	goto fail_1;
75
76	win:
77	if (chmod(n, mode)) {
78	fprintf(stderr, "%s: Can't set permissions on `%s': %s\n",
79	ego, n, strerror(errno));
80	goto fail_2;
81	}
82	if ((fp = fdopen(fd, "w")) == 0) {
83	fprintf(stderr, "%s: fdopen on `%s' failed: %s\n",
84	ego, n, strerror(errno));
85	goto fail_2;
86	}
87	*newname = n;
88	return (fp);
89
90	fail_2:
91	close(fd);
92	fail_1:
93	free(n);
94	fail_0:
95	return (0);
96	}
97
98	typedef struct buf {
99	char *b;
100	size_t n;
101	size_t sz;
102	} buf;
103	#define BUF_INIT { 0, 0, 0 }
104
105	static void reset(buf *b) { b->n = 0; }
106
107	static int put(buf *b, int ch)
108	{
109	size_t w;
110
111	if (b->n >= b->sz) {
112	if (!b->sz) {
113	w = 64;
114	b->b = malloc(w);
115	} else {
116	w = b->sz * 2;
117	b->b = realloc(b->b, w);
118	}
119	if (!b->b) {
120	fprintf(stderr, "%s: Not enough memory for buffer!\n", ego);
121	return (-1);
122	}
123	b->sz = w;
124	}
125	b->b[b->n++] = ch;
126	return (0);
127	}
128
129	#define TABSTOP(n) (((n) + 8u) & ~7u)
130
131	static int space(const char *name)
132	{
133	static buf b = BUF_INIT;
134	FILE fin, fout = stdout;
135	char newname = 0, oldname = 0;
136	int rc = TROUBLE, status = OK;
137	int last = '\n';
138	unsigned nsp = 0, nwsp = 0, hpos = 0, ohpos = 0, nhpos = 0, nl = 1;
139	unsigned i;
140	#define f_newline 1u
141	#define f_warnspacetab 2u
142	#define f_tabify 4u
143	#define f_warntabs 8u
144	#define f_warnspaces 16u
145	#define f_tab 32u
146	#define f_bad 64u
147	#define f_forced 128u
148	unsigned f = f_newline \| (flags & F_TABIFY ? f_tabify : 0);
149	int ch;
150
151	if (strcmp(name, "-") == 0) {
152	if (flags & F_INPLACE) {
153	fprintf(stderr, "%s: Can't modify stdin in-place.\n", ego);
154	goto done_0;
155	}
156	fin = stdin;
157	} else {
158	if ((fin = fopen(name, "r")) == 0) {
159	fprintf(stderr, "%s: Failed to open file `%s': %s.\n",
160	ego, name, strerror(errno));
161	goto done_0;
162	}
163	else if (flags & F_INPLACE) {
164	struct stat st;
165	if (stat(name, &st)) {
166	fprintf(stderr, "%s: Can't stat `%s': %s.\n",
167	ego, name, strerror(errno));
168	goto done_1;
169	}
170	if ((fout = freshname(name, &newname, st.st_mode)) == 0)
171	goto done_1;
172	}
173	}
174	if (flags & F_CHECK)
175	fout = 0;
176
177	for (;;) {
178	ch = getc(fin);
179	switch (ch) {
180	case ' ':
181	nsp++; nwsp++; hpos++;
182	if (put(&b, ' ')) goto done_2;
183	break;
184	case '\t':
185	if (flags & F_UNTABIFY) {
f4ed186a	186	if ((flags & F_VERBOSE) && !(f & f_warntabs)) {
df33ee54 MW	187	fprintf(stderr, "%s:%u: found tab\n", name, nl);
df33ee54 MW	188	f \|= f_warntabs;
df33ee54	189	}
f4ed186a	190	status = BADNESS;
df33ee54 MW	191	} else if (((flags & F_MIDLINETABS) \|\| (f & f_newline)) && nsp) {
	192	if ((flags & F_VERBOSE) && !(f & f_warnspacetab)) {
	193	fprintf(stderr, "%s:%u: space followed by tab\n", name, nl);
	194	f \|= f_warnspacetab;
df33ee54	195	}
f4ed186a	196	status = BADNESS;
df33ee54 MW	197	f \|= f_tabify \| f_forced;
	198	}
	199	f \|= f_tab;
	200	nsp = 0; nwsp++; hpos = TABSTOP(hpos);
	201	if (put(&b, '\t')) goto done_2;
	202	break;
	203	case EOF:
	204	if (nwsp \|\| !(f & f_newline)) {
	205	if (flags & F_VERBOSE)
	206	fprintf(stderr, "%s:%u: file ends in mid-line\n", name, nl);
	207	status = BADNESS;
	208	if (fout) putc('\n', fout);
	209	}
	210	goto end;
	211	case '\n':
	212	case '\v':
f4ed186a MW	213	if (nwsp) {
	214	if (flags & F_VERBOSE)
	215	fprintf(stderr, "%s:%u: trailing whitespace\n", name, nl);
df33ee54 MW	216	status = BADNESS;
	217	}
	218	if (fout) putc('\n', fout);
	219	reset(&b);
	220	nsp = nwsp = hpos = ohpos = 0; nl++;
	221	f \|= f_newline;
	222	f &= ~(f_tab \| f_warnspacetab \| f_warntabs \| f_warnspaces);
	223	if (flags & F_TABIFY)
	224	f \|= f_tabify;
	225	else
	226	f &= ~f_tabify;
	227	last = '\n';
	228	break;
	229	default:
	230	if (nwsp) {
	231	if (flags & F_UNTABIFY) {
	232	if (fout) for (; ohpos < hpos; ohpos++) putc(' ', fout);
	233	} else if ((f & f_tabify) &&
	234	((hpos - ohpos >= (last == '.' \|\| last == ':' ?
	235	3 : 2)) \|\|
	236	(f & (f_tab \| f_newline)))) {
	237	i = 0;
	238	for (;;) {
	239	nhpos = TABSTOP(ohpos);
	240	if (nhpos > hpos) break;
	241	if (fout) putc('\t', fout);
	242	if ((flags & F_VERBOSE) && (flags & F_TABIFY) &&
	243	i < b.n && b.b[i] != '\t' &&
	244	!(f & (f_warnspaces \| f_forced))) {
	245	fprintf(stderr, "%s:%u: spaces could be turned into tabs\n",
	246	name, nl);
	247	f \|= f_warnspaces;
	248	}
	249	ohpos = nhpos;
	250	i++;
	251	}
	252	if (fout)
	253	for (; ohpos < hpos; ohpos++) putc(' ', fout);
	254	} else if (fout)
	255	for (i = 0; i < b.n; i++) putc(b.b[i], fout);
	256	}
	257	reset(&b);
	258	f &= ~(f_newline \| f_tab \| f_forced);
	259	if (!(flags & F_TABIFY) \|\| !(flags & F_MIDLINETABS)) f &= ~f_tabify;
	260	nwsp = nsp = 0;
	261	hpos++; ohpos = hpos;
	262	if (fout) putc(ch, fout);
	263	if (ch != '"' && ch != '\'')
	264	last = ch;
	265	break;
	266	}
	267	}
	268	end:;
	269
	270	if (ferror(fin)) {
	271	fprintf(stderr, "%s: Error reading `%s': %s\n",
	272	ego, name, strerror(errno));
	273	goto done_2;
	274	}
	275
	276	if (fout) {
	277	if (fflush(fout) \|\| ferror(fout)) f \|= f_bad;
	278	if (fout != stdout && fclose(fout)) f \|= f_bad;
	279	fout = 0;
280	if (f & f_bad) {
281	fprintf(stderr, "%s: Error writing `%s': %s\n",
282	ego, newname, strerror(errno));
283	goto done_2;
284	}
285	}
286
287	if (flags & F_INPLACE) {
288	if (bkp) {
289	if ((oldname = augment(name, bkp)) == 0)
290	goto done_2;
291	if (rename(name, oldname)) {
292	fprintf(stderr, "%s: Failed to back up `%s' as `%s': %s\n",
293	ego, name, oldname, strerror(errno));
294	goto done_2;
295	}
296	}
297	if (rename(newname, name)) {
298	if (oldname) rename(oldname, name);
299	fprintf(stderr, "%s: Failed to install `%s' as `%s': %s\n",
300	ego, newname, name, strerror(errno));
301	goto done_2;
302	}
303	}
304
305	rc = status;
306
307	done_2:
308	if (oldname) free(oldname);
309	if (newname) {
310	remove(newname);
311	free(newname);
312	}
313	done_1:
314	if (fout && fout != stdout) fclose(fout);
315	fclose(fin);
316	done_0:
317	return (rc);
318	}
319
320	static int manysetp(unsigned f) { return (!!(f & (f - 1))); }
321
322	int main(int argc, char *argv[])
323	{
324	int i;
325	int rc = OK, st;
326
327	if ((ego = strrchr(argv[0], '/')) == 0)
328	ego = argv[0];
329	else
330	ego++;
331
332	for (;;) {
333	if ((i = getopt(argc, argv, "h" "cmtuv" "i::")) < 0)
334	break;
335	switch (i) {
336	case 'h':
337	printf("%s -- remove extraneous spaces from files\n\n", ego);
338	usage(stdout);
339	fputs("Options:\n\
340	-h Print this help text\n\
341	-c Check files for badness, but don't produce other output\n\
342	-m Fix spaces followed by tabs in mid-line\n\
343	-t Tabify file completely\n\
344	-u Untabify file completely\n\
345	-i[BKP] Modify files in place; leave FILEBKP as copy of old FILE\n\
346	", stdout);
347	exit(0);
348	case 'i':
349	bkp = optarg;
350	flags \|= F_INPLACE;
351	break;
352	case 'm':
353	flags \|= F_MIDLINETABS;
354	break;
355	case 'c':
356	flags \|= F_CHECK;
357	break;
358	case 't':
359	flags \|= F_TABIFY;
360	break;
361	case 'u':
362	flags \|= F_UNTABIFY;
363	break;
364	case 'v':
365	flags \|= F_VERBOSE;
366	break;
367	default:
368	flags \|= F_BOGUS;
369	break;
370	}
371	}
372	if (flags & F_BOGUS) {
373	usage(stderr);
374	exit(TROUBLE);
375	}
376	if (manysetp(flags & (F_CHECK \| F_INPLACE))) {
377	fprintf(stderr, "%s: Options -c and -i are mutually exclusive.\n", ego);
378	exit(TROUBLE);
379	}
380	if (manysetp(flags & (F_TABIFY \| F_UNTABIFY))) {
381	fprintf(stderr, "%s: Options -t and -u are mutually exclusive.\n", ego);
382	exit(TROUBLE);
383	}
384
385	if (optind == argc) {
386	if (isatty(0)) {
387	fprintf(stderr, "%s: No options given and stdin is a terminal.\n",
388	ego);
389	exit(TROUBLE);
390	}
391	rc = space("-");
392	} else for (i = optind; i < argc; i++) {
393	st = space(argv[i]);
394	if (st > rc) rc = st;
395	}
396	if (rc == BADNESS && !(flags & F_CHECK))
397	rc = OK;
398	return (rc);
399	}