Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/match.c	Lines:	0	59	0.0 %
Date:	2016-12-06	Branches:	0	36	0.0 %


/*	$OpenBSD: match.c,v 1.19 2015/06/03 23:40:01 bcallah Exp $	*/

/* This file is in the public domain. */

/*
 *	Limited parenthesis matching routines
 *
 * The hacks in this file implement automatic matching * of (), [], {}, and
 * other characters.  It would be better to have a full-blown syntax table,
 * but there's enough overhead in the editor as it is.
 */

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

#include "def.h"
#include "key.h"

static int	balance(void);
static void	displaymatch(struct line *, int);

/*
 * Balance table. When balance() encounters a character that is to be
 * matched, it first searches this table for a balancing left-side character.
 * If the character is not in the table, the character is balanced by itself.
 */
static struct balance {
	char	left, right;
} bal[] = {
	{ '(', ')' },
	{ '[', ']' },
	{ '{', '}' },
	{ '<', '>' },
	{ '\0', '\0' }
};

/*
 * Hack to show matching paren.  Self-insert character, then show matching
 * character, if any.  Bound to "blink-and-insert".
 */
int
showmatch(int f, int n)
{
	int	i, s;

	for (i = 0; i < n; i++) {
		if ((s = selfinsert(FFRAND, 1)) != TRUE)
			return (s);
		/* unbalanced -- warn user */
		if (balance() != TRUE)
			dobeep();
	}
	return (TRUE);
}

/*
 * Search for and display a matching character.
 *
 * This routine does the real work of searching backward
 * for a balancing character.  If such a balancing character
 * is found, it uses displaymatch() to display the match.
 */
static int
balance(void)
{
	struct line	*clp;
	int	 cbo;
	int	 c, i, depth;
	int	 rbal, lbal;

	rbal = key.k_chars[key.k_count - 1];

	/* See if there is a matching character -- default to the same */
	lbal = rbal;
	for (i = 0; bal[i].right != '\0'; i++)
		if (bal[i].right == rbal) {
			lbal = bal[i].left;
			break;
		}

	/*
	 * Move behind the inserted character.	We are always guaranteed
	 * that there is at least one character on the line.
	 */
	clp = curwp->w_dotp;
	cbo = curwp->w_doto - 1;

	/* init nesting depth */
	depth = 0;

	for (;;) {
		if (cbo == 0) {
			clp = lback(clp);	/* beginning of line	*/
			if (clp == curbp->b_headp)
				return (FALSE);
			cbo = llength(clp) + 1;
		}
		if (--cbo == llength(clp))
			c = '\n';		/* end of line		*/
		else
			c = lgetc(clp, cbo);	/* somewhere in middle	*/

		/*
		 * Check for a matching character.  If still in a nested
		 * level, pop out of it and continue search.  This check
		 * is done before the nesting check so single-character
		 * matches will work too.
		 */
		if (c == lbal) {
			if (depth == 0) {
				displaymatch(clp, cbo);
				return (TRUE);
			} else
				depth--;
		}
		/* Check for another level of nesting.	 */
		if (c == rbal)
			depth++;
	}
	/* NOTREACHED */
}

/*
 * Display matching character.  Matching characters that are not in the
 * current window are displayed in the echo line. If in the current window,
 * move dot to the matching character, sit there a while, then move back.
 */
static void
displaymatch(struct line *clp, int cbo)
{
	struct line	*tlp;
	int	 tbo;
	int	 cp;
	int	 bufo;
	int	 c;
	int	 inwindow;
	char	 buf[NLINE];

	/*
	 * Figure out if matching char is in current window by
	 * searching from the top of the window to dot.
	 */
	inwindow = FALSE;
	for (tlp = curwp->w_linep; tlp != lforw(curwp->w_dotp);
	    tlp = lforw(tlp))
		if (tlp == clp)
			inwindow = TRUE;

	if (inwindow == TRUE) {
		tlp = curwp->w_dotp;	/* save current position */
		tbo = curwp->w_doto;

		curwp->w_dotp = clp;	/* move to new position */
		curwp->w_doto = cbo;
		curwp->w_rflag |= WFMOVE;

		update(CMODE);		/* show match */
		ttwait(1000);		/* wait for key or 1 second */

		curwp->w_dotp = tlp;	/* return to old position */
		curwp->w_doto = tbo;
		curwp->w_rflag |= WFMOVE;
		update(CMODE);
	} else {
		/* match is not in this window, so display line in echo area */
		bufo = 0;
		for (cp = 0; cp < llength(clp); cp++) {
			c = lgetc(clp, cp);
			if (c != '\t'
#ifdef NOTAB
			    || (curbp->b_flag & BFNOTAB)
#endif
				)
				if (ISCTRL(c)) {
					buf[bufo++] = '^';
					buf[bufo++] = CCHR(c);
				} else
					buf[bufo++] = c;
			else
				do {
					buf[bufo++] = ' ';
				} while (bufo & 7);
		}
		buf[bufo++] = '\0';
		ewprintf("Matches %s", buf);
	}
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: match.c,v 1.19 2015/06/03 23:40:01 bcallah Exp $ */
2
3			/* This file is in the public domain. */
4
5			/*
6			* Limited parenthesis matching routines
7			*
8			* The hacks in this file implement automatic matching * of (), [], {}, and
9			* other characters. It would be better to have a full-blown syntax table,
10			* but there's enough overhead in the editor as it is.
11			*/
12
13			#include <sys/queue.h>
14			#include <signal.h>
15			#include <stdio.h>
16
17			#include "def.h"
18			#include "key.h"
19
20			static int balance(void);
21			static void displaymatch(struct line *, int);
22
23			/*
24			* Balance table. When balance() encounters a character that is to be
25			* matched, it first searches this table for a balancing left-side character.
26			* If the character is not in the table, the character is balanced by itself.
27			*/
28			static struct balance {
29			char left, right;
30			} bal[] = {
31			{ '(', ')' },
32			{ '[', ']' },
33			{ '{', '}' },
34			{ '<', '>' },
35			{ '\0', '\0' }
36			};
37
38			/*
39			* Hack to show matching paren. Self-insert character, then show matching
40			* character, if any. Bound to "blink-and-insert".
41			*/
42			int
43			showmatch(int f, int n)
44			{
45			int i, s;
46
47			for (i = 0; i < n; i++) {
48			if ((s = selfinsert(FFRAND, 1)) != TRUE)
49			return (s);
50			/* unbalanced -- warn user */
51			if (balance() != TRUE)
52			dobeep();
53			}
54			return (TRUE);
55			}
56
57			/*
58			* Search for and display a matching character.
59			*
60			* This routine does the real work of searching backward
61			* for a balancing character. If such a balancing character
62			* is found, it uses displaymatch() to display the match.
63			*/
64			static int
65			balance(void)
66			{
67			struct line *clp;
68			int cbo;
69			int c, i, depth;
70			int rbal, lbal;
71
72			rbal = key.k_chars[key.k_count - 1];
73
74			/* See if there is a matching character -- default to the same */
75			lbal = rbal;
76			for (i = 0; bal[i].right != '\0'; i++)
77			if (bal[i].right == rbal) {
78			lbal = bal[i].left;
79			break;
80			}
81
82			/*
83			* Move behind the inserted character. We are always guaranteed
84			* that there is at least one character on the line.
85			*/
86			clp = curwp->w_dotp;
87			cbo = curwp->w_doto - 1;
88
89			/* init nesting depth */
90			depth = 0;
91
92			for (;;) {
93			if (cbo == 0) {
94			clp = lback(clp); /* beginning of line */
95			if (clp == curbp->b_headp)
96			return (FALSE);
97			cbo = llength(clp) + 1;
98			}
99			if (--cbo == llength(clp))
100			c = '\n'; /* end of line */
101			else
102			c = lgetc(clp, cbo); /* somewhere in middle */
103
104			/*
105			* Check for a matching character. If still in a nested
106			* level, pop out of it and continue search. This check
107			* is done before the nesting check so single-character
108			* matches will work too.
109			*/
110			if (c == lbal) {
111			if (depth == 0) {
112			displaymatch(clp, cbo);
113			return (TRUE);
114			} else
115			depth--;
116			}
117			/* Check for another level of nesting. */
118			if (c == rbal)
119			depth++;
120			}
121			/* NOTREACHED */
122			}
123
124			/*
125			* Display matching character. Matching characters that are not in the
126			* current window are displayed in the echo line. If in the current window,
127			* move dot to the matching character, sit there a while, then move back.
128			*/
129			static void
130			displaymatch(struct line *clp, int cbo)
131			{
132			struct line *tlp;
133			int tbo;
134			int cp;
135			int bufo;
136			int c;
137			int inwindow;
138			char buf[NLINE];
139
140			/*
141			* Figure out if matching char is in current window by
142			* searching from the top of the window to dot.
143			*/
144			inwindow = FALSE;
145			for (tlp = curwp->w_linep; tlp != lforw(curwp->w_dotp);
146			tlp = lforw(tlp))
147			if (tlp == clp)
148			inwindow = TRUE;
149
150			if (inwindow == TRUE) {
151			tlp = curwp->w_dotp; /* save current position */
152			tbo = curwp->w_doto;
153
154			curwp->w_dotp = clp; /* move to new position */
155			curwp->w_doto = cbo;
156			curwp->w_rflag \|= WFMOVE;
157
158			update(CMODE); /* show match */
159			ttwait(1000); /* wait for key or 1 second */
160
161			curwp->w_dotp = tlp; /* return to old position */
162			curwp->w_doto = tbo;
163			curwp->w_rflag \|= WFMOVE;
164			update(CMODE);
165			} else {
166			/* match is not in this window, so display line in echo area */
167			bufo = 0;
168			for (cp = 0; cp < llength(clp); cp++) {
169			c = lgetc(clp, cp);
170			if (c != '\t'
171			#ifdef NOTAB
172			\|\| (curbp->b_flag & BFNOTAB)
173			#endif
174			)
175			if (ISCTRL(c)) {
176			buf[bufo++] = '^';
177			buf[bufo++] = CCHR(c);
178			} else
179			buf[bufo++] = c;
180			else
181			do {
182			buf[bufo++] = ' ';
183			} while (bufo & 7);
184			}
185			buf[bufo++] = '\0';
186			ewprintf("Matches %s", buf);
187			}
188			}