![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to macros.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to macros.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: #include "jove.h"
9: #include "ctype.h"
10: #include "fp.h"
11: #include "chars.h"
12: #include "disp.h"
13:
14: private void
15: add_mac proto((struct macro *)),
16: del_mac proto((struct macro *)),
17: pop_macro_stack proto((void)),
18: push_macro_stack proto((struct macro *, int));
19:
20: private struct macro *mac_exists proto((char *));
21:
22: #define SAVE 01 /* this macro needs saving to a file */
23:
24: struct macro *macros = 0; /* macros */
25: int InMacDefine = NO;
26:
27: private void
28: add_mac(new)
29: struct macro *new;
30: {
31: register struct macro *mp,
32: *prev = 0;
33:
34: for (mp = macros; mp != 0; prev = mp, mp = mp->m_nextm)
35: if (mp == new)
36: return;
37:
38: if (prev)
39: prev->m_nextm = new;
40: else
41: macros = new;
42: new->m_nextm = 0;
43: new->Type = MACRO;
44: }
45:
46: private void
47: del_mac(mac)
48: struct macro *mac;
49: {
50: register struct macro *m;
51:
52: for (m = macros; m != 0; m = m->m_nextm)
53: if (m->m_nextm == mac) {
54: m->m_nextm = mac->m_nextm;
55: break;
56: }
57: free(mac->Name);
58: free(mac->m_body);
59: free((char *) mac);
60: }
61:
62: struct macro KeyMacro; /* Macro used for defining */
63:
64: /* To execute a macro, we have a "stack" of running macros. Whenever
65: we execute a macro, we push it on the stack, run it, then pop it
66: from the stack. */
67: struct m_thread {
68: struct m_thread *mt_prev;
69: struct macro *mt_mp;
70: int mt_offset,
71: mt_count;
72: };
73:
74: private struct m_thread *mac_stack = 0;
75:
76: private struct m_thread *
77: alloc_mthread()
78: {
79: return (struct m_thread *) emalloc(sizeof (struct m_thread));
80: }
81:
82: private void
83: free_mthread(t)
84: struct m_thread *t;
85: {
86: free((char *) t);
87: }
88:
89: void
90: unwind_macro_stack()
91: {
92: while (mac_stack != 0)
93: pop_macro_stack();
94: }
95:
96: private void
97: pop_macro_stack()
98: {
99: register struct m_thread *m;
100:
101: if ((m = mac_stack) == 0)
102: return;
103: mac_stack = m->mt_prev;
104: free_mthread(m);
105: }
106:
107: private void
108: push_macro_stack(m, count)
109: register struct macro *m;
110: int count;
111: {
112: register struct m_thread *t;
113:
114: for (t = mac_stack; t != 0; t = t->mt_prev)
115: if (t->mt_mp == m)
116: complain("[Cannot execute macro recusively]");
117: if (count <= 0)
118: complain("[Cannot execute macro a negative number of times]");
119: t = alloc_mthread();
120: t->mt_prev = mac_stack;
121: mac_stack = t;
122: t->mt_offset = 0;
123: t->mt_mp = m;
124: t->mt_count = count;
125: }
126:
127: void
128: do_macro(mac)
129: struct macro *mac;
130: {
131: push_macro_stack(mac, arg_value());
132: }
133:
134: private struct macro *
135: mac_exists(name)
136: char *name;
137: {
138: register struct macro *mp;
139:
140: for (mp = macros; mp; mp = mp->m_nextm)
141: if (strcmp(mp->Name, name) == 0)
142: return mp;
143: return 0;
144: }
145:
146: void
147: mac_init()
148: {
149: add_mac(&KeyMacro);
150: KeyMacro.Name = "keyboard-macro";
151: KeyMacro.m_len = 0;
152: KeyMacro.m_buflen = 16;
153: KeyMacro.m_body = emalloc((size_t) KeyMacro.m_buflen);
154: }
155:
156: void
157: mac_putc(c)
158: int c;
159: {
160: if (KeyMacro.m_len >= KeyMacro.m_buflen) {
161: KeyMacro.m_buflen += 16;
162: KeyMacro.m_body = realloc(KeyMacro.m_body, (size_t) KeyMacro.m_buflen);
163: if (KeyMacro.m_body == 0) {
164: KeyMacro.m_buflen = KeyMacro.m_len = 0;
165: complain("[Can't allocate storage for keyboard macro]");
166: }
167: }
168: KeyMacro.m_body[KeyMacro.m_len++] = c;
169: }
170:
171: int
172: in_macro()
173: {
174: return (mac_stack != NULL);
175: }
176:
177: int
178: mac_getc()
179: {
180: struct m_thread *mthread;
181: struct macro *m;
182:
183: if ((mthread = mac_stack) == NULL)
184: return EOF;
185: m = mthread->mt_mp;
186: if (mthread->mt_offset == m->m_len) {
187: mthread->mt_offset = 0;
188: if (--mthread->mt_count == 0)
189: pop_macro_stack();
190: return mac_getc();
191: }
192: return m->m_body[mthread->mt_offset++];
193: }
194:
195: void
196: NameMac()
197: {
198: char *name;
199: struct macro *m;
200:
201: if (KeyMacro.m_len == 0)
202: complain("[No keyboard macro to name!]");
203: if (in_macro() || InMacDefine)
204: complain("[Can't name while defining/executing]");
205: if ((m = mac_exists(name = ask((char *) 0, ProcFmt))) == 0)
206: m = (struct macro *) emalloc(sizeof *m);
207: else {
208: if (strcmp(name, KeyMacro.Name) == 0)
209: complain("[Can't name it that!]");
210: free(m->Name);
211: free(m->m_body);
212: }
213: name = copystr(name);
214: m->Type = KeyMacro.Type;
215: m->m_len = KeyMacro.m_len;
216: m->m_buflen = KeyMacro.m_buflen;
217: m->m_body = emalloc((size_t) m->m_buflen);
218: byte_copy(KeyMacro.m_body, m->m_body, (size_t) m->m_len);
219: m->m_flags = SAVE;
220: m->Name = name;
221: add_mac(m);
222: }
223:
224: void
225: RunMacro()
226: {
227: struct macro *m;
228:
229: if ((m = (struct macro *) findmac(ProcFmt)) != NULL)
230: do_macro(m);
231: }
232:
233: private void
234: pr_putc(c, fp)
235: int c;
236: File *fp;
237: {
238: if (c == '\\' || c == '^')
239: jputc('\\', fp);
240: else if (isctrl(c)) {
241: jputc('^', fp);
242: c = (c == RUBOUT) ? '?' : (c + '@');
243: }
244: jputc(c, fp);
245: }
246:
247: void
248: WriteMacs()
249: {
250: struct macro *m;
251: char *file,
252: filebuf[FILESIZE];
253: File *fp;
254: int i;
255:
256: file = ask_file((char *) 0, (char *) 0, filebuf);
257: fp = open_file(file, iobuff, F_WRITE, YES, YES);
258:
259: /* Don't write the keyboard macro which is always the first */
260: for (m = macros->m_nextm; m != 0; m = m->m_nextm) {
261: fwritef(fp, "define-macro %s ", m->Name);
262: for (i = 0; i < m->m_len; i++)
263: pr_putc(m->m_body[i], fp);
264: jputc('\n', fp);
265: m->m_flags &= ~SAVE;
266: }
267: close_file(fp);
268: }
269:
270: void
271: DefKBDMac()
272: {
273: char *macro_name,
274: *macro_body,
275: nextc,
276: c,
277: macro_buffer[LBSIZE];
278: int i;
279: struct macro *m;
280:
281: macro_name = do_ask(" \r\n", (int (*) proto((int))) 0, (char *) 0,
282: ProcFmt);
283: if (macro_name == 0)
284: complain("[No default]");
285: macro_name = copystr(macro_name);
286: if ((m = mac_exists(macro_name)) != NULL)
287: del_mac(m);
288: macro_body = ask((char *) 0, ": %f %s enter body: ", macro_name);
289: i = 0;
290: while ((c = *macro_body++) != '\0') {
291: if (c == '\\') {
292: if ((nextc = *macro_body++) == LF)
293: complain("[Premature end of line]");
294: c = nextc;
295: } else if (c == '^') {
296: if ((nextc = *macro_body++) == '?')
297: c = RUBOUT;
298: else if (isalpha(nextc) || strchr("@[\\]^_", nextc))
299: c = CTL(nextc);
300: else
301: complain("Bad control-character: '%c'", nextc);
302: }
303: macro_buffer[i++] = c;
304: }
305: m = (struct macro *) emalloc(sizeof (*m));
306: m->Name = macro_name;
307: m->m_len = m->m_buflen = i;
308: m->m_body = emalloc((size_t) i);
309: m->m_flags = InJoverc ? 0 : SAVE;
310: byte_copy(macro_buffer, m->m_body, (size_t) i);
311: add_mac(m);
312: }
313:
314: void
315: Remember()
316: {
317: /* We're already executing the macro; ignore any attempts
318: to define the keyboard macro while we are executing. */
319: if (in_macro())
320: return;
321: if (InMacDefine)
322: message("[Already defining ... continue with definition]");
323: else {
324: UpdModLine = YES;
325: InMacDefine = YES;
326: KeyMacro.m_len = 0;
327: message("Defining...");
328: }
329: }
330:
331: void
332: Forget()
333: {
334: char *cp;
335: struct macro *m = &KeyMacro;
336:
337: UpdModLine = YES;
338: if (InMacDefine) {
339: message("Keyboard macro defined.");
340: InMacDefine = NO;
341:
342: /* try and strip off the key sequence that invoked us */
343: cp = &m->m_body[m->m_len - 2];
344: if (PrefChar(*cp))
345: m->m_len -= 2;
346: else if (commands[cp[1]].c_proc == Forget)
347: m->m_len -= 1;
348: } else
349: complain("[end-kbd-macro: not currently defining macro!]");
350: }
351:
352: void
353: ExecMacro()
354: {
355: do_macro(&KeyMacro);
356: }
357:
358: void
359: MacInter()
360: {
361: if (!Asking)
362: return;
363: Interactive = 1;
364: }
365:
366: int
367: ModMacs()
368: {
369: register struct macro *m;
370:
371: for (m = macros->m_nextm; m != 0; m = m->m_nextm)
372: if (m->m_flags & SAVE)
373: return YES;
374: return NO;
375: }
376:
377: data_obj *
378: findmac(prompt)
379: char *prompt;
380: {
381: char *strings[100];
382: register char **strs = strings;
383: register int com;
384: register struct macro *m = macros;
385:
386: for (; m != 0; m = m->m_nextm)
387: *strs++ = m->Name;
388: *strs = 0;
389:
390: if ((com = complete(strings, prompt, NOTHING)) < 0)
391: return 0;
392: m = macros;
393: while (--com >= 0)
394: m = m->m_nextm;
395: return (data_obj *) m;
396: }
397:
398: void
399: DelMacro()
400: {
401: struct macro *m;
402:
403: if ((m = (struct macro *) findmac(ProcFmt)) == 0)
404: return;
405: if (m == &KeyMacro)
406: complain("[It's illegal to delete the keyboard-macro!]");
407: del_mac(m);
408: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.