[unix-history] / usr / contrib / jove / macros.c

/*************************************************************************
 * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
 * provided to you without charge for use only on a licensed Unix        *
 * system.  You may copy JOVE provided that this notice is included with *
 * the copy.  You may not sell copies of this program or versions        *
 * modified for use on microcomputer systems, unless the copies are      *
 * included with a Unix system distribution and the source is provided.  *
 *************************************************************************/

#include "jove.h"

struct macro	*macros = 0;		/* Macros */
data_obj	*LastCmd;

static
add_mac(new)
struct macro	*new;
{
	register struct macro	*mp,
				*prev = 0;

	for (mp = macros; mp != 0; prev = mp, mp = mp->m_nextm)
		if (mp == new)
			return;

	if (prev)
		prev->m_nextm = new;
	else
		macros = new;
	new->m_nextm = 0;
	new->Type = MACRO;
}

static
del_mac(mac)
struct macro	*mac;
{
	register struct macro	*m;

	for (m = macros; m != 0; m = m->m_nextm)
		if (m->m_nextm == mac) {
			m->m_nextm = mac->m_nextm;
			break;
		}
	free(mac->Name);
	free(mac->m_body);
	free((char *) mac);
}

struct macro	KeyMacro;	/* Macro used for defining */

#define NMACROS	40		/* This is bad, bad, BAD! */

struct macro	*macstack[NMACROS];
static int	stackp = 0;

fix_macros()
{
	register int	i;
	register struct macro	*mp;

	for (i = 0; macstack[i]; i++) {
		mp = macstack[i];
		macstack[i] = 0;
		mp->m_flags = mp->m_offset = 0;
	}
	stackp = -1;
	KeyMacro.m_flags = KeyMacro.m_offset = 0;
}

static
mac_err(err)
char	*err;
{
	KeyMacro.m_flags = 0;
	MacNolen(&KeyMacro);
	complain(err);
}

do_macro(mac)
struct macro	*mac;
{
	if (mac->m_flags & EXECUTE)
		mac_err("[Attempt to execute macro recursively!]");
	if (++stackp >= NMACROS)
		complain("[Too many macros at once!]");
	macstack[stackp] = mac;
	mac->m_offset = 0;
	mac->m_ntimes = exp;
	mac->m_flags |= EXECUTE;
}

static
MacNolen(m)
struct macro	*m;
{
	m->m_len = m->m_offset = 0;
}

static struct macro *
mac_exists(name)
char	*name;
{
	register struct macro	*mp;

	for (mp = macros; mp; mp = mp->m_nextm)
		if (strcmp(mp->Name, name) == 0)
			return mp;
	return 0;
}

mac_init()
{
	add_mac(&KeyMacro);
	MacNolen(&KeyMacro);
	KeyMacro.Name = "keyboard-macro";
	KeyMacro.m_buflen = 16;
	KeyMacro.m_body = emalloc(KeyMacro.m_buflen);
	KeyMacro.m_ntimes = KeyMacro.m_flags = 0;
	fix_macros();
}

mac_putc(c)
int	c;
{
	if (KeyMacro.m_len >= KeyMacro.m_buflen) {
		KeyMacro.m_buflen += 16;
		KeyMacro.m_body = realloc(KeyMacro.m_body, (unsigned) KeyMacro.m_buflen);
		if (KeyMacro.m_body == 0)
			mac_err("[Can't allocate storage for keyboard macro]");
	}
	KeyMacro.m_body[KeyMacro.m_offset++] = c;
	KeyMacro.m_len++;
}

in_macro()
{
	return ((stackp >= 0) && ((macstack[stackp])->m_flags & EXECUTE));
}

mac_getc()
{
	struct macro	*m;

	if (stackp < 0 || ((m = macstack[stackp])->m_flags & EXECUTE) == 0)
		return -1;
	if (m->m_offset == m->m_len) {
		m->m_offset = 0;
		if (--m->m_ntimes == 0) {
			m->m_flags &= ~EXECUTE;
			stackp--;
		}
		return mac_getc();
	}
	return m->m_body[m->m_offset++];
}

NameMac()
{
	char	*name;
	struct macro	*m;

	if (KeyMacro.m_len == 0)
		complain("[No keyboard macro to name!]");
	if (KeyMacro.m_flags & (DEFINE | EXECUTE))
		complain("[Can't name while defining/executing]");
	if ((m = mac_exists(name = ask((char *) 0, ProcFmt))) == 0)
		m = (struct macro *) emalloc(sizeof *m);
	else {
		if (strcmp(name, KeyMacro.Name) == 0)
			complain("[Can't name it that!]");
		free(m->Name);
		free(m->m_body);
	}
	name = copystr(name);
	m->Type = KeyMacro.Type;
	m->m_len = KeyMacro.m_len;
	m->m_buflen = KeyMacro.m_buflen;
	m->m_body = emalloc(m->m_buflen);
	byte_copy(KeyMacro.m_body, m->m_body, m->m_len);
	m->m_ntimes = m->m_offset = 0;	/* At the beginning */
	m->m_flags = SAVE;
	m->Name = name;
	add_mac(m);
}	

RunMacro()
{
	struct macro	*m;

	if (m = (struct macro *) findmac(ProcFmt))
		do_macro(m);
}

static int	mac_fd;

static
mac_io(fcn, ptr, nbytes)
int	(*fcn)();
char	*ptr;
{
	int	nio;

	if ((nio = (*fcn)(mac_fd, ptr, nbytes)) != nbytes)
		complain("[Macro %s error: %d got %d]",
			 (fcn == read) ? "read" : "write",
			 nbytes,
			 nio);
}

WriteMacs()
{
	struct macro	*m;
	int	namelen,
		netl,
		nmacs = 0;
	char	*file,
		filebuf[FILESIZE];

	file = ask_file((char *) 0, filebuf);
	if ((mac_fd = creat(file, 0666)) == -1)
		complain(IOerr("create", file));
	f_mess("\"%s\"", file);

	/* Don't write the keyboard macro which is always the first */
	for (m = macros->m_nextm; m != 0; m = m->m_nextm) {
		if (m->m_len == 0)
			continue;
		nmacs++;
		netl = htonl(m->m_len);
		mac_io(write, (char *) &netl, sizeof m->m_len);
		namelen = strlen(m->Name) + 1;	/* Including the null */
		netl = htonl(namelen);
		mac_io(write, (char *) &netl, sizeof namelen);
		mac_io(write, m->Name, namelen);
		mac_io(write, m->m_body, m->m_len);
		m->m_flags &= ~SAVE;
	}
	(void) close(mac_fd);
	add_mess(" %d macro%n saved.", nmacs, nmacs);
}

#define NEWWAY	1
#define OLDWAY	0

static int	int_how = NEWWAY;

/* Formatting int's the old way or the new "improved" way? */

#ifndef BSD4_2

/* 4.2 (at least) has these functions defined. */

#if vax || pdp11
long htonl(x)
register long x;
{
	return(	(((x >>  0) & 0377) << 24) |
		(((x >>  8) & 0377) << 16) |
		(((x >> 16) & 0377) <<  8) |
		(((x >> 24) & 0377) <<  0) );
}

short htons(x)
register short x;
{
	return(	(((x >>  0) & 0377) << 8) |
		(((x >>  8) & 0377) << 0) );
}

long ntohl(x)
register long x;
{
	return(	(((x >>  0) & 0377) << 24) |
		(((x >>  8) & 0377) << 16) |
		(((x >> 16) & 0377) <<  8) |
		(((x >> 24) & 0377) <<  0) );
}

short ntohs(x)
register short x;
{
	return(	(((x >>  0) & 0377) << 8) |
		(((x >>  8) & 0377) << 0) );
}
#else
long htonl(x)
register long x;
{
	return(x);
}

short htons(x)
register short x;
{
	return(x);
}

long ntohl(x)
register long x;
{
	return(x);
}

short ntohs(x)
register short x;
{
	return(x);
}
#endif
#endif BSD4_2

int_fmt(i)
{
	if (int_how == NEWWAY)
		return ntohl(i);
	return i;
}

ReadMacs()
{
	char	*file,
		filebuf[FILESIZE];
	struct macro	*m;
	int	nmacs = 0,
		namelen,
		bodylen,
		tmp,
		he_is_sure = 0,
		save_em = FALSE;

	file = ask_file((char *) 0, filebuf);
	if ((mac_fd = open(file, 0)) == -1)
		complain(IOerr("open", file));

	f_mess("\"%s\"", file);
	while (read(mac_fd, (char *) &tmp, sizeof tmp) == (sizeof tmp)) {
retry:		bodylen = int_fmt(tmp);
		if (!he_is_sure && (bodylen <= 0 || bodylen > 10000)) {
			if (int_how == NEWWAY) {
				int_how = OLDWAY;
				save_em = TRUE;
				goto retry;
			} else {
				confirm("Are you sure \"%s\" is a JOVE macro file? ", filebuf);
				he_is_sure = 1;
			}
		}
		nmacs++;
		m = (struct macro *) emalloc (sizeof *m);
		m->m_flags = 0;
		m->m_len = bodylen;
		m->m_buflen = m->m_len;
		mac_io(read, (char *) &namelen, sizeof namelen);
		namelen = int_fmt(namelen);
		m->Name = emalloc(namelen);
		mac_io(read, m->Name, namelen);
		m->m_body = emalloc(m->m_buflen);
		mac_io(read, m->m_body, m->m_len);
		add_mac(m);
	}
	(void) close(mac_fd);
	add_mess(" %d macro%n defined.", nmacs, nmacs);
	if (save_em) {
		char	*msg = "OK to convert to the new format? ",
			ibuf[FILESIZE + 1];

		if (!InJoverc) {
			TOstart("Warning", TRUE);
			Typeout("Warning: your macros file is in the old format.");
			Typeout("Do you want me to convert \"%s\" to the new", pr_name(file));
			Typeout("format?");
			f_mess(msg);
			TOstop();
			confirm(msg);
		}
		/* WriteMacs requests a file name.  This is what it'll get. */
		sprintf(ibuf, "%s\n", file);
		Inputp = ibuf;
		WriteMacs();
	}		
}

Remember()
{
	if (KeyMacro.m_flags & EXECUTE)
		/* We're already executing the macro; ignore any attempts
		   to define the keyboard macro while we are executing. */
		return;
	if (KeyMacro.m_flags & DEFINE)
		message("[Already remembering ... continue with definition]");
	else {
		UpdModLine++;
		KeyMacro.m_flags |= DEFINE;
		MacNolen(&KeyMacro);
		message("Remembering...");
	}
}

/* Is `c' a prefix character */

static
PrefChar(c)
{
	return (int) IsPrefix(mainmap[c]);
}

Forget()
{
	char	*cp;
	struct macro	*m = &KeyMacro;

	UpdModLine++;
	if (m->m_flags & DEFINE) {
		message("Keyboard macro defined.");
		m->m_flags &= ~DEFINE;
		cp = &m->m_body[m->m_len - 2];
		if (PrefChar(*cp))
			m->m_len -= 2;
		else if (commands[*++cp].c_proc == Forget)
			m->m_len--;
	}
}

ExecMacro()
{
	do_macro(&KeyMacro);
}

MacInter()
{
	extern int	Interactive;

	if (!Asking)
		return;
	Interactive = 1;
}

ModMacs()
{
	register struct macro	*m;

	for (m = macros->m_nextm; m != 0; m = m->m_nextm)
		if (m->m_flags & SAVE)
			return 1;
	return 0;
}

data_obj *
findmac(prompt)
char	*prompt;
{
	char	*strings[100];
	register char	**strs = strings;
	register int	com;
	register struct macro	*m = macros;

	for (; m != 0; m = m->m_nextm)
		*strs++ = m->Name;
	*strs = 0;

	if ((com = complete(strings, prompt, NOTHING)) < 0)
		return 0;
	m = macros;
	while (--com >= 0)
		m = m->m_nextm;
	return (data_obj *) m;
}

DelMacro()
{
	struct macro	*m;

	if ((m = (struct macro *) findmac(ProcFmt)) == 0)
		return;
	if (m == &KeyMacro)
		complain("[It's illegal to delete the keyboard-macro!]");
	del_mac(m);
}
Commit	Line	Data
b346cbec C	1	/*************************************************************************
	2	* This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
	3	* provided to you without charge for use only on a licensed Unix *
	4	* system. You may copy JOVE provided that this notice is included with *
	5	* the copy. You may not sell copies of this program or versions *
	6	* modified for use on microcomputer systems, unless the copies are *
	7	* included with a Unix system distribution and the source is provided. *
	8	*************************************************************************/
	9
	10	#include "jove.h"
	11
	12	struct macro macros = 0; / Macros */
	13	data_obj *LastCmd;
	14
	15	static
	16	add_mac(new)
	17	struct macro *new;
	18	{
	19	register struct macro *mp,
	20	*prev = 0;
	21
	22	for (mp = macros; mp != 0; prev = mp, mp = mp->m_nextm)
	23	if (mp == new)
	24	return;
	25
	26	if (prev)
	27	prev->m_nextm = new;
	28	else
	29	macros = new;
	30	new->m_nextm = 0;
	31	new->Type = MACRO;
	32	}
	33
	34	static
	35	del_mac(mac)
	36	struct macro *mac;
	37	{
	38	register struct macro *m;
	39
	40	for (m = macros; m != 0; m = m->m_nextm)
	41	if (m->m_nextm == mac) {
	42	m->m_nextm = mac->m_nextm;
	43	break;
	44	}
	45	free(mac->Name);
	46	free(mac->m_body);
	47	free((char *) mac);
	48	}
	49
	50	struct macro KeyMacro; /* Macro used for defining */
	51
	52	#define NMACROS 40 /* This is bad, bad, BAD! */
	53
	54	struct macro *macstack[NMACROS];
	55	static int stackp = 0;
	56
	57	fix_macros()
	58	{
	59	register int i;
	60	register struct macro *mp;
	61
	62	for (i = 0; macstack[i]; i++) {
	63	mp = macstack[i];
	64	macstack[i] = 0;
65	mp->m_flags = mp->m_offset = 0;
66	}
67	stackp = -1;
68	KeyMacro.m_flags = KeyMacro.m_offset = 0;
69	}
70
71	static
72	mac_err(err)
73	char *err;
74	{
75	KeyMacro.m_flags = 0;
76	MacNolen(&KeyMacro);
77	complain(err);
78	}
79
80	do_macro(mac)
81	struct macro *mac;
82	{
83	if (mac->m_flags & EXECUTE)
84	mac_err("[Attempt to execute macro recursively!]");
85	if (++stackp >= NMACROS)
86	complain("[Too many macros at once!]");
87	macstack[stackp] = mac;
88	mac->m_offset = 0;
89	mac->m_ntimes = exp;
90	mac->m_flags \|= EXECUTE;
91	}
92
93	static
94	MacNolen(m)
95	struct macro *m;
96	{
97	m->m_len = m->m_offset = 0;
98	}
99
100	static struct macro *
101	mac_exists(name)
102	char *name;
103	{
104	register struct macro *mp;
105
106	for (mp = macros; mp; mp = mp->m_nextm)
107	if (strcmp(mp->Name, name) == 0)
108	return mp;
109	return 0;
110	}
111
112	mac_init()
113	{
114	add_mac(&KeyMacro);
115	MacNolen(&KeyMacro);
116	KeyMacro.Name = "keyboard-macro";
117	KeyMacro.m_buflen = 16;
118	KeyMacro.m_body = emalloc(KeyMacro.m_buflen);
119	KeyMacro.m_ntimes = KeyMacro.m_flags = 0;
120	fix_macros();
121	}
122
123	mac_putc(c)
124	int c;
125	{
126	if (KeyMacro.m_len >= KeyMacro.m_buflen) {
127	KeyMacro.m_buflen += 16;
128	KeyMacro.m_body = realloc(KeyMacro.m_body, (unsigned) KeyMacro.m_buflen);
129	if (KeyMacro.m_body == 0)
130	mac_err("[Can't allocate storage for keyboard macro]");
131	}
132	KeyMacro.m_body[KeyMacro.m_offset++] = c;
133	KeyMacro.m_len++;
134	}
135
136	in_macro()
137	{
138	return ((stackp >= 0) && ((macstack[stackp])->m_flags & EXECUTE));
139	}
140
141	mac_getc()
142	{
143	struct macro *m;
144
145	if (stackp < 0 \|\| ((m = macstack[stackp])->m_flags & EXECUTE) == 0)
146	return -1;
147	if (m->m_offset == m->m_len) {
148	m->m_offset = 0;
149	if (--m->m_ntimes == 0) {
150	m->m_flags &= ~EXECUTE;
151	stackp--;
152	}
153	return mac_getc();
154	}
155	return m->m_body[m->m_offset++];
156	}
157
158	NameMac()
159	{
160	char *name;
161	struct macro *m;
162
163	if (KeyMacro.m_len == 0)
164	complain("[No keyboard macro to name!]");
165	if (KeyMacro.m_flags & (DEFINE \| EXECUTE))
166	complain("[Can't name while defining/executing]");
167	if ((m = mac_exists(name = ask((char *) 0, ProcFmt))) == 0)
168	m = (struct macro ) emalloc(sizeof m);
169	else {
170	if (strcmp(name, KeyMacro.Name) == 0)
171	complain("[Can't name it that!]");
172	free(m->Name);
173	free(m->m_body);
174	}
175	name = copystr(name);
176	m->Type = KeyMacro.Type;
177	m->m_len = KeyMacro.m_len;
178	m->m_buflen = KeyMacro.m_buflen;
179	m->m_body = emalloc(m->m_buflen);
180	byte_copy(KeyMacro.m_body, m->m_body, m->m_len);
181	m->m_ntimes = m->m_offset = 0; /* At the beginning */
182	m->m_flags = SAVE;
183	m->Name = name;
184	add_mac(m);
185	}
186
187	RunMacro()
188	{
189	struct macro *m;
190
191	if (m = (struct macro *) findmac(ProcFmt))
192	do_macro(m);
193	}
194
195	static int mac_fd;
196
197	static
198	mac_io(fcn, ptr, nbytes)
199	int (*fcn)();
200	char *ptr;
201	{
202	int nio;
203
204	if ((nio = (*fcn)(mac_fd, ptr, nbytes)) != nbytes)
205	complain("[Macro %s error: %d got %d]",
206	(fcn == read) ? "read" : "write",
207	nbytes,
208	nio);
209	}
210
211	WriteMacs()
212	{
213	struct macro *m;
214	int namelen,
215	netl,
216	nmacs = 0;
217	char *file,
218	filebuf[FILESIZE];
219
220	file = ask_file((char *) 0, filebuf);
221	if ((mac_fd = creat(file, 0666)) == -1)
222	complain(IOerr("create", file));
223	f_mess("\"%s\"", file);
224
225	/* Don't write the keyboard macro which is always the first */
226	for (m = macros->m_nextm; m != 0; m = m->m_nextm) {
227	if (m->m_len == 0)
228	continue;
229	nmacs++;
230	netl = htonl(m->m_len);
231	mac_io(write, (char *) &netl, sizeof m->m_len);
232	namelen = strlen(m->Name) + 1; /* Including the null */
233	netl = htonl(namelen);
234	mac_io(write, (char *) &netl, sizeof namelen);
235	mac_io(write, m->Name, namelen);
236	mac_io(write, m->m_body, m->m_len);
237	m->m_flags &= ~SAVE;
238	}
239	(void) close(mac_fd);
240	add_mess(" %d macro%n saved.", nmacs, nmacs);
241	}
242
243	#define NEWWAY 1
244	#define OLDWAY 0
245
246	static int int_how = NEWWAY;
247
248	/* Formatting int's the old way or the new "improved" way? */
249
250	#ifndef BSD4_2
251
252	/* 4.2 (at least) has these functions defined. */
253
254	#if vax \|\| pdp11
255	long htonl(x)
256	register long x;
257	{
258	return( (((x >> 0) & 0377) << 24) \|
259	(((x >> 8) & 0377) << 16) \|
260	(((x >> 16) & 0377) << 8) \|
261	(((x >> 24) & 0377) << 0) );
262	}
263
264	short htons(x)
265	register short x;
266	{
267	return( (((x >> 0) & 0377) << 8) \|
268	(((x >> 8) & 0377) << 0) );
269	}
270
271	long ntohl(x)
272	register long x;
273	{
274	return( (((x >> 0) & 0377) << 24) \|
275	(((x >> 8) & 0377) << 16) \|
276	(((x >> 16) & 0377) << 8) \|
277	(((x >> 24) & 0377) << 0) );
278	}
279
280	short ntohs(x)
281	register short x;
282	{
283	return( (((x >> 0) & 0377) << 8) \|
284	(((x >> 8) & 0377) << 0) );
285	}
286	#else
287	long htonl(x)
288	register long x;
289	{
290	return(x);
291	}
292
293	short htons(x)
294	register short x;
295	{
296	return(x);
297	}
298
299	long ntohl(x)
300	register long x;
301	{
302	return(x);
303	}
304
305	short ntohs(x)
306	register short x;
307	{
308	return(x);
309	}
310	#endif
311	#endif BSD4_2
312
313	int_fmt(i)
314	{
315	if (int_how == NEWWAY)
316	return ntohl(i);
317	return i;
318	}
319
320	ReadMacs()
321	{
322	char *file,
323	filebuf[FILESIZE];
324	struct macro *m;
325	int nmacs = 0,
326	namelen,
327	bodylen,
328	tmp,
329	he_is_sure = 0,
330	save_em = FALSE;
331
332	file = ask_file((char *) 0, filebuf);
333	if ((mac_fd = open(file, 0)) == -1)
334	complain(IOerr("open", file));
335
336	f_mess("\"%s\"", file);
337	while (read(mac_fd, (char *) &tmp, sizeof tmp) == (sizeof tmp)) {
338	retry: bodylen = int_fmt(tmp);
339	if (!he_is_sure && (bodylen <= 0 \|\| bodylen > 10000)) {
340	if (int_how == NEWWAY) {
341	int_how = OLDWAY;
342	save_em = TRUE;
343	goto retry;
344	} else {
345	confirm("Are you sure \"%s\" is a JOVE macro file? ", filebuf);
346	he_is_sure = 1;
347	}
348	}
349	nmacs++;
350	m = (struct macro ) emalloc (sizeof m);
351	m->m_flags = 0;
352	m->m_len = bodylen;
353	m->m_buflen = m->m_len;
354	mac_io(read, (char *) &namelen, sizeof namelen);
355	namelen = int_fmt(namelen);
356	m->Name = emalloc(namelen);
357	mac_io(read, m->Name, namelen);
358	m->m_body = emalloc(m->m_buflen);
359	mac_io(read, m->m_body, m->m_len);
360	add_mac(m);
361	}
362	(void) close(mac_fd);
363	add_mess(" %d macro%n defined.", nmacs, nmacs);
364	if (save_em) {
365	char *msg = "OK to convert to the new format? ",
366	ibuf[FILESIZE + 1];
367
368	if (!InJoverc) {
369	TOstart("Warning", TRUE);
370	Typeout("Warning: your macros file is in the old format.");
371	Typeout("Do you want me to convert \"%s\" to the new", pr_name(file));
372	Typeout("format?");
373	f_mess(msg);
374	TOstop();
375	confirm(msg);
376	}
377	/* WriteMacs requests a file name. This is what it'll get. */
378	sprintf(ibuf, "%s\n", file);
379	Inputp = ibuf;
380	WriteMacs();
381	}
382	}
383
384	Remember()
385	{
386	if (KeyMacro.m_flags & EXECUTE)
387	/* We're already executing the macro; ignore any attempts
388	to define the keyboard macro while we are executing. */
389	return;
390	if (KeyMacro.m_flags & DEFINE)
391	message("[Already remembering ... continue with definition]");
392	else {
393	UpdModLine++;
394	KeyMacro.m_flags \|= DEFINE;
395	MacNolen(&KeyMacro);
396	message("Remembering...");
397	}
398	}
399
400	/* Is `c' a prefix character */
401
402	static
403	PrefChar(c)
404	{
405	return (int) IsPrefix(mainmap[c]);
406	}
407
408	Forget()
409	{
410	char *cp;
411	struct macro *m = &KeyMacro;
412
413	UpdModLine++;
414	if (m->m_flags & DEFINE) {
415	message("Keyboard macro defined.");
416	m->m_flags &= ~DEFINE;
417	cp = &m->m_body[m->m_len - 2];
418	if (PrefChar(*cp))
419	m->m_len -= 2;
420	else if (commands[*++cp].c_proc == Forget)
421	m->m_len--;
422	}
423	}
424
425	ExecMacro()
426	{
427	do_macro(&KeyMacro);
428	}
429
430	MacInter()
431	{
432	extern int Interactive;
433
434	if (!Asking)
435	return;
436	Interactive = 1;
437	}
438
439	ModMacs()
440	{
441	register struct macro *m;
442
443	for (m = macros->m_nextm; m != 0; m = m->m_nextm)
444	if (m->m_flags & SAVE)
445	return 1;
446	return 0;
447	}
448
449	data_obj *
450	findmac(prompt)
451	char *prompt;
452	{
453	char *strings[100];
454	register char **strs = strings;
455	register int com;
456	register struct macro *m = macros;
457
458	for (; m != 0; m = m->m_nextm)
459	*strs++ = m->Name;
460	*strs = 0;
461
462	if ((com = complete(strings, prompt, NOTHING)) < 0)
463	return 0;
464	m = macros;
465	while (--com >= 0)
466	m = m->m_nextm;
467	return (data_obj *) m;
468	}
469
470	DelMacro()
471	{
472	struct macro *m;
473
474	if ((m = (struct macro *) findmac(ProcFmt)) == 0)
475	return;
476	if (m == &KeyMacro)
477	complain("[It's illegal to delete the keyboard-macro!]");
478	del_mac(m);
479	}