Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/cmode.c	Lines:	0	159	0.0 %
Date:	2017-11-07	Branches:	0	142	0.0 %


/* $OpenBSD: cmode.c,v 1.16 2015/09/26 21:51:58 jasper Exp $ */
/*
 * This file is in the public domain.
 *
 * Author: Kjell Wooding <kjell@openbsd.org>
 */

/*
 * Implement an non-irritating KNF-compliant mode for editing
 * C code.
 */

#include <sys/queue.h>
#include <ctype.h>
#include <signal.h>
#include <stdio.h>

#include "def.h"
#include "funmap.h"
#include "kbd.h"

/* Pull in from modes.c */
extern int changemode(int, int, char *);

static int cc_strip_trailp = TRUE;	/* Delete Trailing space? */
static int cc_basic_indent = 8;		/* Basic Indent multiple */
static int cc_cont_indent = 4;		/* Continued line indent */
static int cc_colon_indent = -8;	/* Label / case indent */

static int getmatch(int, int);
static int getindent(const struct line *, int *);
static int in_whitespace(struct line *, int);
static int findcolpos(const struct buffer *, const struct line *, int);
static struct line *findnonblank(struct line *);
static int isnonblank(const struct line *, int);

void cmode_init(void);
int cc_comment(int, int);

/* Keymaps */

static PF cmode_brace[] = {
	cc_brace,	/* } */
};

static PF cmode_cCP[] = {
	compile,		/* C-c P */
};


static PF cmode_cc[] = {
	NULL,		/* ^C */
	rescan,		/* ^D */
	rescan,		/* ^E */
	rescan,		/* ^F */
	rescan,		/* ^G */
	rescan,		/* ^H */
	cc_tab,		/* ^I */
	rescan,		/* ^J */
	rescan,		/* ^K */
	rescan,		/* ^L */
	cc_lfindent,	/* ^M */
};

static PF cmode_spec[] = {
	cc_char,	/* : */
};

static struct KEYMAPE (1) cmode_cmap = {
	1,
	1,
	rescan,
	{
		{ 'P', 'P', cmode_cCP, NULL }
	}
};

static struct KEYMAPE (3) cmodemap = {
	3,
	3,
	rescan,
	{
		{ CCHR('C'), CCHR('M'), cmode_cc, (KEYMAP *) &cmode_cmap },
		{ ':', ':', cmode_spec, NULL },
		{ '}', '}', cmode_brace, NULL }
	}
};

/* Funtion, Mode hooks */

void
cmode_init(void)
{
	funmap_add(cmode, "c-mode");
	funmap_add(cc_char, "c-handle-special-char");
	funmap_add(cc_brace, "c-handle-special-brace");
	funmap_add(cc_tab, "c-tab-or-indent");
	funmap_add(cc_indent, "c-indent");
	funmap_add(cc_lfindent, "c-indent-and-newline");
	maps_add((KEYMAP *)&cmodemap, "c");
}

/*
 * Enable/toggle c-mode
 */
int
cmode(int f, int n)
{
	return(changemode(f, n, "c"));
}

/*
 * Handle special C character - selfinsert then indent.
 */
int
cc_char(int f, int n)
{
	if (n < 0)
		return (FALSE);
	if (selfinsert(FFRAND, n) == FALSE)
		return (FALSE);
	return (cc_indent(FFRAND, n));
}

/*
 * Handle special C character - selfinsert then indent.
 */
int
cc_brace(int f, int n)
{
	if (n < 0)
		return (FALSE);
	if (showmatch(FFRAND, 1) == FALSE)
		return (FALSE);
	return (cc_indent(FFRAND, n));
}


/*
 * If we are in the whitespace at the beginning of the line,
 * simply act as a regular tab. If we are not, indent
 * current line according to whitespace rules.
 */
int
cc_tab(int f, int n)
{
	int inwhitep = FALSE;	/* In leading whitespace? */

	inwhitep = in_whitespace(curwp->w_dotp, llength(curwp->w_dotp));

	/* If empty line, or in whitespace */
	if (llength(curwp->w_dotp) == 0 || inwhitep)
		return (selfinsert(f, n));

	return (cc_indent(FFRAND, 1));
}

/*
 * Attempt to indent current line according to KNF rules.
 */
int
cc_indent(int f, int n)
{
	int pi, mi;			/* Previous indents (mi is ignored) */
	int ci;				/* current indent */
	struct line *lp;
	int ret;

	if (n < 0)
		return (FALSE);

	undo_boundary_enable(FFRAND, 0);
	if (cc_strip_trailp)
		deltrailwhite(FFRAND, 1);

	/*
	 * Search backwards for a non-blank, non-preprocessor,
	 * non-comment line
	 */

	lp = findnonblank(curwp->w_dotp);

	pi = getindent(lp, &mi);

	/* Strip leading space on current line */
	delleadwhite(FFRAND, 1);
	/* current indent is computed only to current position */
	(void)getindent(curwp->w_dotp, &ci);

	if (pi + ci < 0)
		ret = indent(FFOTHARG, 0);
	else
		ret = indent(FFOTHARG, pi + ci);

	undo_boundary_enable(FFRAND, 1);

	return (ret);
}

/*
 * Indent-and-newline (technically, newline then indent)
 */
int
cc_lfindent(int f, int n)
{
	if (n < 0)
		return (FALSE);
	if (enewline(FFRAND, 1) == FALSE)
		return (FALSE);
	return (cc_indent(FFRAND, n));
}

/*
 * Get the level of indention after line lp is processed
 * Note getindent has two returns:
 * curi = value if indenting current line.
 * return value = value affecting subsequent lines.
 */
static int
getindent(const struct line *lp, int *curi)
{
	int lo, co;		/* leading space,  current offset*/
	int nicol = 0;		/* position count */
	int c = '\0';		/* current char */
	int newind = 0;		/* new index value */
	int stringp = FALSE;	/* in string? */
	int escp = FALSE;	/* Escape char? */
	int lastc = '\0';	/* Last matched string delimeter */
	int nparen = 0;		/* paren count */
	int obrace = 0;		/* open brace count */
	int cbrace = 0;		/* close brace count */
	int firstnwsp = FALSE;	/* First nonspace encountered? */
	int colonp = FALSE;	/* Did we see a colon? */
	int questionp = FALSE;	/* Did we see a question mark? */
	int slashp = FALSE;	/* Slash? */
	int astp = FALSE;	/* Asterisk? */
	int cpos = -1;		/* comment position */
	int cppp  = FALSE;	/* Preprocessor command? */

	*curi = 0;

	/* Compute leading space */
	for (lo = 0; lo < llength(lp); lo++) {
		if (!isspace(c = lgetc(lp, lo)))
			break;
		if (c == '\t'
#ifdef NOTAB
		    && !(curbp->b_flag & BFNOTAB)
#endif /* NOTAB */
		    ) {
			nicol |= 0x07;
		}
		nicol++;
	}

	/* If last line was blank, choose 0 */
	if (lo == llength(lp))
		nicol = 0;

	newind = 0;
	/* Compute modifiers */
	for (co = lo; co < llength(lp); co++) {
		c = lgetc(lp, co);
		/* We have a non-whitespace char */
		if (!firstnwsp && !isspace(c)) {
			if (c == '#')
				cppp = TRUE;
			firstnwsp = TRUE;
		}
		if (c == '\\')
			escp = !escp;
		else if (stringp) {
			if (!escp && (c == '"' || c == '\'')) {
				/* unescaped string char */
				if (getmatch(c, lastc))
					stringp = FALSE;
			}
		} else if (c == '"' || c == '\'') {
			stringp = TRUE;
			lastc = c;
		} else if (c == '(') {
			nparen++;
		} else if (c == ')') {
			nparen--;
		} else if (c == '{') {
			obrace++;
			firstnwsp = FALSE;
		} else if (c == '}') {
			cbrace++;
		} else if (c == '?') {
			questionp = TRUE;
		} else if (c == ':') {
			/* ignore (foo ? bar : baz) construct */
			if (!questionp)
				colonp = TRUE;
		} else if (c == '/') {
			/* first nonwhitespace? -> indent */
			if (firstnwsp) {
				/* If previous char asterisk -> close */
				if (astp)
					cpos = -1;
				else
					slashp = TRUE;
			}
		} else if (c == '*') {
			/* If previous char slash -> open */
			if (slashp)
				cpos = co;
			else
				astp = TRUE;
		} else if (firstnwsp) {
			firstnwsp = FALSE;
		}

		/* Reset matches that apply to next character only */
		if (c != '\\')
			escp = FALSE;
		if (c != '*')
			astp = FALSE;
		if (c != '/')
			slashp = FALSE;
	}
	/*
	 * If not terminated with a semicolon, and brace or paren open.
	 * we continue
	 */
	if (colonp) {
		*curi += cc_colon_indent;
		newind -= cc_colon_indent;
	}

	*curi -= (cbrace) * cc_basic_indent;
	newind += obrace * cc_basic_indent;

	if (nparen < 0)
		newind -= cc_cont_indent;
	else if (nparen > 0)
		newind += cc_cont_indent;

	*curi += nicol;

	/* Ignore preprocessor. Otherwise, add current column */
	if (cppp) {
		newind = nicol;
		*curi = 0;
	} else {
		newind += nicol;
	}

	if (cpos != -1)
		newind = findcolpos(curbp, lp, cpos);

	return (newind);
}

/*
 * Given a delimeter and its purported mate, tell us if they
 * match.
 */
static int
getmatch(int c, int mc)
{
	int match = FALSE;

	switch (c) {
	case '"':
		match = (mc == '"');
		break;
	case '\'':
		match = (mc == '\'');
		break;
	case '(':
		match = (mc == ')');
		break;
	case '[':
		match = (mc == ']');
		break;
	case '{':
		match = (mc == '}');
		break;
	}

	return (match);
}

static int
in_whitespace(struct line *lp, int len)
{
	int lo;
	int inwhitep = FALSE;

	for (lo = 0; lo < len; lo++) {
		if (!isspace(lgetc(lp, lo)))
			break;
		if (lo == len - 1)
			inwhitep = TRUE;
	}

	return (inwhitep);
}


/* convert a line/offset pair to a column position (for indenting) */
static int
findcolpos(const struct buffer *bp, const struct line *lp, int lo)
{
	int	col, i, c;
	char tmp[5];

	/* determine column */
	col = 0;

	for (i = 0; i < lo; ++i) {
		c = lgetc(lp, i);
		if (c == '\t'
#ifdef NOTAB
		    && !(bp->b_flag & BFNOTAB)
#endif /* NOTAB */
			) {
			col |= 0x07;
			col++;
		} else if (ISCTRL(c) != FALSE)
			col += 2;
		else if (isprint(c)) {
			col++;
		} else {
			col += snprintf(tmp, sizeof(tmp), "\\%o", c);
		}

	}
	return (col);
}

/*
 * Find a non-blank line, searching backwards from the supplied line pointer.
 * For C, nonblank is non-preprocessor, non C++, and accounts
 * for complete C-style comments.
 */
static struct line *
findnonblank(struct line *lp)
{
	int lo;
	int nonblankp = FALSE;
	int commentp = FALSE;
	int slashp;
	int astp;
	int c;

	while (lback(lp) != curbp->b_headp && (commentp || !nonblankp)) {
		lp = lback(lp);
		slashp = FALSE;
		astp = FALSE;

		/* Potential nonblank? */
		nonblankp = isnonblank(lp, llength(lp));

		/*
		 * Search from end, removing complete C-style
		 * comments. If one is found, ignore it and
		 * test for nonblankness from where it starts.
		 */
		for (lo = llength(lp) - 1; lo >= 0; lo--) {
			if (!isspace(c = lgetc(lp, lo))) {
				if (commentp) { /* find comment "open" */
					if (c == '*')
						astp = TRUE;
					else if (astp && c == '/') {
						commentp = FALSE;
						/* whitespace to here? */
						nonblankp = isnonblank(lp, lo);
					}
				} else { /* find comment "close" */
					if (c == '/')
						slashp = TRUE;
					else if (slashp && c == '*')
						/* found a comment */
						commentp = TRUE;
				}
			}
		}
	}

	/* Rewound to start of file? */
	if (lback(lp) == curbp->b_headp && !nonblankp)
		return (curbp->b_headp);

	return (lp);
}

/*
 * Given a line, scan forward to 'omax' and determine if we
 * are all C whitespace.
 * Note that preprocessor directives and C++-style comments
 * count as whitespace. C-style comments do not, and must
 * be handled elsewhere.
 */
static int
isnonblank(const struct line *lp, int omax)
{
	int nonblankp = FALSE;		/* Return value */
	int slashp = FALSE;		/* Encountered slash */
	int lo;				/* Loop index */
	int c;				/* char being read */

	/* Scan from front for preprocessor, C++ comments */
	for (lo = 0; lo < omax; lo++) {
		if (!isspace(c = lgetc(lp, lo))) {
			/* Possible nonblank line */
			nonblankp = TRUE;
			/* skip // and # starts */
			if (c == '#' || (slashp && c == '/')) {
				nonblankp = FALSE;
				break;
			} else if (!slashp && c == '/') {
				slashp = TRUE;
				continue;
			}
		}
		slashp = FALSE;
	}
	return (nonblankp);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: cmode.c,v 1.16 2015/09/26 21:51:58 jasper Exp $ */
2			/*
3			* This file is in the public domain.
4			*
5			* Author: Kjell Wooding <kjell@openbsd.org>
6			*/
7
8			/*
9			* Implement an non-irritating KNF-compliant mode for editing
10			* C code.
11			*/
12
13			#include <sys/queue.h>
14			#include <ctype.h>
15			#include <signal.h>
16			#include <stdio.h>
17
18			#include "def.h"
19			#include "funmap.h"
20			#include "kbd.h"
21
22			/* Pull in from modes.c */
23			extern int changemode(int, int, char *);
24
25			static int cc_strip_trailp = TRUE; /* Delete Trailing space? */
26			static int cc_basic_indent = 8; /* Basic Indent multiple */
27			static int cc_cont_indent = 4; /* Continued line indent */
28			static int cc_colon_indent = -8; /* Label / case indent */
29
30			static int getmatch(int, int);
31			static int getindent(const struct line , int );
32			static int in_whitespace(struct line *, int);
33			static int findcolpos(const struct buffer , const struct line , int);
34			static struct line findnonblank(struct line );
35			static int isnonblank(const struct line *, int);
36
37			void cmode_init(void);
38			int cc_comment(int, int);
39
40			/* Keymaps */
41
42			static PF cmode_brace[] = {
43			cc_brace, /* } */
44			};
45
46			static PF cmode_cCP[] = {
47			compile, /* C-c P */
48			};
49
50
51			static PF cmode_cc[] = {
52			NULL, /* ^C */
53			rescan, /* ^D */
54			rescan, /* ^E */
55			rescan, /* ^F */
56			rescan, /* ^G */
57			rescan, /* ^H */
58			cc_tab, /* ^I */
59			rescan, /* ^J */
60			rescan, /* ^K */
61			rescan, /* ^L */
62			cc_lfindent, /* ^M */
63			};
64
65			static PF cmode_spec[] = {
66			cc_char, /* : */
67			};
68
69			static struct KEYMAPE (1) cmode_cmap = {
70			1,
71			1,
72			rescan,
73			{
74			{ 'P', 'P', cmode_cCP, NULL }
75			}
76			};
77
78			static struct KEYMAPE (3) cmodemap = {
79			3,
80			3,
81			rescan,
82			{
83			{ CCHR('C'), CCHR('M'), cmode_cc, (KEYMAP *) &cmode_cmap },
84			{ ':', ':', cmode_spec, NULL },
85			{ '}', '}', cmode_brace, NULL }
86			}
87			};
88
89			/* Funtion, Mode hooks */
90
91			void
92			cmode_init(void)
93			{
94			funmap_add(cmode, "c-mode");
95			funmap_add(cc_char, "c-handle-special-char");
96			funmap_add(cc_brace, "c-handle-special-brace");
97			funmap_add(cc_tab, "c-tab-or-indent");
98			funmap_add(cc_indent, "c-indent");
99			funmap_add(cc_lfindent, "c-indent-and-newline");
100			maps_add((KEYMAP *)&cmodemap, "c");
101			}
102
103			/*
104			* Enable/toggle c-mode
105			*/
106			int
107			cmode(int f, int n)
108			{
109			return(changemode(f, n, "c"));
110			}
111
112			/*
113			* Handle special C character - selfinsert then indent.
114			*/
115			int
116			cc_char(int f, int n)
117			{
118			if (n < 0)
119			return (FALSE);
120			if (selfinsert(FFRAND, n) == FALSE)
121			return (FALSE);
122			return (cc_indent(FFRAND, n));
123			}
124
125			/*
126			* Handle special C character - selfinsert then indent.
127			*/
128			int
129			cc_brace(int f, int n)
130			{
131			if (n < 0)
132			return (FALSE);
133			if (showmatch(FFRAND, 1) == FALSE)
134			return (FALSE);
135			return (cc_indent(FFRAND, n));
136			}
137
138
139			/*
140			* If we are in the whitespace at the beginning of the line,
141			* simply act as a regular tab. If we are not, indent
142			* current line according to whitespace rules.
143			*/
144			int
145			cc_tab(int f, int n)
146			{
147			int inwhitep = FALSE; /* In leading whitespace? */
148
149			inwhitep = in_whitespace(curwp->w_dotp, llength(curwp->w_dotp));
150
151			/* If empty line, or in whitespace */
152			if (llength(curwp->w_dotp) == 0 \|\| inwhitep)
153			return (selfinsert(f, n));
154
155			return (cc_indent(FFRAND, 1));
156			}
157
158			/*
159			* Attempt to indent current line according to KNF rules.
160			*/
161			int
162			cc_indent(int f, int n)
163			{
164			int pi, mi; /* Previous indents (mi is ignored) */
165			int ci; /* current indent */
166			struct line *lp;
167			int ret;
168
169			if (n < 0)
170			return (FALSE);
171
172			undo_boundary_enable(FFRAND, 0);
173			if (cc_strip_trailp)
174			deltrailwhite(FFRAND, 1);
175
176			/*
177			* Search backwards for a non-blank, non-preprocessor,
178			* non-comment line
179			*/
180
181			lp = findnonblank(curwp->w_dotp);
182
183			pi = getindent(lp, &mi);
184
185			/* Strip leading space on current line */
186			delleadwhite(FFRAND, 1);
187			/* current indent is computed only to current position */
188			(void)getindent(curwp->w_dotp, &ci);
189
190			if (pi + ci < 0)
191			ret = indent(FFOTHARG, 0);
192			else
193			ret = indent(FFOTHARG, pi + ci);
194
195			undo_boundary_enable(FFRAND, 1);
196
197			return (ret);
198			}
199
200			/*
201			* Indent-and-newline (technically, newline then indent)
202			*/
203			int
204			cc_lfindent(int f, int n)
205			{
206			if (n < 0)
207			return (FALSE);
208			if (enewline(FFRAND, 1) == FALSE)
209			return (FALSE);
210			return (cc_indent(FFRAND, n));
211			}
212
213			/*
214			* Get the level of indention after line lp is processed
215			* Note getindent has two returns:
216			* curi = value if indenting current line.
217			* return value = value affecting subsequent lines.
218			*/
219			static int
220			getindent(const struct line lp, int curi)
221			{
222			int lo, co; /* leading space, current offset*/
223			int nicol = 0; /* position count */
224			int c = '\0'; /* current char */
225			int newind = 0; /* new index value */
226			int stringp = FALSE; /* in string? */
227			int escp = FALSE; /* Escape char? */
228			int lastc = '\0'; /* Last matched string delimeter */
229			int nparen = 0; /* paren count */
230			int obrace = 0; /* open brace count */
231			int cbrace = 0; /* close brace count */
232			int firstnwsp = FALSE; /* First nonspace encountered? */
233			int colonp = FALSE; /* Did we see a colon? */
234			int questionp = FALSE; /* Did we see a question mark? */
235			int slashp = FALSE; /* Slash? */
236			int astp = FALSE; /* Asterisk? */
237			int cpos = -1; /* comment position */
238			int cppp = FALSE; /* Preprocessor command? */
239
240			*curi = 0;
241
242			/* Compute leading space */
243			for (lo = 0; lo < llength(lp); lo++) {
244			if (!isspace(c = lgetc(lp, lo)))
245			break;
246			if (c == '\t'
247			#ifdef NOTAB
248			&& !(curbp->b_flag & BFNOTAB)
249			#endif /* NOTAB */
250			) {
251			nicol \|= 0x07;
252			}
253			nicol++;
254			}
255
256			/* If last line was blank, choose 0 */
257			if (lo == llength(lp))
258			nicol = 0;
259
260			newind = 0;
261			/* Compute modifiers */
262			for (co = lo; co < llength(lp); co++) {
263			c = lgetc(lp, co);
264			/* We have a non-whitespace char */
265			if (!firstnwsp && !isspace(c)) {
266			if (c == '#')
267			cppp = TRUE;
268			firstnwsp = TRUE;
269			}
270			if (c == '\\')
271			escp = !escp;
272			else if (stringp) {
273			if (!escp && (c == '"' \|\| c == '\'')) {
274			/* unescaped string char */
275			if (getmatch(c, lastc))
276			stringp = FALSE;
277			}
278			} else if (c == '"' \|\| c == '\'') {
279			stringp = TRUE;
280			lastc = c;
281			} else if (c == '(') {
282			nparen++;
283			} else if (c == ')') {
284			nparen--;
285			} else if (c == '{') {
286			obrace++;
287			firstnwsp = FALSE;
288			} else if (c == '}') {
289			cbrace++;
290			} else if (c == '?') {
291			questionp = TRUE;
292			} else if (c == ':') {
293			/* ignore (foo ? bar : baz) construct */
294			if (!questionp)
295			colonp = TRUE;
296			} else if (c == '/') {
297			/* first nonwhitespace? -> indent */
298			if (firstnwsp) {
299			/* If previous char asterisk -> close */
300			if (astp)
301			cpos = -1;
302			else
303			slashp = TRUE;
304			}
305			} else if (c == '*') {
306			/* If previous char slash -> open */
307			if (slashp)
308			cpos = co;
309			else
310			astp = TRUE;
311			} else if (firstnwsp) {
312			firstnwsp = FALSE;
313			}
314
315			/* Reset matches that apply to next character only */
316			if (c != '\\')
317			escp = FALSE;
318			if (c != '*')
319			astp = FALSE;
320			if (c != '/')
321			slashp = FALSE;
322			}
323			/*
324			* If not terminated with a semicolon, and brace or paren open.
325			* we continue
326			*/
327			if (colonp) {
328			*curi += cc_colon_indent;
329			newind -= cc_colon_indent;
330			}
331
332			curi -= (cbrace) cc_basic_indent;
333			newind += obrace * cc_basic_indent;
334
335			if (nparen < 0)
336			newind -= cc_cont_indent;
337			else if (nparen > 0)
338			newind += cc_cont_indent;
339
340			*curi += nicol;
341
342			/* Ignore preprocessor. Otherwise, add current column */
343			if (cppp) {
344			newind = nicol;
345			*curi = 0;
346			} else {
347			newind += nicol;
348			}
349
350			if (cpos != -1)
351			newind = findcolpos(curbp, lp, cpos);
352
353			return (newind);
354			}
355
356			/*
357			* Given a delimeter and its purported mate, tell us if they
358			* match.
359			*/
360			static int
361			getmatch(int c, int mc)
362			{
363			int match = FALSE;
364
365			switch (c) {
366			case '"':
367			match = (mc == '"');
368			break;
369			case '\'':
370			match = (mc == '\'');
371			break;
372			case '(':
373			match = (mc == ')');
374			break;
375			case '[':
376			match = (mc == ']');
377			break;
378			case '{':
379			match = (mc == '}');
380			break;
381			}
382
383			return (match);
384			}
385
386			static int
387			in_whitespace(struct line *lp, int len)
388			{
389			int lo;
390			int inwhitep = FALSE;
391
392			for (lo = 0; lo < len; lo++) {
393			if (!isspace(lgetc(lp, lo)))
394			break;
395			if (lo == len - 1)
396			inwhitep = TRUE;
397			}
398
399			return (inwhitep);
400			}
401
402
403			/* convert a line/offset pair to a column position (for indenting) */
404			static int
405			findcolpos(const struct buffer bp, const struct line lp, int lo)
406			{
407			int col, i, c;
408			char tmp[5];
409
410			/* determine column */
411			col = 0;
412
413			for (i = 0; i < lo; ++i) {
414			c = lgetc(lp, i);
415			if (c == '\t'
416			#ifdef NOTAB
417			&& !(bp->b_flag & BFNOTAB)
418			#endif /* NOTAB */
419			) {
420			col \|= 0x07;
421			col++;
422			} else if (ISCTRL(c) != FALSE)
423			col += 2;
424			else if (isprint(c)) {
425			col++;
426			} else {
427			col += snprintf(tmp, sizeof(tmp), "\\%o", c);
428			}
429
430			}
431			return (col);
432			}
433
434			/*
435			* Find a non-blank line, searching backwards from the supplied line pointer.
436			* For C, nonblank is non-preprocessor, non C++, and accounts
437			* for complete C-style comments.
438			*/
439			static struct line *
440			findnonblank(struct line *lp)
441			{
442			int lo;
443			int nonblankp = FALSE;
444			int commentp = FALSE;
445			int slashp;
446			int astp;
447			int c;
448
449			while (lback(lp) != curbp->b_headp && (commentp \|\| !nonblankp)) {
450			lp = lback(lp);
451			slashp = FALSE;
452			astp = FALSE;
453
454			/* Potential nonblank? */
455			nonblankp = isnonblank(lp, llength(lp));
456
457			/*
458			* Search from end, removing complete C-style
459			* comments. If one is found, ignore it and
460			* test for nonblankness from where it starts.
461			*/
462			for (lo = llength(lp) - 1; lo >= 0; lo--) {
463			if (!isspace(c = lgetc(lp, lo))) {
464			if (commentp) { /* find comment "open" */
465			if (c == '*')
466			astp = TRUE;
467			else if (astp && c == '/') {
468			commentp = FALSE;
469			/* whitespace to here? */
470			nonblankp = isnonblank(lp, lo);
471			}
472			} else { /* find comment "close" */
473			if (c == '/')
474			slashp = TRUE;
475			else if (slashp && c == '*')
476			/* found a comment */
477			commentp = TRUE;
478			}
479			}
480			}
481			}
482
483			/* Rewound to start of file? */
484			if (lback(lp) == curbp->b_headp && !nonblankp)
485			return (curbp->b_headp);
486
487			return (lp);
488			}
489
490			/*
491			* Given a line, scan forward to 'omax' and determine if we
492			* are all C whitespace.
493			* Note that preprocessor directives and C++-style comments
494			* count as whitespace. C-style comments do not, and must
495			* be handled elsewhere.
496			*/
497			static int
498			isnonblank(const struct line *lp, int omax)
499			{
500			int nonblankp = FALSE; /* Return value */
501			int slashp = FALSE; /* Encountered slash */
502			int lo; /* Loop index */
503			int c; /* char being read */
504
505			/* Scan from front for preprocessor, C++ comments */
506			for (lo = 0; lo < omax; lo++) {
507			if (!isspace(c = lgetc(lp, lo))) {
508			/* Possible nonblank line */
509			nonblankp = TRUE;
510			/* skip // and # starts */
511			if (c == '#' \|\| (slashp && c == '/')) {
512			nonblankp = FALSE;
513			break;
514			} else if (!slashp && c == '/') {
515			slashp = TRUE;
516			continue;
517			}
518			}
519			slashp = FALSE;
520			}
521			return (nonblankp);
522			}