new copyright, cflag CIGNORE implements TCSASOFT

[unix-history] / usr / src / lib / libc / gen / vis.c

/*
 * Copyright (c) 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that the above copyright notice and this paragraph are
 * duplicated in all such forms and that any documentation,
 * advertising materials, and other materials related to such
 * distribution and use acknowledge that the software was developed
 * by the University of California, Berkeley.  The name of the
 * University may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid[] = "@(#)vis.c	5.2 (Berkeley) %G%";
#endif /* LIBC_SCCS and not lint */

#include <sys/types.h>
#include <ctype.h>
#include <cencode.h>

#define	isoctal(c)	(((u_char)(c)) >= '0' && ((u_char)(c)) <= '7')

/*
 * vis - visually encode characters
 */
char *
vis(dst, c, flag, nextc)
	register char *dst, c;
	char nextc;
	register int flag;
{
	if (isascii(c) && isgraph(c) ||
	   ((flag & VIS_WHITE) == 0 && 
		(c == ' ' || c == '\n' || (flag & VIS_TAB) == 0 && c == '\t')) ||
	   ((flag & VIS_SAFE) && (c == '\b' || c == '\007' || c == '\r'))) {
		*dst++ = c;
		if (c == '\\' && (flag & VIS_NOSLASH) == 0)
			*dst++ = '\\';
		*dst = '\0';
		return (dst);
	}

	if ((flag & VIS_NOSLASH) == 0)
		*dst++ = '\\';
	if (flag & VIS_CSTYLE) {
		switch(c) {
		case '\n':
			*dst++ = 'n';
			goto done;
		case '\r':
			*dst++ = 'r';
			goto done;
		case '\b':
			*dst++ = 'b';
			goto done;
		case '\007':	/* waiting for ansi compiler */
			*dst++ = 'a';
			goto done;
		case '\v':
			*dst++ = 'v';
			goto done;
		case '\t':
			*dst++ = 't';
			goto done;
		case '\f':
			*dst++ = 'f';
			goto done;
		case ' ':
			*dst++ = 's';
			goto done;
		case '\0':
			*dst++ = '0';
			if ((flag & VIS_NEXTC) == 0 || isoctal(nextc)) {
				*dst++ = '0';
				*dst++ = '0';
			}
			goto done;
		}
	}
	if (((c & 0177) == ' ') || (flag & VIS_OCTAL)) {	
		*dst++ = ((u_char)c >> 6 & 07) + '0';
		*dst++ = ((u_char)c >> 3 & 07) + '0';
		*dst++ = ((u_char)c & 07) + '0';
		goto done;
	}
	if (c & 0200) {
		c &= 0177;
		*dst++ = 'M';
	}
	if (iscntrl(c)) {
		*dst++ = '^';
		if (c == 0177)
			*dst++ = '?';
		else
			*dst++ = c + '@';
	} else {
		*dst++ = '-';
		*dst++ = c;
	}
done:
	*dst = '\0';
	return (dst);
}


/*
 * decode driven by state machine
 */
#define	S_NORMAL	1	/* haven't seen escape char */
#define	S_START		2	/* start decoding special sequence */
#define	S_META		3	/* metachar started (M) */
#define	S_META1		4	/* metachar more, regular char (-) */
#define	S_CTRL		5	/* control char started (^) */
#define	S_OCTAL		6	/* octal number */

/*
 *
 */
cunvis(c, cp, flags)
	char c;
	char *cp;
{
	static int state = S_NORMAL;
	static u_char buildchar;
	static int octal;

	if (flags&UNVIS_END) {
		int ostate = state;
		state = S_NORMAL;
		if (ostate == S_OCTAL) {
			*cp = buildchar;
			return(UNVIS_OK);
		} else if (ostate == S_META1) {
			/* slightly forgiving, if not wrong */
			*cp = ' ' | 0200;
			return(UNVIS_OK);
		} else
			return(ostate == S_NORMAL ? UNVIS_NOCHAR : CDEC_SYNBAD);
	}

	switch (state) {
	case S_NORMAL:
		buildchar = 0;
		if (c == '\\') {
			state = S_START;
			return(UNVIS_NEEDMORE);
		} else if (flags&UNVIS_HAT && c == '^') {
			state = S_CTRL;
			return(UNVIS_NEEDMORE);
		} else {
			*cp = c;
			return(UNVIS_OK);
		}
		break;
	case S_START:
		state = S_NORMAL;
		if (c == '\\') {
			*cp = c;
			return(UNVIS_OK);
		}
		if (isoctal(c)) {
			buildchar = (c-'0');
			octal = 1;
			state = S_OCTAL;
			return(UNVIS_NEEDMORE);
		} 
		switch(c) {
		case 'M':
			buildchar |= 0200;
			state = S_META;
			return(UNVIS_NEEDMORE);
		case '^':
			state = S_CTRL;
			return(UNVIS_NEEDMORE);
		case 'n':
			*cp = '\n';
			return(UNVIS_OK);
		case 'r':
			*cp = '\r';
			return(UNVIS_OK);
		case 'b':
			*cp = '\b';
			return(UNVIS_OK);
		case 'a':
			*cp = '\007';
			return(UNVIS_OK);
		case 'v':
			*cp = '\v';
			return(UNVIS_OK);
		case 't':
			*cp = '\t';
			return(UNVIS_OK);
		case 'f':
			*cp = '\f';
			return(UNVIS_OK);
		case 's':			/* does anyone use this ? */
			*cp = ' ';
			return(UNVIS_OK);
		case 'E':
			*cp = '\033';
			return(UNVIS_OK);
		case '\n':
			return(UNVIS_NOCHAR);	/* hidden newline */
		}
		state = S_NORMAL;
		return(UNVIS_SYNBAD);
	case S_META:
		if (c == '-')
			state = S_META1;
		else if (c == '^')
			state = S_CTRL;
		else {
			state = S_NORMAL;
			return(UNVIS_SYNBAD);
		}
		return(UNVIS_NEEDMORE);
	case S_META1:
		state = S_NORMAL;
		*cp = c | buildchar;
		return(UNVIS_OK);
	case S_CTRL:
		if (c == '?')
			buildchar |= 0177;
		else
			buildchar |= c&037;
		state = S_NORMAL;
		*cp = buildchar;
		return(UNVIS_OK);
	case S_OCTAL:
		if (isoctal(c)) {
			buildchar = (buildchar<<3) + (c-'0');
			if (++octal == 3) {
				state = S_NORMAL;
				*cp = buildchar;
				return(UNVIS_OK);
			} else
				return(UNVIS_NEEDMORE);
		} else {
			state = S_NORMAL;
			*cp = buildchar;
			return(UNVIS_OKPUSH);
		}
	}
}

/*
 * strvis - visually encode characters from src into dst
 *
 *	If len >= 0, encodes exactly len chars from src (including NULL's).
 *	Otherwise, stops before first NULL in src.  In all cases, dst is 
 *	NULL terminated.
 *
 *	Dst must be 4 times the size of src to account for possible
 *	expansion.  The length of dst, not including the trailing NULL,
 *	is returned.
 */
strvis(dst, src, len, flag)
	register char *dst, *src;
	register int len;
{
	char *start = dst;

	for (;;) {
		if (len > 0) { 
			if (len-- == 0)
				break;
		} else if (!*src)
			break;
		dst = vis(dst, *src, flag | VIS_NEXTC, *(src+1));
		src++;
	}

	return (dst - start);
}